| Index: third_party/sqlite/amalgamation/sqlite3.08.c
|
| diff --git a/third_party/sqlite/amalgamation/sqlite3.08.c b/third_party/sqlite/amalgamation/sqlite3.08.c
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..3621f05a878bcbd6b08b107eb715f5b49797c3e2
|
| --- /dev/null
|
| +++ b/third_party/sqlite/amalgamation/sqlite3.08.c
|
| @@ -0,0 +1,12938 @@
|
| +/************** Begin file sqlite3rbu.c **************************************/
|
| +/*
|
| +** 2014 August 30
|
| +**
|
| +** The author disclaims copyright to this source code. In place of
|
| +** a legal notice, here is a blessing:
|
| +**
|
| +** May you do good and not evil.
|
| +** May you find forgiveness for yourself and forgive others.
|
| +** May you share freely, never taking more than you give.
|
| +**
|
| +*************************************************************************
|
| +**
|
| +**
|
| +** OVERVIEW
|
| +**
|
| +** The RBU extension requires that the RBU update be packaged as an
|
| +** SQLite database. The tables it expects to find are described in
|
| +** sqlite3rbu.h. Essentially, for each table xyz in the target database
|
| +** that the user wishes to write to, a corresponding data_xyz table is
|
| +** created in the RBU database and populated with one row for each row to
|
| +** update, insert or delete from the target table.
|
| +**
|
| +** The update proceeds in three stages:
|
| +**
|
| +** 1) The database is updated. The modified database pages are written
|
| +** to a *-oal file. A *-oal file is just like a *-wal file, except
|
| +** that it is named "<database>-oal" instead of "<database>-wal".
|
| +** Because regular SQLite clients do not look for file named
|
| +** "<database>-oal", they go on using the original database in
|
| +** rollback mode while the *-oal file is being generated.
|
| +**
|
| +** During this stage RBU does not update the database by writing
|
| +** directly to the target tables. Instead it creates "imposter"
|
| +** tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses
|
| +** to update each b-tree individually. All updates required by each
|
| +** b-tree are completed before moving on to the next, and all
|
| +** updates are done in sorted key order.
|
| +**
|
| +** 2) The "<database>-oal" file is moved to the equivalent "<database>-wal"
|
| +** location using a call to rename(2). Before doing this the RBU
|
| +** module takes an EXCLUSIVE lock on the database file, ensuring
|
| +** that there are no other active readers.
|
| +**
|
| +** Once the EXCLUSIVE lock is released, any other database readers
|
| +** detect the new *-wal file and read the database in wal mode. At
|
| +** this point they see the new version of the database - including
|
| +** the updates made as part of the RBU update.
|
| +**
|
| +** 3) The new *-wal file is checkpointed. This proceeds in the same way
|
| +** as a regular database checkpoint, except that a single frame is
|
| +** checkpointed each time sqlite3rbu_step() is called. If the RBU
|
| +** handle is closed before the entire *-wal file is checkpointed,
|
| +** the checkpoint progress is saved in the RBU database and the
|
| +** checkpoint can be resumed by another RBU client at some point in
|
| +** the future.
|
| +**
|
| +** POTENTIAL PROBLEMS
|
| +**
|
| +** The rename() call might not be portable. And RBU is not currently
|
| +** syncing the directory after renaming the file.
|
| +**
|
| +** When state is saved, any commit to the *-oal file and the commit to
|
| +** the RBU update database are not atomic. So if the power fails at the
|
| +** wrong moment they might get out of sync. As the main database will be
|
| +** committed before the RBU update database this will likely either just
|
| +** pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE
|
| +** constraint violations).
|
| +**
|
| +** If some client does modify the target database mid RBU update, or some
|
| +** other error occurs, the RBU extension will keep throwing errors. It's
|
| +** not really clear how to get out of this state. The system could just
|
| +** by delete the RBU update database and *-oal file and have the device
|
| +** download the update again and start over.
|
| +**
|
| +** At present, for an UPDATE, both the new.* and old.* records are
|
| +** collected in the rbu_xyz table. And for both UPDATEs and DELETEs all
|
| +** fields are collected. This means we're probably writing a lot more
|
| +** data to disk when saving the state of an ongoing update to the RBU
|
| +** update database than is strictly necessary.
|
| +**
|
| +*/
|
| +
|
| +/* #include <assert.h> */
|
| +/* #include <string.h> */
|
| +/* #include <stdio.h> */
|
| +
|
| +/* #include "sqlite3.h" */
|
| +
|
| +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
|
| +/************** Include sqlite3rbu.h in the middle of sqlite3rbu.c ***********/
|
| +/************** Begin file sqlite3rbu.h **************************************/
|
| +/*
|
| +** 2014 August 30
|
| +**
|
| +** The author disclaims copyright to this source code. In place of
|
| +** a legal notice, here is a blessing:
|
| +**
|
| +** May you do good and not evil.
|
| +** May you find forgiveness for yourself and forgive others.
|
| +** May you share freely, never taking more than you give.
|
| +**
|
| +*************************************************************************
|
| +**
|
| +** This file contains the public interface for the RBU extension.
|
| +*/
|
| +
|
| +/*
|
| +** SUMMARY
|
| +**
|
| +** Writing a transaction containing a large number of operations on
|
| +** b-tree indexes that are collectively larger than the available cache
|
| +** memory can be very inefficient.
|
| +**
|
| +** The problem is that in order to update a b-tree, the leaf page (at least)
|
| +** containing the entry being inserted or deleted must be modified. If the
|
| +** working set of leaves is larger than the available cache memory, then a
|
| +** single leaf that is modified more than once as part of the transaction
|
| +** may be loaded from or written to the persistent media multiple times.
|
| +** Additionally, because the index updates are likely to be applied in
|
| +** random order, access to pages within the database is also likely to be in
|
| +** random order, which is itself quite inefficient.
|
| +**
|
| +** One way to improve the situation is to sort the operations on each index
|
| +** by index key before applying them to the b-tree. This leads to an IO
|
| +** pattern that resembles a single linear scan through the index b-tree,
|
| +** and all but guarantees each modified leaf page is loaded and stored
|
| +** exactly once. SQLite uses this trick to improve the performance of
|
| +** CREATE INDEX commands. This extension allows it to be used to improve
|
| +** the performance of large transactions on existing databases.
|
| +**
|
| +** Additionally, this extension allows the work involved in writing the
|
| +** large transaction to be broken down into sub-transactions performed
|
| +** sequentially by separate processes. This is useful if the system cannot
|
| +** guarantee that a single update process will run for long enough to apply
|
| +** the entire update, for example because the update is being applied on a
|
| +** mobile device that is frequently rebooted. Even after the writer process
|
| +** has committed one or more sub-transactions, other database clients continue
|
| +** to read from the original database snapshot. In other words, partially
|
| +** applied transactions are not visible to other clients.
|
| +**
|
| +** "RBU" stands for "Resumable Bulk Update". As in a large database update
|
| +** transmitted via a wireless network to a mobile device. A transaction
|
| +** applied using this extension is hence refered to as an "RBU update".
|
| +**
|
| +**
|
| +** LIMITATIONS
|
| +**
|
| +** An "RBU update" transaction is subject to the following limitations:
|
| +**
|
| +** * The transaction must consist of INSERT, UPDATE and DELETE operations
|
| +** only.
|
| +**
|
| +** * INSERT statements may not use any default values.
|
| +**
|
| +** * UPDATE and DELETE statements must identify their target rows by
|
| +** non-NULL PRIMARY KEY values. Rows with NULL values stored in PRIMARY
|
| +** KEY fields may not be updated or deleted. If the table being written
|
| +** has no PRIMARY KEY, affected rows must be identified by rowid.
|
| +**
|
| +** * UPDATE statements may not modify PRIMARY KEY columns.
|
| +**
|
| +** * No triggers will be fired.
|
| +**
|
| +** * No foreign key violations are detected or reported.
|
| +**
|
| +** * CHECK constraints are not enforced.
|
| +**
|
| +** * No constraint handling mode except for "OR ROLLBACK" is supported.
|
| +**
|
| +**
|
| +** PREPARATION
|
| +**
|
| +** An "RBU update" is stored as a separate SQLite database. A database
|
| +** containing an RBU update is an "RBU database". For each table in the
|
| +** target database to be updated, the RBU database should contain a table
|
| +** named "data_<target name>" containing the same set of columns as the
|
| +** target table, and one more - "rbu_control". The data_% table should
|
| +** have no PRIMARY KEY or UNIQUE constraints, but each column should have
|
| +** the same type as the corresponding column in the target database.
|
| +** The "rbu_control" column should have no type at all. For example, if
|
| +** the target database contains:
|
| +**
|
| +** CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c UNIQUE);
|
| +**
|
| +** Then the RBU database should contain:
|
| +**
|
| +** CREATE TABLE data_t1(a INTEGER, b TEXT, c, rbu_control);
|
| +**
|
| +** The order of the columns in the data_% table does not matter.
|
| +**
|
| +** Instead of a regular table, the RBU database may also contain virtual
|
| +** tables or view named using the data_<target> naming scheme.
|
| +**
|
| +** Instead of the plain data_<target> naming scheme, RBU database tables
|
| +** may also be named data<integer>_<target>, where <integer> is any sequence
|
| +** of zero or more numeric characters (0-9). This can be significant because
|
| +** tables within the RBU database are always processed in order sorted by
|
| +** name. By judicious selection of the <integer> portion of the names
|
| +** of the RBU tables the user can therefore control the order in which they
|
| +** are processed. This can be useful, for example, to ensure that "external
|
| +** content" FTS4 tables are updated before their underlying content tables.
|
| +**
|
| +** If the target database table is a virtual table or a table that has no
|
| +** PRIMARY KEY declaration, the data_% table must also contain a column
|
| +** named "rbu_rowid". This column is mapped to the tables implicit primary
|
| +** key column - "rowid". Virtual tables for which the "rowid" column does
|
| +** not function like a primary key value cannot be updated using RBU. For
|
| +** example, if the target db contains either of the following:
|
| +**
|
| +** CREATE VIRTUAL TABLE x1 USING fts3(a, b);
|
| +** CREATE TABLE x1(a, b)
|
| +**
|
| +** then the RBU database should contain:
|
| +**
|
| +** CREATE TABLE data_x1(a, b, rbu_rowid, rbu_control);
|
| +**
|
| +** All non-hidden columns (i.e. all columns matched by "SELECT *") of the
|
| +** target table must be present in the input table. For virtual tables,
|
| +** hidden columns are optional - they are updated by RBU if present in
|
| +** the input table, or not otherwise. For example, to write to an fts4
|
| +** table with a hidden languageid column such as:
|
| +**
|
| +** CREATE VIRTUAL TABLE ft1 USING fts4(a, b, languageid='langid');
|
| +**
|
| +** Either of the following input table schemas may be used:
|
| +**
|
| +** CREATE TABLE data_ft1(a, b, langid, rbu_rowid, rbu_control);
|
| +** CREATE TABLE data_ft1(a, b, rbu_rowid, rbu_control);
|
| +**
|
| +** For each row to INSERT into the target database as part of the RBU
|
| +** update, the corresponding data_% table should contain a single record
|
| +** with the "rbu_control" column set to contain integer value 0. The
|
| +** other columns should be set to the values that make up the new record
|
| +** to insert.
|
| +**
|
| +** If the target database table has an INTEGER PRIMARY KEY, it is not
|
| +** possible to insert a NULL value into the IPK column. Attempting to
|
| +** do so results in an SQLITE_MISMATCH error.
|
| +**
|
| +** For each row to DELETE from the target database as part of the RBU
|
| +** update, the corresponding data_% table should contain a single record
|
| +** with the "rbu_control" column set to contain integer value 1. The
|
| +** real primary key values of the row to delete should be stored in the
|
| +** corresponding columns of the data_% table. The values stored in the
|
| +** other columns are not used.
|
| +**
|
| +** For each row to UPDATE from the target database as part of the RBU
|
| +** update, the corresponding data_% table should contain a single record
|
| +** with the "rbu_control" column set to contain a value of type text.
|
| +** The real primary key values identifying the row to update should be
|
| +** stored in the corresponding columns of the data_% table row, as should
|
| +** the new values of all columns being update. The text value in the
|
| +** "rbu_control" column must contain the same number of characters as
|
| +** there are columns in the target database table, and must consist entirely
|
| +** of 'x' and '.' characters (or in some special cases 'd' - see below). For
|
| +** each column that is being updated, the corresponding character is set to
|
| +** 'x'. For those that remain as they are, the corresponding character of the
|
| +** rbu_control value should be set to '.'. For example, given the tables
|
| +** above, the update statement:
|
| +**
|
| +** UPDATE t1 SET c = 'usa' WHERE a = 4;
|
| +**
|
| +** is represented by the data_t1 row created by:
|
| +**
|
| +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..x');
|
| +**
|
| +** Instead of an 'x' character, characters of the rbu_control value specified
|
| +** for UPDATEs may also be set to 'd'. In this case, instead of updating the
|
| +** target table with the value stored in the corresponding data_% column, the
|
| +** user-defined SQL function "rbu_delta()" is invoked and the result stored in
|
| +** the target table column. rbu_delta() is invoked with two arguments - the
|
| +** original value currently stored in the target table column and the
|
| +** value specified in the data_xxx table.
|
| +**
|
| +** For example, this row:
|
| +**
|
| +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..d');
|
| +**
|
| +** is similar to an UPDATE statement such as:
|
| +**
|
| +** UPDATE t1 SET c = rbu_delta(c, 'usa') WHERE a = 4;
|
| +**
|
| +** Finally, if an 'f' character appears in place of a 'd' or 's' in an
|
| +** ota_control string, the contents of the data_xxx table column is assumed
|
| +** to be a "fossil delta" - a patch to be applied to a blob value in the
|
| +** format used by the fossil source-code management system. In this case
|
| +** the existing value within the target database table must be of type BLOB.
|
| +** It is replaced by the result of applying the specified fossil delta to
|
| +** itself.
|
| +**
|
| +** If the target database table is a virtual table or a table with no PRIMARY
|
| +** KEY, the rbu_control value should not include a character corresponding
|
| +** to the rbu_rowid value. For example, this:
|
| +**
|
| +** INSERT INTO data_ft1(a, b, rbu_rowid, rbu_control)
|
| +** VALUES(NULL, 'usa', 12, '.x');
|
| +**
|
| +** causes a result similar to:
|
| +**
|
| +** UPDATE ft1 SET b = 'usa' WHERE rowid = 12;
|
| +**
|
| +** The data_xxx tables themselves should have no PRIMARY KEY declarations.
|
| +** However, RBU is more efficient if reading the rows in from each data_xxx
|
| +** table in "rowid" order is roughly the same as reading them sorted by
|
| +** the PRIMARY KEY of the corresponding target database table. In other
|
| +** words, rows should be sorted using the destination table PRIMARY KEY
|
| +** fields before they are inserted into the data_xxx tables.
|
| +**
|
| +** USAGE
|
| +**
|
| +** The API declared below allows an application to apply an RBU update
|
| +** stored on disk to an existing target database. Essentially, the
|
| +** application:
|
| +**
|
| +** 1) Opens an RBU handle using the sqlite3rbu_open() function.
|
| +**
|
| +** 2) Registers any required virtual table modules with the database
|
| +** handle returned by sqlite3rbu_db(). Also, if required, register
|
| +** the rbu_delta() implementation.
|
| +**
|
| +** 3) Calls the sqlite3rbu_step() function one or more times on
|
| +** the new handle. Each call to sqlite3rbu_step() performs a single
|
| +** b-tree operation, so thousands of calls may be required to apply
|
| +** a complete update.
|
| +**
|
| +** 4) Calls sqlite3rbu_close() to close the RBU update handle. If
|
| +** sqlite3rbu_step() has been called enough times to completely
|
| +** apply the update to the target database, then the RBU database
|
| +** is marked as fully applied. Otherwise, the state of the RBU
|
| +** update application is saved in the RBU database for later
|
| +** resumption.
|
| +**
|
| +** See comments below for more detail on APIs.
|
| +**
|
| +** If an update is only partially applied to the target database by the
|
| +** time sqlite3rbu_close() is called, various state information is saved
|
| +** within the RBU database. This allows subsequent processes to automatically
|
| +** resume the RBU update from where it left off.
|
| +**
|
| +** To remove all RBU extension state information, returning an RBU database
|
| +** to its original contents, it is sufficient to drop all tables that begin
|
| +** with the prefix "rbu_"
|
| +**
|
| +** DATABASE LOCKING
|
| +**
|
| +** An RBU update may not be applied to a database in WAL mode. Attempting
|
| +** to do so is an error (SQLITE_ERROR).
|
| +**
|
| +** While an RBU handle is open, a SHARED lock may be held on the target
|
| +** database file. This means it is possible for other clients to read the
|
| +** database, but not to write it.
|
| +**
|
| +** If an RBU update is started and then suspended before it is completed,
|
| +** then an external client writes to the database, then attempting to resume
|
| +** the suspended RBU update is also an error (SQLITE_BUSY).
|
| +*/
|
| +
|
| +#ifndef _SQLITE3RBU_H
|
| +#define _SQLITE3RBU_H
|
| +
|
| +/* #include "sqlite3.h" ** Required for error code definitions ** */
|
| +
|
| +#if 0
|
| +extern "C" {
|
| +#endif
|
| +
|
| +typedef struct sqlite3rbu sqlite3rbu;
|
| +
|
| +/*
|
| +** Open an RBU handle.
|
| +**
|
| +** Argument zTarget is the path to the target database. Argument zRbu is
|
| +** the path to the RBU database. Each call to this function must be matched
|
| +** by a call to sqlite3rbu_close(). When opening the databases, RBU passes
|
| +** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget
|
| +** or zRbu begin with "file:", it will be interpreted as an SQLite
|
| +** database URI, not a regular file name.
|
| +**
|
| +** If the zState argument is passed a NULL value, the RBU extension stores
|
| +** the current state of the update (how many rows have been updated, which
|
| +** indexes are yet to be updated etc.) within the RBU database itself. This
|
| +** can be convenient, as it means that the RBU application does not need to
|
| +** organize removing a separate state file after the update is concluded.
|
| +** Or, if zState is non-NULL, it must be a path to a database file in which
|
| +** the RBU extension can store the state of the update.
|
| +**
|
| +** When resuming an RBU update, the zState argument must be passed the same
|
| +** value as when the RBU update was started.
|
| +**
|
| +** Once the RBU update is finished, the RBU extension does not
|
| +** automatically remove any zState database file, even if it created it.
|
| +**
|
| +** By default, RBU uses the default VFS to access the files on disk. To
|
| +** use a VFS other than the default, an SQLite "file:" URI containing a
|
| +** "vfs=..." option may be passed as the zTarget option.
|
| +**
|
| +** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of
|
| +** SQLite's built-in VFSs, including the multiplexor VFS. However it does
|
| +** not work out of the box with zipvfs. Refer to the comment describing
|
| +** the zipvfs_create_vfs() API below for details on using RBU with zipvfs.
|
| +*/
|
| +SQLITE_API sqlite3rbu *sqlite3rbu_open(
|
| + const char *zTarget,
|
| + const char *zRbu,
|
| + const char *zState
|
| +);
|
| +
|
| +/*
|
| +** Open an RBU handle to perform an RBU vacuum on database file zTarget.
|
| +** An RBU vacuum is similar to SQLite's built-in VACUUM command, except
|
| +** that it can be suspended and resumed like an RBU update.
|
| +**
|
| +** The second argument to this function identifies a database in which
|
| +** to store the state of the RBU vacuum operation if it is suspended. The
|
| +** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum
|
| +** operation, the state database should either not exist or be empty
|
| +** (contain no tables). If an RBU vacuum is suspended by calling
|
| +** sqlite3rbu_close() on the RBU handle before sqlite3rbu_step() has
|
| +** returned SQLITE_DONE, the vacuum state is stored in the state database.
|
| +** The vacuum can be resumed by calling this function to open a new RBU
|
| +** handle specifying the same target and state databases.
|
| +**
|
| +** If the second argument passed to this function is NULL, then the
|
| +** name of the state database is "<database>-vacuum", where <database>
|
| +** is the name of the target database file. In this case, on UNIX, if the
|
| +** state database is not already present in the file-system, it is created
|
| +** with the same permissions as the target db is made.
|
| +**
|
| +** This function does not delete the state database after an RBU vacuum
|
| +** is completed, even if it created it. However, if the call to
|
| +** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents
|
| +** of the state tables within the state database are zeroed. This way,
|
| +** the next call to sqlite3rbu_vacuum() opens a handle that starts a
|
| +** new RBU vacuum operation.
|
| +**
|
| +** As with sqlite3rbu_open(), Zipvfs users should rever to the comment
|
| +** describing the sqlite3rbu_create_vfs() API function below for
|
| +** a description of the complications associated with using RBU with
|
| +** zipvfs databases.
|
| +*/
|
| +SQLITE_API sqlite3rbu *sqlite3rbu_vacuum(
|
| + const char *zTarget,
|
| + const char *zState
|
| +);
|
| +
|
| +/*
|
| +** Internally, each RBU connection uses a separate SQLite database
|
| +** connection to access the target and rbu update databases. This
|
| +** API allows the application direct access to these database handles.
|
| +**
|
| +** The first argument passed to this function must be a valid, open, RBU
|
| +** handle. The second argument should be passed zero to access the target
|
| +** database handle, or non-zero to access the rbu update database handle.
|
| +** Accessing the underlying database handles may be useful in the
|
| +** following scenarios:
|
| +**
|
| +** * If any target tables are virtual tables, it may be necessary to
|
| +** call sqlite3_create_module() on the target database handle to
|
| +** register the required virtual table implementations.
|
| +**
|
| +** * If the data_xxx tables in the RBU source database are virtual
|
| +** tables, the application may need to call sqlite3_create_module() on
|
| +** the rbu update db handle to any required virtual table
|
| +** implementations.
|
| +**
|
| +** * If the application uses the "rbu_delta()" feature described above,
|
| +** it must use sqlite3_create_function() or similar to register the
|
| +** rbu_delta() implementation with the target database handle.
|
| +**
|
| +** If an error has occurred, either while opening or stepping the RBU object,
|
| +** this function may return NULL. The error code and message may be collected
|
| +** when sqlite3rbu_close() is called.
|
| +**
|
| +** Database handles returned by this function remain valid until the next
|
| +** call to any sqlite3rbu_xxx() function other than sqlite3rbu_db().
|
| +*/
|
| +SQLITE_API sqlite3 *sqlite3rbu_db(sqlite3rbu*, int bRbu);
|
| +
|
| +/*
|
| +** Do some work towards applying the RBU update to the target db.
|
| +**
|
| +** Return SQLITE_DONE if the update has been completely applied, or
|
| +** SQLITE_OK if no error occurs but there remains work to do to apply
|
| +** the RBU update. If an error does occur, some other error code is
|
| +** returned.
|
| +**
|
| +** Once a call to sqlite3rbu_step() has returned a value other than
|
| +** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
|
| +** that immediately return the same value.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_step(sqlite3rbu *pRbu);
|
| +
|
| +/*
|
| +** Force RBU to save its state to disk.
|
| +**
|
| +** If a power failure or application crash occurs during an update, following
|
| +** system recovery RBU may resume the update from the point at which the state
|
| +** was last saved. In other words, from the most recent successful call to
|
| +** sqlite3rbu_close() or this function.
|
| +**
|
| +** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *pRbu);
|
| +
|
| +/*
|
| +** Close an RBU handle.
|
| +**
|
| +** If the RBU update has been completely applied, mark the RBU database
|
| +** as fully applied. Otherwise, assuming no error has occurred, save the
|
| +** current state of the RBU update appliation to the RBU database.
|
| +**
|
| +** If an error has already occurred as part of an sqlite3rbu_step()
|
| +** or sqlite3rbu_open() call, or if one occurs within this function, an
|
| +** SQLite error code is returned. Additionally, *pzErrmsg may be set to
|
| +** point to a buffer containing a utf-8 formatted English language error
|
| +** message. It is the responsibility of the caller to eventually free any
|
| +** such buffer using sqlite3_free().
|
| +**
|
| +** Otherwise, if no error occurs, this function returns SQLITE_OK if the
|
| +** update has been partially applied, or SQLITE_DONE if it has been
|
| +** completely applied.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_close(sqlite3rbu *pRbu, char **pzErrmsg);
|
| +
|
| +/*
|
| +** Return the total number of key-value operations (inserts, deletes or
|
| +** updates) that have been performed on the target database since the
|
| +** current RBU update was started.
|
| +*/
|
| +SQLITE_API sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu);
|
| +
|
| +/*
|
| +** Obtain permyriadage (permyriadage is to 10000 as percentage is to 100)
|
| +** progress indications for the two stages of an RBU update. This API may
|
| +** be useful for driving GUI progress indicators and similar.
|
| +**
|
| +** An RBU update is divided into two stages:
|
| +**
|
| +** * Stage 1, in which changes are accumulated in an oal/wal file, and
|
| +** * Stage 2, in which the contents of the wal file are copied into the
|
| +** main database.
|
| +**
|
| +** The update is visible to non-RBU clients during stage 2. During stage 1
|
| +** non-RBU reader clients may see the original database.
|
| +**
|
| +** If this API is called during stage 2 of the update, output variable
|
| +** (*pnOne) is set to 10000 to indicate that stage 1 has finished and (*pnTwo)
|
| +** to a value between 0 and 10000 to indicate the permyriadage progress of
|
| +** stage 2. A value of 5000 indicates that stage 2 is half finished,
|
| +** 9000 indicates that it is 90% finished, and so on.
|
| +**
|
| +** If this API is called during stage 1 of the update, output variable
|
| +** (*pnTwo) is set to 0 to indicate that stage 2 has not yet started. The
|
| +** value to which (*pnOne) is set depends on whether or not the RBU
|
| +** database contains an "rbu_count" table. The rbu_count table, if it
|
| +** exists, must contain the same columns as the following:
|
| +**
|
| +** CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
|
| +**
|
| +** There must be one row in the table for each source (data_xxx) table within
|
| +** the RBU database. The 'tbl' column should contain the name of the source
|
| +** table. The 'cnt' column should contain the number of rows within the
|
| +** source table.
|
| +**
|
| +** If the rbu_count table is present and populated correctly and this
|
| +** API is called during stage 1, the *pnOne output variable is set to the
|
| +** permyriadage progress of the same stage. If the rbu_count table does
|
| +** not exist, then (*pnOne) is set to -1 during stage 1. If the rbu_count
|
| +** table exists but is not correctly populated, the value of the *pnOne
|
| +** output variable during stage 1 is undefined.
|
| +*/
|
| +SQLITE_API void sqlite3rbu_bp_progress(sqlite3rbu *pRbu, int *pnOne, int *pnTwo);
|
| +
|
| +/*
|
| +** Obtain an indication as to the current stage of an RBU update or vacuum.
|
| +** This function always returns one of the SQLITE_RBU_STATE_XXX constants
|
| +** defined in this file. Return values should be interpreted as follows:
|
| +**
|
| +** SQLITE_RBU_STATE_OAL:
|
| +** RBU is currently building a *-oal file. The next call to sqlite3rbu_step()
|
| +** may either add further data to the *-oal file, or compute data that will
|
| +** be added by a subsequent call.
|
| +**
|
| +** SQLITE_RBU_STATE_MOVE:
|
| +** RBU has finished building the *-oal file. The next call to sqlite3rbu_step()
|
| +** will move the *-oal file to the equivalent *-wal path. If the current
|
| +** operation is an RBU update, then the updated version of the database
|
| +** file will become visible to ordinary SQLite clients following the next
|
| +** call to sqlite3rbu_step().
|
| +**
|
| +** SQLITE_RBU_STATE_CHECKPOINT:
|
| +** RBU is currently performing an incremental checkpoint. The next call to
|
| +** sqlite3rbu_step() will copy a page of data from the *-wal file into
|
| +** the target database file.
|
| +**
|
| +** SQLITE_RBU_STATE_DONE:
|
| +** The RBU operation has finished. Any subsequent calls to sqlite3rbu_step()
|
| +** will immediately return SQLITE_DONE.
|
| +**
|
| +** SQLITE_RBU_STATE_ERROR:
|
| +** An error has occurred. Any subsequent calls to sqlite3rbu_step() will
|
| +** immediately return the SQLite error code associated with the error.
|
| +*/
|
| +#define SQLITE_RBU_STATE_OAL 1
|
| +#define SQLITE_RBU_STATE_MOVE 2
|
| +#define SQLITE_RBU_STATE_CHECKPOINT 3
|
| +#define SQLITE_RBU_STATE_DONE 4
|
| +#define SQLITE_RBU_STATE_ERROR 5
|
| +
|
| +SQLITE_API int sqlite3rbu_state(sqlite3rbu *pRbu);
|
| +
|
| +/*
|
| +** Create an RBU VFS named zName that accesses the underlying file-system
|
| +** via existing VFS zParent. Or, if the zParent parameter is passed NULL,
|
| +** then the new RBU VFS uses the default system VFS to access the file-system.
|
| +** The new object is registered as a non-default VFS with SQLite before
|
| +** returning.
|
| +**
|
| +** Part of the RBU implementation uses a custom VFS object. Usually, this
|
| +** object is created and deleted automatically by RBU.
|
| +**
|
| +** The exception is for applications that also use zipvfs. In this case,
|
| +** the custom VFS must be explicitly created by the user before the RBU
|
| +** handle is opened. The RBU VFS should be installed so that the zipvfs
|
| +** VFS uses the RBU VFS, which in turn uses any other VFS layers in use
|
| +** (for example multiplexor) to access the file-system. For example,
|
| +** to assemble an RBU enabled VFS stack that uses both zipvfs and
|
| +** multiplexor (error checking omitted):
|
| +**
|
| +** // Create a VFS named "multiplex" (not the default).
|
| +** sqlite3_multiplex_initialize(0, 0);
|
| +**
|
| +** // Create an rbu VFS named "rbu" that uses multiplexor. If the
|
| +** // second argument were replaced with NULL, the "rbu" VFS would
|
| +** // access the file-system via the system default VFS, bypassing the
|
| +** // multiplexor.
|
| +** sqlite3rbu_create_vfs("rbu", "multiplex");
|
| +**
|
| +** // Create a zipvfs VFS named "zipvfs" that uses rbu.
|
| +** zipvfs_create_vfs_v3("zipvfs", "rbu", 0, xCompressorAlgorithmDetector);
|
| +**
|
| +** // Make zipvfs the default VFS.
|
| +** sqlite3_vfs_register(sqlite3_vfs_find("zipvfs"), 1);
|
| +**
|
| +** Because the default VFS created above includes a RBU functionality, it
|
| +** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack
|
| +** that does not include the RBU layer results in an error.
|
| +**
|
| +** The overhead of adding the "rbu" VFS to the system is negligible for
|
| +** non-RBU users. There is no harm in an application accessing the
|
| +** file-system via "rbu" all the time, even if it only uses RBU functionality
|
| +** occasionally.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent);
|
| +
|
| +/*
|
| +** Deregister and destroy an RBU vfs created by an earlier call to
|
| +** sqlite3rbu_create_vfs().
|
| +**
|
| +** VFS objects are not reference counted. If a VFS object is destroyed
|
| +** before all database handles that use it have been closed, the results
|
| +** are undefined.
|
| +*/
|
| +SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
|
| +
|
| +#if 0
|
| +} /* end of the 'extern "C"' block */
|
| +#endif
|
| +
|
| +#endif /* _SQLITE3RBU_H */
|
| +
|
| +/************** End of sqlite3rbu.h ******************************************/
|
| +/************** Continuing where we left off in sqlite3rbu.c *****************/
|
| +
|
| +#if defined(_WIN32_WCE)
|
| +/* #include "windows.h" */
|
| +#endif
|
| +
|
| +/* Maximum number of prepared UPDATE statements held by this module */
|
| +#define SQLITE_RBU_UPDATE_CACHESIZE 16
|
| +
|
| +/*
|
| +** Swap two objects of type TYPE.
|
| +*/
|
| +#if !defined(SQLITE_AMALGAMATION)
|
| +# define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
|
| +#endif
|
| +
|
| +/*
|
| +** The rbu_state table is used to save the state of a partially applied
|
| +** update so that it can be resumed later. The table consists of integer
|
| +** keys mapped to values as follows:
|
| +**
|
| +** RBU_STATE_STAGE:
|
| +** May be set to integer values 1, 2, 4 or 5. As follows:
|
| +** 1: the *-rbu file is currently under construction.
|
| +** 2: the *-rbu file has been constructed, but not yet moved
|
| +** to the *-wal path.
|
| +** 4: the checkpoint is underway.
|
| +** 5: the rbu update has been checkpointed.
|
| +**
|
| +** RBU_STATE_TBL:
|
| +** Only valid if STAGE==1. The target database name of the table
|
| +** currently being written.
|
| +**
|
| +** RBU_STATE_IDX:
|
| +** Only valid if STAGE==1. The target database name of the index
|
| +** currently being written, or NULL if the main table is currently being
|
| +** updated.
|
| +**
|
| +** RBU_STATE_ROW:
|
| +** Only valid if STAGE==1. Number of rows already processed for the current
|
| +** table/index.
|
| +**
|
| +** RBU_STATE_PROGRESS:
|
| +** Trbul number of sqlite3rbu_step() calls made so far as part of this
|
| +** rbu update.
|
| +**
|
| +** RBU_STATE_CKPT:
|
| +** Valid if STAGE==4. The 64-bit checksum associated with the wal-index
|
| +** header created by recovering the *-wal file. This is used to detect
|
| +** cases when another client appends frames to the *-wal file in the
|
| +** middle of an incremental checkpoint (an incremental checkpoint cannot
|
| +** be continued if this happens).
|
| +**
|
| +** RBU_STATE_COOKIE:
|
| +** Valid if STAGE==1. The current change-counter cookie value in the
|
| +** target db file.
|
| +**
|
| +** RBU_STATE_OALSZ:
|
| +** Valid if STAGE==1. The size in bytes of the *-oal file.
|
| +*/
|
| +#define RBU_STATE_STAGE 1
|
| +#define RBU_STATE_TBL 2
|
| +#define RBU_STATE_IDX 3
|
| +#define RBU_STATE_ROW 4
|
| +#define RBU_STATE_PROGRESS 5
|
| +#define RBU_STATE_CKPT 6
|
| +#define RBU_STATE_COOKIE 7
|
| +#define RBU_STATE_OALSZ 8
|
| +#define RBU_STATE_PHASEONESTEP 9
|
| +
|
| +#define RBU_STAGE_OAL 1
|
| +#define RBU_STAGE_MOVE 2
|
| +#define RBU_STAGE_CAPTURE 3
|
| +#define RBU_STAGE_CKPT 4
|
| +#define RBU_STAGE_DONE 5
|
| +
|
| +
|
| +#define RBU_CREATE_STATE \
|
| + "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)"
|
| +
|
| +typedef struct RbuFrame RbuFrame;
|
| +typedef struct RbuObjIter RbuObjIter;
|
| +typedef struct RbuState RbuState;
|
| +typedef struct rbu_vfs rbu_vfs;
|
| +typedef struct rbu_file rbu_file;
|
| +typedef struct RbuUpdateStmt RbuUpdateStmt;
|
| +
|
| +#if !defined(SQLITE_AMALGAMATION)
|
| +typedef unsigned int u32;
|
| +typedef unsigned short u16;
|
| +typedef unsigned char u8;
|
| +typedef sqlite3_int64 i64;
|
| +#endif
|
| +
|
| +/*
|
| +** These values must match the values defined in wal.c for the equivalent
|
| +** locks. These are not magic numbers as they are part of the SQLite file
|
| +** format.
|
| +*/
|
| +#define WAL_LOCK_WRITE 0
|
| +#define WAL_LOCK_CKPT 1
|
| +#define WAL_LOCK_READ0 3
|
| +
|
| +#define SQLITE_FCNTL_RBUCNT 5149216
|
| +
|
| +/*
|
| +** A structure to store values read from the rbu_state table in memory.
|
| +*/
|
| +struct RbuState {
|
| + int eStage;
|
| + char *zTbl;
|
| + char *zIdx;
|
| + i64 iWalCksum;
|
| + int nRow;
|
| + i64 nProgress;
|
| + u32 iCookie;
|
| + i64 iOalSz;
|
| + i64 nPhaseOneStep;
|
| +};
|
| +
|
| +struct RbuUpdateStmt {
|
| + char *zMask; /* Copy of update mask used with pUpdate */
|
| + sqlite3_stmt *pUpdate; /* Last update statement (or NULL) */
|
| + RbuUpdateStmt *pNext;
|
| +};
|
| +
|
| +/*
|
| +** An iterator of this type is used to iterate through all objects in
|
| +** the target database that require updating. For each such table, the
|
| +** iterator visits, in order:
|
| +**
|
| +** * the table itself,
|
| +** * each index of the table (zero or more points to visit), and
|
| +** * a special "cleanup table" state.
|
| +**
|
| +** abIndexed:
|
| +** If the table has no indexes on it, abIndexed is set to NULL. Otherwise,
|
| +** it points to an array of flags nTblCol elements in size. The flag is
|
| +** set for each column that is either a part of the PK or a part of an
|
| +** index. Or clear otherwise.
|
| +**
|
| +*/
|
| +struct RbuObjIter {
|
| + sqlite3_stmt *pTblIter; /* Iterate through tables */
|
| + sqlite3_stmt *pIdxIter; /* Index iterator */
|
| + int nTblCol; /* Size of azTblCol[] array */
|
| + char **azTblCol; /* Array of unquoted target column names */
|
| + char **azTblType; /* Array of target column types */
|
| + int *aiSrcOrder; /* src table col -> target table col */
|
| + u8 *abTblPk; /* Array of flags, set on target PK columns */
|
| + u8 *abNotNull; /* Array of flags, set on NOT NULL columns */
|
| + u8 *abIndexed; /* Array of flags, set on indexed & PK cols */
|
| + int eType; /* Table type - an RBU_PK_XXX value */
|
| +
|
| + /* Output variables. zTbl==0 implies EOF. */
|
| + int bCleanup; /* True in "cleanup" state */
|
| + const char *zTbl; /* Name of target db table */
|
| + const char *zDataTbl; /* Name of rbu db table (or null) */
|
| + const char *zIdx; /* Name of target db index (or null) */
|
| + int iTnum; /* Root page of current object */
|
| + int iPkTnum; /* If eType==EXTERNAL, root of PK index */
|
| + int bUnique; /* Current index is unique */
|
| + int nIndex; /* Number of aux. indexes on table zTbl */
|
| +
|
| + /* Statements created by rbuObjIterPrepareAll() */
|
| + int nCol; /* Number of columns in current object */
|
| + sqlite3_stmt *pSelect; /* Source data */
|
| + sqlite3_stmt *pInsert; /* Statement for INSERT operations */
|
| + sqlite3_stmt *pDelete; /* Statement for DELETE ops */
|
| + sqlite3_stmt *pTmpInsert; /* Insert into rbu_tmp_$zDataTbl */
|
| +
|
| + /* Last UPDATE used (for PK b-tree updates only), or NULL. */
|
| + RbuUpdateStmt *pRbuUpdate;
|
| +};
|
| +
|
| +/*
|
| +** Values for RbuObjIter.eType
|
| +**
|
| +** 0: Table does not exist (error)
|
| +** 1: Table has an implicit rowid.
|
| +** 2: Table has an explicit IPK column.
|
| +** 3: Table has an external PK index.
|
| +** 4: Table is WITHOUT ROWID.
|
| +** 5: Table is a virtual table.
|
| +*/
|
| +#define RBU_PK_NOTABLE 0
|
| +#define RBU_PK_NONE 1
|
| +#define RBU_PK_IPK 2
|
| +#define RBU_PK_EXTERNAL 3
|
| +#define RBU_PK_WITHOUT_ROWID 4
|
| +#define RBU_PK_VTAB 5
|
| +
|
| +
|
| +/*
|
| +** Within the RBU_STAGE_OAL stage, each call to sqlite3rbu_step() performs
|
| +** one of the following operations.
|
| +*/
|
| +#define RBU_INSERT 1 /* Insert on a main table b-tree */
|
| +#define RBU_DELETE 2 /* Delete a row from a main table b-tree */
|
| +#define RBU_REPLACE 3 /* Delete and then insert a row */
|
| +#define RBU_IDX_DELETE 4 /* Delete a row from an aux. index b-tree */
|
| +#define RBU_IDX_INSERT 5 /* Insert on an aux. index b-tree */
|
| +
|
| +#define RBU_UPDATE 6 /* Update a row in a main table b-tree */
|
| +
|
| +/*
|
| +** A single step of an incremental checkpoint - frame iWalFrame of the wal
|
| +** file should be copied to page iDbPage of the database file.
|
| +*/
|
| +struct RbuFrame {
|
| + u32 iDbPage;
|
| + u32 iWalFrame;
|
| +};
|
| +
|
| +/*
|
| +** RBU handle.
|
| +**
|
| +** nPhaseOneStep:
|
| +** If the RBU database contains an rbu_count table, this value is set to
|
| +** a running estimate of the number of b-tree operations required to
|
| +** finish populating the *-oal file. This allows the sqlite3_bp_progress()
|
| +** API to calculate the permyriadage progress of populating the *-oal file
|
| +** using the formula:
|
| +**
|
| +** permyriadage = (10000 * nProgress) / nPhaseOneStep
|
| +**
|
| +** nPhaseOneStep is initialized to the sum of:
|
| +**
|
| +** nRow * (nIndex + 1)
|
| +**
|
| +** for all source tables in the RBU database, where nRow is the number
|
| +** of rows in the source table and nIndex the number of indexes on the
|
| +** corresponding target database table.
|
| +**
|
| +** This estimate is accurate if the RBU update consists entirely of
|
| +** INSERT operations. However, it is inaccurate if:
|
| +**
|
| +** * the RBU update contains any UPDATE operations. If the PK specified
|
| +** for an UPDATE operation does not exist in the target table, then
|
| +** no b-tree operations are required on index b-trees. Or if the
|
| +** specified PK does exist, then (nIndex*2) such operations are
|
| +** required (one delete and one insert on each index b-tree).
|
| +**
|
| +** * the RBU update contains any DELETE operations for which the specified
|
| +** PK does not exist. In this case no operations are required on index
|
| +** b-trees.
|
| +**
|
| +** * the RBU update contains REPLACE operations. These are similar to
|
| +** UPDATE operations.
|
| +**
|
| +** nPhaseOneStep is updated to account for the conditions above during the
|
| +** first pass of each source table. The updated nPhaseOneStep value is
|
| +** stored in the rbu_state table if the RBU update is suspended.
|
| +*/
|
| +struct sqlite3rbu {
|
| + int eStage; /* Value of RBU_STATE_STAGE field */
|
| + sqlite3 *dbMain; /* target database handle */
|
| + sqlite3 *dbRbu; /* rbu database handle */
|
| + char *zTarget; /* Path to target db */
|
| + char *zRbu; /* Path to rbu db */
|
| + char *zState; /* Path to state db (or NULL if zRbu) */
|
| + char zStateDb[5]; /* Db name for state ("stat" or "main") */
|
| + int rc; /* Value returned by last rbu_step() call */
|
| + char *zErrmsg; /* Error message if rc!=SQLITE_OK */
|
| + int nStep; /* Rows processed for current object */
|
| + int nProgress; /* Rows processed for all objects */
|
| + RbuObjIter objiter; /* Iterator for skipping through tbl/idx */
|
| + const char *zVfsName; /* Name of automatically created rbu vfs */
|
| + rbu_file *pTargetFd; /* File handle open on target db */
|
| + i64 iOalSz;
|
| + i64 nPhaseOneStep;
|
| +
|
| + /* The following state variables are used as part of the incremental
|
| + ** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding
|
| + ** function rbuSetupCheckpoint() for details. */
|
| + u32 iMaxFrame; /* Largest iWalFrame value in aFrame[] */
|
| + u32 mLock;
|
| + int nFrame; /* Entries in aFrame[] array */
|
| + int nFrameAlloc; /* Allocated size of aFrame[] array */
|
| + RbuFrame *aFrame;
|
| + int pgsz;
|
| + u8 *aBuf;
|
| + i64 iWalCksum;
|
| +
|
| + /* Used in RBU vacuum mode only */
|
| + int nRbu; /* Number of RBU VFS in the stack */
|
| + rbu_file *pRbuFd; /* Fd for main db of dbRbu */
|
| +};
|
| +
|
| +/*
|
| +** An rbu VFS is implemented using an instance of this structure.
|
| +*/
|
| +struct rbu_vfs {
|
| + sqlite3_vfs base; /* rbu VFS shim methods */
|
| + sqlite3_vfs *pRealVfs; /* Underlying VFS */
|
| + sqlite3_mutex *mutex; /* Mutex to protect pMain */
|
| + rbu_file *pMain; /* Linked list of main db files */
|
| +};
|
| +
|
| +/*
|
| +** Each file opened by an rbu VFS is represented by an instance of
|
| +** the following structure.
|
| +*/
|
| +struct rbu_file {
|
| + sqlite3_file base; /* sqlite3_file methods */
|
| + sqlite3_file *pReal; /* Underlying file handle */
|
| + rbu_vfs *pRbuVfs; /* Pointer to the rbu_vfs object */
|
| + sqlite3rbu *pRbu; /* Pointer to rbu object (rbu target only) */
|
| +
|
| + int openFlags; /* Flags this file was opened with */
|
| + u32 iCookie; /* Cookie value for main db files */
|
| + u8 iWriteVer; /* "write-version" value for main db files */
|
| + u8 bNolock; /* True to fail EXCLUSIVE locks */
|
| +
|
| + int nShm; /* Number of entries in apShm[] array */
|
| + char **apShm; /* Array of mmap'd *-shm regions */
|
| + char *zDel; /* Delete this when closing file */
|
| +
|
| + const char *zWal; /* Wal filename for this main db file */
|
| + rbu_file *pWalFd; /* Wal file descriptor for this main db */
|
| + rbu_file *pMainNext; /* Next MAIN_DB file */
|
| +};
|
| +
|
| +/*
|
| +** True for an RBU vacuum handle, or false otherwise.
|
| +*/
|
| +#define rbuIsVacuum(p) ((p)->zTarget==0)
|
| +
|
| +
|
| +/*************************************************************************
|
| +** The following three functions, found below:
|
| +**
|
| +** rbuDeltaGetInt()
|
| +** rbuDeltaChecksum()
|
| +** rbuDeltaApply()
|
| +**
|
| +** are lifted from the fossil source code (http://fossil-scm.org). They
|
| +** are used to implement the scalar SQL function rbu_fossil_delta().
|
| +*/
|
| +
|
| +/*
|
| +** Read bytes from *pz and convert them into a positive integer. When
|
| +** finished, leave *pz pointing to the first character past the end of
|
| +** the integer. The *pLen parameter holds the length of the string
|
| +** in *pz and is decremented once for each character in the integer.
|
| +*/
|
| +static unsigned int rbuDeltaGetInt(const char **pz, int *pLen){
|
| + static const signed char zValue[] = {
|
| + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
| + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
| + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
| + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
|
| + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
|
| + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, 36,
|
| + -1, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
|
| + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, -1, -1, 63, -1,
|
| + };
|
| + unsigned int v = 0;
|
| + int c;
|
| + unsigned char *z = (unsigned char*)*pz;
|
| + unsigned char *zStart = z;
|
| + while( (c = zValue[0x7f&*(z++)])>=0 ){
|
| + v = (v<<6) + c;
|
| + }
|
| + z--;
|
| + *pLen -= z - zStart;
|
| + *pz = (char*)z;
|
| + return v;
|
| +}
|
| +
|
| +/*
|
| +** Compute a 32-bit checksum on the N-byte buffer. Return the result.
|
| +*/
|
| +static unsigned int rbuDeltaChecksum(const char *zIn, size_t N){
|
| + const unsigned char *z = (const unsigned char *)zIn;
|
| + unsigned sum0 = 0;
|
| + unsigned sum1 = 0;
|
| + unsigned sum2 = 0;
|
| + unsigned sum3 = 0;
|
| + while(N >= 16){
|
| + sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]);
|
| + sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]);
|
| + sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]);
|
| + sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]);
|
| + z += 16;
|
| + N -= 16;
|
| + }
|
| + while(N >= 4){
|
| + sum0 += z[0];
|
| + sum1 += z[1];
|
| + sum2 += z[2];
|
| + sum3 += z[3];
|
| + z += 4;
|
| + N -= 4;
|
| + }
|
| + sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24);
|
| + switch(N){
|
| + case 3: sum3 += (z[2] << 8);
|
| + case 2: sum3 += (z[1] << 16);
|
| + case 1: sum3 += (z[0] << 24);
|
| + default: ;
|
| + }
|
| + return sum3;
|
| +}
|
| +
|
| +/*
|
| +** Apply a delta.
|
| +**
|
| +** The output buffer should be big enough to hold the whole output
|
| +** file and a NUL terminator at the end. The delta_output_size()
|
| +** routine will determine this size for you.
|
| +**
|
| +** The delta string should be null-terminated. But the delta string
|
| +** may contain embedded NUL characters (if the input and output are
|
| +** binary files) so we also have to pass in the length of the delta in
|
| +** the lenDelta parameter.
|
| +**
|
| +** This function returns the size of the output file in bytes (excluding
|
| +** the final NUL terminator character). Except, if the delta string is
|
| +** malformed or intended for use with a source file other than zSrc,
|
| +** then this routine returns -1.
|
| +**
|
| +** Refer to the delta_create() documentation above for a description
|
| +** of the delta file format.
|
| +*/
|
| +static int rbuDeltaApply(
|
| + const char *zSrc, /* The source or pattern file */
|
| + int lenSrc, /* Length of the source file */
|
| + const char *zDelta, /* Delta to apply to the pattern */
|
| + int lenDelta, /* Length of the delta */
|
| + char *zOut /* Write the output into this preallocated buffer */
|
| +){
|
| + unsigned int limit;
|
| + unsigned int total = 0;
|
| +#ifndef FOSSIL_OMIT_DELTA_CKSUM_TEST
|
| + char *zOrigOut = zOut;
|
| +#endif
|
| +
|
| + limit = rbuDeltaGetInt(&zDelta, &lenDelta);
|
| + if( *zDelta!='\n' ){
|
| + /* ERROR: size integer not terminated by "\n" */
|
| + return -1;
|
| + }
|
| + zDelta++; lenDelta--;
|
| + while( *zDelta && lenDelta>0 ){
|
| + unsigned int cnt, ofst;
|
| + cnt = rbuDeltaGetInt(&zDelta, &lenDelta);
|
| + switch( zDelta[0] ){
|
| + case '@': {
|
| + zDelta++; lenDelta--;
|
| + ofst = rbuDeltaGetInt(&zDelta, &lenDelta);
|
| + if( lenDelta>0 && zDelta[0]!=',' ){
|
| + /* ERROR: copy command not terminated by ',' */
|
| + return -1;
|
| + }
|
| + zDelta++; lenDelta--;
|
| + total += cnt;
|
| + if( total>limit ){
|
| + /* ERROR: copy exceeds output file size */
|
| + return -1;
|
| + }
|
| + if( (int)(ofst+cnt) > lenSrc ){
|
| + /* ERROR: copy extends past end of input */
|
| + return -1;
|
| + }
|
| + memcpy(zOut, &zSrc[ofst], cnt);
|
| + zOut += cnt;
|
| + break;
|
| + }
|
| + case ':': {
|
| + zDelta++; lenDelta--;
|
| + total += cnt;
|
| + if( total>limit ){
|
| + /* ERROR: insert command gives an output larger than predicted */
|
| + return -1;
|
| + }
|
| + if( (int)cnt>lenDelta ){
|
| + /* ERROR: insert count exceeds size of delta */
|
| + return -1;
|
| + }
|
| + memcpy(zOut, zDelta, cnt);
|
| + zOut += cnt;
|
| + zDelta += cnt;
|
| + lenDelta -= cnt;
|
| + break;
|
| + }
|
| + case ';': {
|
| + zDelta++; lenDelta--;
|
| + zOut[0] = 0;
|
| +#ifndef FOSSIL_OMIT_DELTA_CKSUM_TEST
|
| + if( cnt!=rbuDeltaChecksum(zOrigOut, total) ){
|
| + /* ERROR: bad checksum */
|
| + return -1;
|
| + }
|
| +#endif
|
| + if( total!=limit ){
|
| + /* ERROR: generated size does not match predicted size */
|
| + return -1;
|
| + }
|
| + return total;
|
| + }
|
| + default: {
|
| + /* ERROR: unknown delta operator */
|
| + return -1;
|
| + }
|
| + }
|
| + }
|
| + /* ERROR: unterminated delta */
|
| + return -1;
|
| +}
|
| +
|
| +static int rbuDeltaOutputSize(const char *zDelta, int lenDelta){
|
| + int size;
|
| + size = rbuDeltaGetInt(&zDelta, &lenDelta);
|
| + if( *zDelta!='\n' ){
|
| + /* ERROR: size integer not terminated by "\n" */
|
| + return -1;
|
| + }
|
| + return size;
|
| +}
|
| +
|
| +/*
|
| +** End of code taken from fossil.
|
| +*************************************************************************/
|
| +
|
| +/*
|
| +** Implementation of SQL scalar function rbu_fossil_delta().
|
| +**
|
| +** This function applies a fossil delta patch to a blob. Exactly two
|
| +** arguments must be passed to this function. The first is the blob to
|
| +** patch and the second the patch to apply. If no error occurs, this
|
| +** function returns the patched blob.
|
| +*/
|
| +static void rbuFossilDeltaFunc(
|
| + sqlite3_context *context,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + const char *aDelta;
|
| + int nDelta;
|
| + const char *aOrig;
|
| + int nOrig;
|
| +
|
| + int nOut;
|
| + int nOut2;
|
| + char *aOut;
|
| +
|
| + assert( argc==2 );
|
| +
|
| + nOrig = sqlite3_value_bytes(argv[0]);
|
| + aOrig = (const char*)sqlite3_value_blob(argv[0]);
|
| + nDelta = sqlite3_value_bytes(argv[1]);
|
| + aDelta = (const char*)sqlite3_value_blob(argv[1]);
|
| +
|
| + /* Figure out the size of the output */
|
| + nOut = rbuDeltaOutputSize(aDelta, nDelta);
|
| + if( nOut<0 ){
|
| + sqlite3_result_error(context, "corrupt fossil delta", -1);
|
| + return;
|
| + }
|
| +
|
| + aOut = sqlite3_malloc(nOut+1);
|
| + if( aOut==0 ){
|
| + sqlite3_result_error_nomem(context);
|
| + }else{
|
| + nOut2 = rbuDeltaApply(aOrig, nOrig, aDelta, nDelta, aOut);
|
| + if( nOut2!=nOut ){
|
| + sqlite3_result_error(context, "corrupt fossil delta", -1);
|
| + }else{
|
| + sqlite3_result_blob(context, aOut, nOut, sqlite3_free);
|
| + }
|
| + }
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Prepare the SQL statement in buffer zSql against database handle db.
|
| +** If successful, set *ppStmt to point to the new statement and return
|
| +** SQLITE_OK.
|
| +**
|
| +** Otherwise, if an error does occur, set *ppStmt to NULL and return
|
| +** an SQLite error code. Additionally, set output variable *pzErrmsg to
|
| +** point to a buffer containing an error message. It is the responsibility
|
| +** of the caller to (eventually) free this buffer using sqlite3_free().
|
| +*/
|
| +static int prepareAndCollectError(
|
| + sqlite3 *db,
|
| + sqlite3_stmt **ppStmt,
|
| + char **pzErrmsg,
|
| + const char *zSql
|
| +){
|
| + int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0);
|
| + if( rc!=SQLITE_OK ){
|
| + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
|
| + *ppStmt = 0;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Reset the SQL statement passed as the first argument. Return a copy
|
| +** of the value returned by sqlite3_reset().
|
| +**
|
| +** If an error has occurred, then set *pzErrmsg to point to a buffer
|
| +** containing an error message. It is the responsibility of the caller
|
| +** to eventually free this buffer using sqlite3_free().
|
| +*/
|
| +static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){
|
| + int rc = sqlite3_reset(pStmt);
|
| + if( rc!=SQLITE_OK ){
|
| + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt)));
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Unless it is NULL, argument zSql points to a buffer allocated using
|
| +** sqlite3_malloc containing an SQL statement. This function prepares the SQL
|
| +** statement against database db and frees the buffer. If statement
|
| +** compilation is successful, *ppStmt is set to point to the new statement
|
| +** handle and SQLITE_OK is returned.
|
| +**
|
| +** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code
|
| +** returned. In this case, *pzErrmsg may also be set to point to an error
|
| +** message. It is the responsibility of the caller to free this error message
|
| +** buffer using sqlite3_free().
|
| +**
|
| +** If argument zSql is NULL, this function assumes that an OOM has occurred.
|
| +** In this case SQLITE_NOMEM is returned and *ppStmt set to NULL.
|
| +*/
|
| +static int prepareFreeAndCollectError(
|
| + sqlite3 *db,
|
| + sqlite3_stmt **ppStmt,
|
| + char **pzErrmsg,
|
| + char *zSql
|
| +){
|
| + int rc;
|
| + assert( *pzErrmsg==0 );
|
| + if( zSql==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + *ppStmt = 0;
|
| + }else{
|
| + rc = prepareAndCollectError(db, ppStmt, pzErrmsg, zSql);
|
| + sqlite3_free(zSql);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Free the RbuObjIter.azTblCol[] and RbuObjIter.abTblPk[] arrays allocated
|
| +** by an earlier call to rbuObjIterCacheTableInfo().
|
| +*/
|
| +static void rbuObjIterFreeCols(RbuObjIter *pIter){
|
| + int i;
|
| + for(i=0; i<pIter->nTblCol; i++){
|
| + sqlite3_free(pIter->azTblCol[i]);
|
| + sqlite3_free(pIter->azTblType[i]);
|
| + }
|
| + sqlite3_free(pIter->azTblCol);
|
| + pIter->azTblCol = 0;
|
| + pIter->azTblType = 0;
|
| + pIter->aiSrcOrder = 0;
|
| + pIter->abTblPk = 0;
|
| + pIter->abNotNull = 0;
|
| + pIter->nTblCol = 0;
|
| + pIter->eType = 0; /* Invalid value */
|
| +}
|
| +
|
| +/*
|
| +** Finalize all statements and free all allocations that are specific to
|
| +** the current object (table/index pair).
|
| +*/
|
| +static void rbuObjIterClearStatements(RbuObjIter *pIter){
|
| + RbuUpdateStmt *pUp;
|
| +
|
| + sqlite3_finalize(pIter->pSelect);
|
| + sqlite3_finalize(pIter->pInsert);
|
| + sqlite3_finalize(pIter->pDelete);
|
| + sqlite3_finalize(pIter->pTmpInsert);
|
| + pUp = pIter->pRbuUpdate;
|
| + while( pUp ){
|
| + RbuUpdateStmt *pTmp = pUp->pNext;
|
| + sqlite3_finalize(pUp->pUpdate);
|
| + sqlite3_free(pUp);
|
| + pUp = pTmp;
|
| + }
|
| +
|
| + pIter->pSelect = 0;
|
| + pIter->pInsert = 0;
|
| + pIter->pDelete = 0;
|
| + pIter->pRbuUpdate = 0;
|
| + pIter->pTmpInsert = 0;
|
| + pIter->nCol = 0;
|
| +}
|
| +
|
| +/*
|
| +** Clean up any resources allocated as part of the iterator object passed
|
| +** as the only argument.
|
| +*/
|
| +static void rbuObjIterFinalize(RbuObjIter *pIter){
|
| + rbuObjIterClearStatements(pIter);
|
| + sqlite3_finalize(pIter->pTblIter);
|
| + sqlite3_finalize(pIter->pIdxIter);
|
| + rbuObjIterFreeCols(pIter);
|
| + memset(pIter, 0, sizeof(RbuObjIter));
|
| +}
|
| +
|
| +/*
|
| +** Advance the iterator to the next position.
|
| +**
|
| +** If no error occurs, SQLITE_OK is returned and the iterator is left
|
| +** pointing to the next entry. Otherwise, an error code and message is
|
| +** left in the RBU handle passed as the first argument. A copy of the
|
| +** error code is returned.
|
| +*/
|
| +static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){
|
| + int rc = p->rc;
|
| + if( rc==SQLITE_OK ){
|
| +
|
| + /* Free any SQLite statements used while processing the previous object */
|
| + rbuObjIterClearStatements(pIter);
|
| + if( pIter->zIdx==0 ){
|
| + rc = sqlite3_exec(p->dbMain,
|
| + "DROP TRIGGER IF EXISTS temp.rbu_insert_tr;"
|
| + "DROP TRIGGER IF EXISTS temp.rbu_update1_tr;"
|
| + "DROP TRIGGER IF EXISTS temp.rbu_update2_tr;"
|
| + "DROP TRIGGER IF EXISTS temp.rbu_delete_tr;"
|
| + , 0, 0, &p->zErrmsg
|
| + );
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + if( pIter->bCleanup ){
|
| + rbuObjIterFreeCols(pIter);
|
| + pIter->bCleanup = 0;
|
| + rc = sqlite3_step(pIter->pTblIter);
|
| + if( rc!=SQLITE_ROW ){
|
| + rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg);
|
| + pIter->zTbl = 0;
|
| + }else{
|
| + pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0);
|
| + pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1);
|
| + rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM;
|
| + }
|
| + }else{
|
| + if( pIter->zIdx==0 ){
|
| + sqlite3_stmt *pIdx = pIter->pIdxIter;
|
| + rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_step(pIter->pIdxIter);
|
| + if( rc!=SQLITE_ROW ){
|
| + rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg);
|
| + pIter->bCleanup = 1;
|
| + pIter->zIdx = 0;
|
| + }else{
|
| + pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0);
|
| + pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1);
|
| + pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2);
|
| + rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM;
|
| + }
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + if( rc!=SQLITE_OK ){
|
| + rbuObjIterFinalize(pIter);
|
| + p->rc = rc;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** The implementation of the rbu_target_name() SQL function. This function
|
| +** accepts one or two arguments. The first argument is the name of a table -
|
| +** the name of a table in the RBU database. The second, if it is present, is 1
|
| +** for a view or 0 for a table.
|
| +**
|
| +** For a non-vacuum RBU handle, if the table name matches the pattern:
|
| +**
|
| +** data[0-9]_<name>
|
| +**
|
| +** where <name> is any sequence of 1 or more characters, <name> is returned.
|
| +** Otherwise, if the only argument does not match the above pattern, an SQL
|
| +** NULL is returned.
|
| +**
|
| +** "data_t1" -> "t1"
|
| +** "data0123_t2" -> "t2"
|
| +** "dataAB_t3" -> NULL
|
| +**
|
| +** For an rbu vacuum handle, a copy of the first argument is returned if
|
| +** the second argument is either missing or 0 (not a view).
|
| +*/
|
| +static void rbuTargetNameFunc(
|
| + sqlite3_context *pCtx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + sqlite3rbu *p = sqlite3_user_data(pCtx);
|
| + const char *zIn;
|
| + assert( argc==1 || argc==2 );
|
| +
|
| + zIn = (const char*)sqlite3_value_text(argv[0]);
|
| + if( zIn ){
|
| + if( rbuIsVacuum(p) ){
|
| + if( argc==1 || 0==sqlite3_value_int(argv[1]) ){
|
| + sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC);
|
| + }
|
| + }else{
|
| + if( strlen(zIn)>4 && memcmp("data", zIn, 4)==0 ){
|
| + int i;
|
| + for(i=4; zIn[i]>='0' && zIn[i]<='9'; i++);
|
| + if( zIn[i]=='_' && zIn[i+1] ){
|
| + sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC);
|
| + }
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Initialize the iterator structure passed as the second argument.
|
| +**
|
| +** If no error occurs, SQLITE_OK is returned and the iterator is left
|
| +** pointing to the first entry. Otherwise, an error code and message is
|
| +** left in the RBU handle passed as the first argument. A copy of the
|
| +** error code is returned.
|
| +*/
|
| +static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){
|
| + int rc;
|
| + memset(pIter, 0, sizeof(RbuObjIter));
|
| +
|
| + rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg,
|
| + sqlite3_mprintf(
|
| + "SELECT rbu_target_name(name, type='view') AS target, name "
|
| + "FROM sqlite_master "
|
| + "WHERE type IN ('table', 'view') AND target IS NOT NULL "
|
| + " %s "
|
| + "ORDER BY name"
|
| + , rbuIsVacuum(p) ? "AND rootpage!=0 AND rootpage IS NOT NULL" : ""));
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg,
|
| + "SELECT name, rootpage, sql IS NULL OR substr(8, 6)=='UNIQUE' "
|
| + " FROM main.sqlite_master "
|
| + " WHERE type='index' AND tbl_name = ?"
|
| + );
|
| + }
|
| +
|
| + pIter->bCleanup = 1;
|
| + p->rc = rc;
|
| + return rbuObjIterNext(p, pIter);
|
| +}
|
| +
|
| +/*
|
| +** This is a wrapper around "sqlite3_mprintf(zFmt, ...)". If an OOM occurs,
|
| +** an error code is stored in the RBU handle passed as the first argument.
|
| +**
|
| +** If an error has already occurred (p->rc is already set to something other
|
| +** than SQLITE_OK), then this function returns NULL without modifying the
|
| +** stored error code. In this case it still calls sqlite3_free() on any
|
| +** printf() parameters associated with %z conversions.
|
| +*/
|
| +static char *rbuMPrintf(sqlite3rbu *p, const char *zFmt, ...){
|
| + char *zSql = 0;
|
| + va_list ap;
|
| + va_start(ap, zFmt);
|
| + zSql = sqlite3_vmprintf(zFmt, ap);
|
| + if( p->rc==SQLITE_OK ){
|
| + if( zSql==0 ) p->rc = SQLITE_NOMEM;
|
| + }else{
|
| + sqlite3_free(zSql);
|
| + zSql = 0;
|
| + }
|
| + va_end(ap);
|
| + return zSql;
|
| +}
|
| +
|
| +/*
|
| +** Argument zFmt is a sqlite3_mprintf() style format string. The trailing
|
| +** arguments are the usual subsitution values. This function performs
|
| +** the printf() style substitutions and executes the result as an SQL
|
| +** statement on the RBU handles database.
|
| +**
|
| +** If an error occurs, an error code and error message is stored in the
|
| +** RBU handle. If an error has already occurred when this function is
|
| +** called, it is a no-op.
|
| +*/
|
| +static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){
|
| + va_list ap;
|
| + char *zSql;
|
| + va_start(ap, zFmt);
|
| + zSql = sqlite3_vmprintf(zFmt, ap);
|
| + if( p->rc==SQLITE_OK ){
|
| + if( zSql==0 ){
|
| + p->rc = SQLITE_NOMEM;
|
| + }else{
|
| + p->rc = sqlite3_exec(db, zSql, 0, 0, &p->zErrmsg);
|
| + }
|
| + }
|
| + sqlite3_free(zSql);
|
| + va_end(ap);
|
| + return p->rc;
|
| +}
|
| +
|
| +/*
|
| +** Attempt to allocate and return a pointer to a zeroed block of nByte
|
| +** bytes.
|
| +**
|
| +** If an error (i.e. an OOM condition) occurs, return NULL and leave an
|
| +** error code in the rbu handle passed as the first argument. Or, if an
|
| +** error has already occurred when this function is called, return NULL
|
| +** immediately without attempting the allocation or modifying the stored
|
| +** error code.
|
| +*/
|
| +static void *rbuMalloc(sqlite3rbu *p, int nByte){
|
| + void *pRet = 0;
|
| + if( p->rc==SQLITE_OK ){
|
| + assert( nByte>0 );
|
| + pRet = sqlite3_malloc64(nByte);
|
| + if( pRet==0 ){
|
| + p->rc = SQLITE_NOMEM;
|
| + }else{
|
| + memset(pRet, 0, nByte);
|
| + }
|
| + }
|
| + return pRet;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that
|
| +** there is room for at least nCol elements. If an OOM occurs, store an
|
| +** error code in the RBU handle passed as the first argument.
|
| +*/
|
| +static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
|
| + int nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
|
| + char **azNew;
|
| +
|
| + azNew = (char**)rbuMalloc(p, nByte);
|
| + if( azNew ){
|
| + pIter->azTblCol = azNew;
|
| + pIter->azTblType = &azNew[nCol];
|
| + pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol];
|
| + pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol];
|
| + pIter->abNotNull = (u8*)&pIter->abTblPk[nCol];
|
| + pIter->abIndexed = (u8*)&pIter->abNotNull[nCol];
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** The first argument must be a nul-terminated string. This function
|
| +** returns a copy of the string in memory obtained from sqlite3_malloc().
|
| +** It is the responsibility of the caller to eventually free this memory
|
| +** using sqlite3_free().
|
| +**
|
| +** If an OOM condition is encountered when attempting to allocate memory,
|
| +** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise,
|
| +** if the allocation succeeds, (*pRc) is left unchanged.
|
| +*/
|
| +static char *rbuStrndup(const char *zStr, int *pRc){
|
| + char *zRet = 0;
|
| +
|
| + assert( *pRc==SQLITE_OK );
|
| + if( zStr ){
|
| + size_t nCopy = strlen(zStr) + 1;
|
| + zRet = (char*)sqlite3_malloc64(nCopy);
|
| + if( zRet ){
|
| + memcpy(zRet, zStr, nCopy);
|
| + }else{
|
| + *pRc = SQLITE_NOMEM;
|
| + }
|
| + }
|
| +
|
| + return zRet;
|
| +}
|
| +
|
| +/*
|
| +** Finalize the statement passed as the second argument.
|
| +**
|
| +** If the sqlite3_finalize() call indicates that an error occurs, and the
|
| +** rbu handle error code is not already set, set the error code and error
|
| +** message accordingly.
|
| +*/
|
| +static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){
|
| + sqlite3 *db = sqlite3_db_handle(pStmt);
|
| + int rc = sqlite3_finalize(pStmt);
|
| + if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){
|
| + p->rc = rc;
|
| + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
|
| + }
|
| +}
|
| +
|
| +/* Determine the type of a table.
|
| +**
|
| +** peType is of type (int*), a pointer to an output parameter of type
|
| +** (int). This call sets the output parameter as follows, depending
|
| +** on the type of the table specified by parameters dbName and zTbl.
|
| +**
|
| +** RBU_PK_NOTABLE: No such table.
|
| +** RBU_PK_NONE: Table has an implicit rowid.
|
| +** RBU_PK_IPK: Table has an explicit IPK column.
|
| +** RBU_PK_EXTERNAL: Table has an external PK index.
|
| +** RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID.
|
| +** RBU_PK_VTAB: Table is a virtual table.
|
| +**
|
| +** Argument *piPk is also of type (int*), and also points to an output
|
| +** parameter. Unless the table has an external primary key index
|
| +** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or,
|
| +** if the table does have an external primary key index, then *piPk
|
| +** is set to the root page number of the primary key index before
|
| +** returning.
|
| +**
|
| +** ALGORITHM:
|
| +**
|
| +** if( no entry exists in sqlite_master ){
|
| +** return RBU_PK_NOTABLE
|
| +** }else if( sql for the entry starts with "CREATE VIRTUAL" ){
|
| +** return RBU_PK_VTAB
|
| +** }else if( "PRAGMA index_list()" for the table contains a "pk" index ){
|
| +** if( the index that is the pk exists in sqlite_master ){
|
| +** *piPK = rootpage of that index.
|
| +** return RBU_PK_EXTERNAL
|
| +** }else{
|
| +** return RBU_PK_WITHOUT_ROWID
|
| +** }
|
| +** }else if( "PRAGMA table_info()" lists one or more "pk" columns ){
|
| +** return RBU_PK_IPK
|
| +** }else{
|
| +** return RBU_PK_NONE
|
| +** }
|
| +*/
|
| +static void rbuTableType(
|
| + sqlite3rbu *p,
|
| + const char *zTab,
|
| + int *peType,
|
| + int *piTnum,
|
| + int *piPk
|
| +){
|
| + /*
|
| + ** 0) SELECT count(*) FROM sqlite_master where name=%Q AND IsVirtual(%Q)
|
| + ** 1) PRAGMA index_list = ?
|
| + ** 2) SELECT count(*) FROM sqlite_master where name=%Q
|
| + ** 3) PRAGMA table_info = ?
|
| + */
|
| + sqlite3_stmt *aStmt[4] = {0, 0, 0, 0};
|
| +
|
| + *peType = RBU_PK_NOTABLE;
|
| + *piPk = 0;
|
| +
|
| + assert( p->rc==SQLITE_OK );
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg,
|
| + sqlite3_mprintf(
|
| + "SELECT (sql LIKE 'create virtual%%'), rootpage"
|
| + " FROM sqlite_master"
|
| + " WHERE name=%Q", zTab
|
| + ));
|
| + if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){
|
| + /* Either an error, or no such table. */
|
| + goto rbuTableType_end;
|
| + }
|
| + if( sqlite3_column_int(aStmt[0], 0) ){
|
| + *peType = RBU_PK_VTAB; /* virtual table */
|
| + goto rbuTableType_end;
|
| + }
|
| + *piTnum = sqlite3_column_int(aStmt[0], 1);
|
| +
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[1], &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA index_list=%Q",zTab)
|
| + );
|
| + if( p->rc ) goto rbuTableType_end;
|
| + while( sqlite3_step(aStmt[1])==SQLITE_ROW ){
|
| + const u8 *zOrig = sqlite3_column_text(aStmt[1], 3);
|
| + const u8 *zIdx = sqlite3_column_text(aStmt[1], 1);
|
| + if( zOrig && zIdx && zOrig[0]=='p' ){
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[2], &p->zErrmsg,
|
| + sqlite3_mprintf(
|
| + "SELECT rootpage FROM sqlite_master WHERE name = %Q", zIdx
|
| + ));
|
| + if( p->rc==SQLITE_OK ){
|
| + if( sqlite3_step(aStmt[2])==SQLITE_ROW ){
|
| + *piPk = sqlite3_column_int(aStmt[2], 0);
|
| + *peType = RBU_PK_EXTERNAL;
|
| + }else{
|
| + *peType = RBU_PK_WITHOUT_ROWID;
|
| + }
|
| + }
|
| + goto rbuTableType_end;
|
| + }
|
| + }
|
| +
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[3], &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA table_info=%Q",zTab)
|
| + );
|
| + if( p->rc==SQLITE_OK ){
|
| + while( sqlite3_step(aStmt[3])==SQLITE_ROW ){
|
| + if( sqlite3_column_int(aStmt[3],5)>0 ){
|
| + *peType = RBU_PK_IPK; /* explicit IPK column */
|
| + goto rbuTableType_end;
|
| + }
|
| + }
|
| + *peType = RBU_PK_NONE;
|
| + }
|
| +
|
| +rbuTableType_end: {
|
| + unsigned int i;
|
| + for(i=0; i<sizeof(aStmt)/sizeof(aStmt[0]); i++){
|
| + rbuFinalize(p, aStmt[i]);
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This is a helper function for rbuObjIterCacheTableInfo(). It populates
|
| +** the pIter->abIndexed[] array.
|
| +*/
|
| +static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
|
| + sqlite3_stmt *pList = 0;
|
| + int bIndex = 0;
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol);
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pList, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
|
| + );
|
| + }
|
| +
|
| + pIter->nIndex = 0;
|
| + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){
|
| + const char *zIdx = (const char*)sqlite3_column_text(pList, 1);
|
| + sqlite3_stmt *pXInfo = 0;
|
| + if( zIdx==0 ) break;
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
|
| + );
|
| + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
|
| + int iCid = sqlite3_column_int(pXInfo, 1);
|
| + if( iCid>=0 ) pIter->abIndexed[iCid] = 1;
|
| + }
|
| + rbuFinalize(p, pXInfo);
|
| + bIndex = 1;
|
| + pIter->nIndex++;
|
| + }
|
| +
|
| + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
|
| + /* "PRAGMA index_list" includes the main PK b-tree */
|
| + pIter->nIndex--;
|
| + }
|
| +
|
| + rbuFinalize(p, pList);
|
| + if( bIndex==0 ) pIter->abIndexed = 0;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** If they are not already populated, populate the pIter->azTblCol[],
|
| +** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to
|
| +** the table (not index) that the iterator currently points to.
|
| +**
|
| +** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
|
| +** an error does occur, an error code and error message are also left in
|
| +** the RBU handle.
|
| +*/
|
| +static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
|
| + if( pIter->azTblCol==0 ){
|
| + sqlite3_stmt *pStmt = 0;
|
| + int nCol = 0;
|
| + int i; /* for() loop iterator variable */
|
| + int bRbuRowid = 0; /* If input table has column "rbu_rowid" */
|
| + int iOrder = 0;
|
| + int iTnum = 0;
|
| +
|
| + /* Figure out the type of table this step will deal with. */
|
| + assert( pIter->eType==0 );
|
| + rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum);
|
| + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl);
|
| + }
|
| + if( p->rc ) return p->rc;
|
| + if( pIter->zIdx==0 ) pIter->iTnum = iTnum;
|
| +
|
| + assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK
|
| + || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID
|
| + || pIter->eType==RBU_PK_VTAB
|
| + );
|
| +
|
| + /* Populate the azTblCol[] and nTblCol variables based on the columns
|
| + ** of the input table. Ignore any input table columns that begin with
|
| + ** "rbu_". */
|
| + p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
|
| + sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl)
|
| + );
|
| + if( p->rc==SQLITE_OK ){
|
| + nCol = sqlite3_column_count(pStmt);
|
| + rbuAllocateIterArrays(p, pIter, nCol);
|
| + }
|
| + for(i=0; p->rc==SQLITE_OK && i<nCol; i++){
|
| + const char *zName = (const char*)sqlite3_column_name(pStmt, i);
|
| + if( sqlite3_strnicmp("rbu_", zName, 4) ){
|
| + char *zCopy = rbuStrndup(zName, &p->rc);
|
| + pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol;
|
| + pIter->azTblCol[pIter->nTblCol++] = zCopy;
|
| + }
|
| + else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){
|
| + bRbuRowid = 1;
|
| + }
|
| + }
|
| + sqlite3_finalize(pStmt);
|
| + pStmt = 0;
|
| +
|
| + if( p->rc==SQLITE_OK
|
| + && rbuIsVacuum(p)==0
|
| + && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
|
| + ){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf(
|
| + "table %q %s rbu_rowid column", pIter->zDataTbl,
|
| + (bRbuRowid ? "may not have" : "requires")
|
| + );
|
| + }
|
| +
|
| + /* Check that all non-HIDDEN columns in the destination table are also
|
| + ** present in the input table. Populate the abTblPk[], azTblType[] and
|
| + ** aiTblOrder[] arrays at the same time. */
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl)
|
| + );
|
| + }
|
| + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + const char *zName = (const char*)sqlite3_column_text(pStmt, 1);
|
| + if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */
|
| + for(i=iOrder; i<pIter->nTblCol; i++){
|
| + if( 0==strcmp(zName, pIter->azTblCol[i]) ) break;
|
| + }
|
| + if( i==pIter->nTblCol ){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("column missing from %q: %s",
|
| + pIter->zDataTbl, zName
|
| + );
|
| + }else{
|
| + int iPk = sqlite3_column_int(pStmt, 5);
|
| + int bNotNull = sqlite3_column_int(pStmt, 3);
|
| + const char *zType = (const char*)sqlite3_column_text(pStmt, 2);
|
| +
|
| + if( i!=iOrder ){
|
| + SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]);
|
| + SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]);
|
| + }
|
| +
|
| + pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
|
| + pIter->abTblPk[iOrder] = (iPk!=0);
|
| + pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
|
| + iOrder++;
|
| + }
|
| + }
|
| +
|
| + rbuFinalize(p, pStmt);
|
| + rbuObjIterCacheIndexedCols(p, pIter);
|
| + assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 );
|
| + assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 );
|
| + }
|
| +
|
| + return p->rc;
|
| +}
|
| +
|
| +/*
|
| +** This function constructs and returns a pointer to a nul-terminated
|
| +** string containing some SQL clause or list based on one or more of the
|
| +** column names currently stored in the pIter->azTblCol[] array.
|
| +*/
|
| +static char *rbuObjIterGetCollist(
|
| + sqlite3rbu *p, /* RBU object */
|
| + RbuObjIter *pIter /* Object iterator for column names */
|
| +){
|
| + char *zList = 0;
|
| + const char *zSep = "";
|
| + int i;
|
| + for(i=0; i<pIter->nTblCol; i++){
|
| + const char *z = pIter->azTblCol[i];
|
| + zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z);
|
| + zSep = ", ";
|
| + }
|
| + return zList;
|
| +}
|
| +
|
| +/*
|
| +** This function is used to create a SELECT list (the list of SQL
|
| +** expressions that follows a SELECT keyword) for a SELECT statement
|
| +** used to read from an data_xxx or rbu_tmp_xxx table while updating the
|
| +** index object currently indicated by the iterator object passed as the
|
| +** second argument. A "PRAGMA index_xinfo = <idxname>" statement is used
|
| +** to obtain the required information.
|
| +**
|
| +** If the index is of the following form:
|
| +**
|
| +** CREATE INDEX i1 ON t1(c, b COLLATE nocase);
|
| +**
|
| +** and "t1" is a table with an explicit INTEGER PRIMARY KEY column
|
| +** "ipk", the returned string is:
|
| +**
|
| +** "`c` COLLATE 'BINARY', `b` COLLATE 'NOCASE', `ipk` COLLATE 'BINARY'"
|
| +**
|
| +** As well as the returned string, three other malloc'd strings are
|
| +** returned via output parameters. As follows:
|
| +**
|
| +** pzImposterCols: ...
|
| +** pzImposterPk: ...
|
| +** pzWhere: ...
|
| +*/
|
| +static char *rbuObjIterGetIndexCols(
|
| + sqlite3rbu *p, /* RBU object */
|
| + RbuObjIter *pIter, /* Object iterator for column names */
|
| + char **pzImposterCols, /* OUT: Columns for imposter table */
|
| + char **pzImposterPk, /* OUT: Imposter PK clause */
|
| + char **pzWhere, /* OUT: WHERE clause */
|
| + int *pnBind /* OUT: Trbul number of columns */
|
| +){
|
| + int rc = p->rc; /* Error code */
|
| + int rc2; /* sqlite3_finalize() return code */
|
| + char *zRet = 0; /* String to return */
|
| + char *zImpCols = 0; /* String to return via *pzImposterCols */
|
| + char *zImpPK = 0; /* String to return via *pzImposterPK */
|
| + char *zWhere = 0; /* String to return via *pzWhere */
|
| + int nBind = 0; /* Value to return via *pnBind */
|
| + const char *zCom = ""; /* Set to ", " later on */
|
| + const char *zAnd = ""; /* Set to " AND " later on */
|
| + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = ? */
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + assert( p->zErrmsg==0 );
|
| + rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
|
| + );
|
| + }
|
| +
|
| + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
|
| + int iCid = sqlite3_column_int(pXInfo, 1);
|
| + int bDesc = sqlite3_column_int(pXInfo, 3);
|
| + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
|
| + const char *zCol;
|
| + const char *zType;
|
| +
|
| + if( iCid<0 ){
|
| + /* An integer primary key. If the table has an explicit IPK, use
|
| + ** its name. Otherwise, use "rbu_rowid". */
|
| + if( pIter->eType==RBU_PK_IPK ){
|
| + int i;
|
| + for(i=0; pIter->abTblPk[i]==0; i++);
|
| + assert( i<pIter->nTblCol );
|
| + zCol = pIter->azTblCol[i];
|
| + }else if( rbuIsVacuum(p) ){
|
| + zCol = "_rowid_";
|
| + }else{
|
| + zCol = "rbu_rowid";
|
| + }
|
| + zType = "INTEGER";
|
| + }else{
|
| + zCol = pIter->azTblCol[iCid];
|
| + zType = pIter->azTblType[iCid];
|
| + }
|
| +
|
| + zRet = sqlite3_mprintf("%z%s\"%w\" COLLATE %Q", zRet, zCom, zCol, zCollate);
|
| + if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){
|
| + const char *zOrder = (bDesc ? " DESC" : "");
|
| + zImpPK = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\"%s",
|
| + zImpPK, zCom, nBind, zCol, zOrder
|
| + );
|
| + }
|
| + zImpCols = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\" %s COLLATE %Q",
|
| + zImpCols, zCom, nBind, zCol, zType, zCollate
|
| + );
|
| + zWhere = sqlite3_mprintf(
|
| + "%z%s\"rbu_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol
|
| + );
|
| + if( zRet==0 || zImpPK==0 || zImpCols==0 || zWhere==0 ) rc = SQLITE_NOMEM;
|
| + zCom = ", ";
|
| + zAnd = " AND ";
|
| + nBind++;
|
| + }
|
| +
|
| + rc2 = sqlite3_finalize(pXInfo);
|
| + if( rc==SQLITE_OK ) rc = rc2;
|
| +
|
| + if( rc!=SQLITE_OK ){
|
| + sqlite3_free(zRet);
|
| + sqlite3_free(zImpCols);
|
| + sqlite3_free(zImpPK);
|
| + sqlite3_free(zWhere);
|
| + zRet = 0;
|
| + zImpCols = 0;
|
| + zImpPK = 0;
|
| + zWhere = 0;
|
| + p->rc = rc;
|
| + }
|
| +
|
| + *pzImposterCols = zImpCols;
|
| + *pzImposterPk = zImpPK;
|
| + *pzWhere = zWhere;
|
| + *pnBind = nBind;
|
| + return zRet;
|
| +}
|
| +
|
| +/*
|
| +** Assuming the current table columns are "a", "b" and "c", and the zObj
|
| +** paramter is passed "old", return a string of the form:
|
| +**
|
| +** "old.a, old.b, old.b"
|
| +**
|
| +** With the column names escaped.
|
| +**
|
| +** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append
|
| +** the text ", old._rowid_" to the returned value.
|
| +*/
|
| +static char *rbuObjIterGetOldlist(
|
| + sqlite3rbu *p,
|
| + RbuObjIter *pIter,
|
| + const char *zObj
|
| +){
|
| + char *zList = 0;
|
| + if( p->rc==SQLITE_OK && pIter->abIndexed ){
|
| + const char *zS = "";
|
| + int i;
|
| + for(i=0; i<pIter->nTblCol; i++){
|
| + if( pIter->abIndexed[i] ){
|
| + const char *zCol = pIter->azTblCol[i];
|
| + zList = sqlite3_mprintf("%z%s%s.\"%w\"", zList, zS, zObj, zCol);
|
| + }else{
|
| + zList = sqlite3_mprintf("%z%sNULL", zList, zS);
|
| + }
|
| + zS = ", ";
|
| + if( zList==0 ){
|
| + p->rc = SQLITE_NOMEM;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + /* For a table with implicit rowids, append "old._rowid_" to the list. */
|
| + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
|
| + zList = rbuMPrintf(p, "%z, %s._rowid_", zList, zObj);
|
| + }
|
| + }
|
| + return zList;
|
| +}
|
| +
|
| +/*
|
| +** Return an expression that can be used in a WHERE clause to match the
|
| +** primary key of the current table. For example, if the table is:
|
| +**
|
| +** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, c));
|
| +**
|
| +** Return the string:
|
| +**
|
| +** "b = ?1 AND c = ?2"
|
| +*/
|
| +static char *rbuObjIterGetWhere(
|
| + sqlite3rbu *p,
|
| + RbuObjIter *pIter
|
| +){
|
| + char *zList = 0;
|
| + if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){
|
| + zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1);
|
| + }else if( pIter->eType==RBU_PK_EXTERNAL ){
|
| + const char *zSep = "";
|
| + int i;
|
| + for(i=0; i<pIter->nTblCol; i++){
|
| + if( pIter->abTblPk[i] ){
|
| + zList = rbuMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1);
|
| + zSep = " AND ";
|
| + }
|
| + }
|
| + zList = rbuMPrintf(p,
|
| + "_rowid_ = (SELECT id FROM rbu_imposter2 WHERE %z)", zList
|
| + );
|
| +
|
| + }else{
|
| + const char *zSep = "";
|
| + int i;
|
| + for(i=0; i<pIter->nTblCol; i++){
|
| + if( pIter->abTblPk[i] ){
|
| + const char *zCol = pIter->azTblCol[i];
|
| + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1);
|
| + zSep = " AND ";
|
| + }
|
| + }
|
| + }
|
| + return zList;
|
| +}
|
| +
|
| +/*
|
| +** The SELECT statement iterating through the keys for the current object
|
| +** (p->objiter.pSelect) currently points to a valid row. However, there
|
| +** is something wrong with the rbu_control value in the rbu_control value
|
| +** stored in the (p->nCol+1)'th column. Set the error code and error message
|
| +** of the RBU handle to something reflecting this.
|
| +*/
|
| +static void rbuBadControlError(sqlite3rbu *p){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("invalid rbu_control value");
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Return a nul-terminated string containing the comma separated list of
|
| +** assignments that should be included following the "SET" keyword of
|
| +** an UPDATE statement used to update the table object that the iterator
|
| +** passed as the second argument currently points to if the rbu_control
|
| +** column of the data_xxx table entry is set to zMask.
|
| +**
|
| +** The memory for the returned string is obtained from sqlite3_malloc().
|
| +** It is the responsibility of the caller to eventually free it using
|
| +** sqlite3_free().
|
| +**
|
| +** If an OOM error is encountered when allocating space for the new
|
| +** string, an error code is left in the rbu handle passed as the first
|
| +** argument and NULL is returned. Or, if an error has already occurred
|
| +** when this function is called, NULL is returned immediately, without
|
| +** attempting the allocation or modifying the stored error code.
|
| +*/
|
| +static char *rbuObjIterGetSetlist(
|
| + sqlite3rbu *p,
|
| + RbuObjIter *pIter,
|
| + const char *zMask
|
| +){
|
| + char *zList = 0;
|
| + if( p->rc==SQLITE_OK ){
|
| + int i;
|
| +
|
| + if( (int)strlen(zMask)!=pIter->nTblCol ){
|
| + rbuBadControlError(p);
|
| + }else{
|
| + const char *zSep = "";
|
| + for(i=0; i<pIter->nTblCol; i++){
|
| + char c = zMask[pIter->aiSrcOrder[i]];
|
| + if( c=='x' ){
|
| + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d",
|
| + zList, zSep, pIter->azTblCol[i], i+1
|
| + );
|
| + zSep = ", ";
|
| + }
|
| + else if( c=='d' ){
|
| + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_delta(\"%w\", ?%d)",
|
| + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
|
| + );
|
| + zSep = ", ";
|
| + }
|
| + else if( c=='f' ){
|
| + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_fossil_delta(\"%w\", ?%d)",
|
| + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1
|
| + );
|
| + zSep = ", ";
|
| + }
|
| + }
|
| + }
|
| + }
|
| + return zList;
|
| +}
|
| +
|
| +/*
|
| +** Return a nul-terminated string consisting of nByte comma separated
|
| +** "?" expressions. For example, if nByte is 3, return a pointer to
|
| +** a buffer containing the string "?,?,?".
|
| +**
|
| +** The memory for the returned string is obtained from sqlite3_malloc().
|
| +** It is the responsibility of the caller to eventually free it using
|
| +** sqlite3_free().
|
| +**
|
| +** If an OOM error is encountered when allocating space for the new
|
| +** string, an error code is left in the rbu handle passed as the first
|
| +** argument and NULL is returned. Or, if an error has already occurred
|
| +** when this function is called, NULL is returned immediately, without
|
| +** attempting the allocation or modifying the stored error code.
|
| +*/
|
| +static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){
|
| + char *zRet = 0;
|
| + int nByte = nBind*2 + 1;
|
| +
|
| + zRet = (char*)rbuMalloc(p, nByte);
|
| + if( zRet ){
|
| + int i;
|
| + for(i=0; i<nBind; i++){
|
| + zRet[i*2] = '?';
|
| + zRet[i*2+1] = (i+1==nBind) ? '\0' : ',';
|
| + }
|
| + }
|
| + return zRet;
|
| +}
|
| +
|
| +/*
|
| +** The iterator currently points to a table (not index) of type
|
| +** RBU_PK_WITHOUT_ROWID. This function creates the PRIMARY KEY
|
| +** declaration for the corresponding imposter table. For example,
|
| +** if the iterator points to a table created as:
|
| +**
|
| +** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, a DESC)) WITHOUT ROWID
|
| +**
|
| +** this function returns:
|
| +**
|
| +** PRIMARY KEY("b", "a" DESC)
|
| +*/
|
| +static char *rbuWithoutRowidPK(sqlite3rbu *p, RbuObjIter *pIter){
|
| + char *z = 0;
|
| + assert( pIter->zIdx==0 );
|
| + if( p->rc==SQLITE_OK ){
|
| + const char *zSep = "PRIMARY KEY(";
|
| + sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */
|
| + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = <pk-index> */
|
| +
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pXList, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl)
|
| + );
|
| + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){
|
| + const char *zOrig = (const char*)sqlite3_column_text(pXList,3);
|
| + if( zOrig && strcmp(zOrig, "pk")==0 ){
|
| + const char *zIdx = (const char*)sqlite3_column_text(pXList,1);
|
| + if( zIdx ){
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
|
| + );
|
| + }
|
| + break;
|
| + }
|
| + }
|
| + rbuFinalize(p, pXList);
|
| +
|
| + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
|
| + if( sqlite3_column_int(pXInfo, 5) ){
|
| + /* int iCid = sqlite3_column_int(pXInfo, 0); */
|
| + const char *zCol = (const char*)sqlite3_column_text(pXInfo, 2);
|
| + const char *zDesc = sqlite3_column_int(pXInfo, 3) ? " DESC" : "";
|
| + z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc);
|
| + zSep = ", ";
|
| + }
|
| + }
|
| + z = rbuMPrintf(p, "%z)", z);
|
| + rbuFinalize(p, pXInfo);
|
| + }
|
| + return z;
|
| +}
|
| +
|
| +/*
|
| +** This function creates the second imposter table used when writing to
|
| +** a table b-tree where the table has an external primary key. If the
|
| +** iterator passed as the second argument does not currently point to
|
| +** a table (not index) with an external primary key, this function is a
|
| +** no-op.
|
| +**
|
| +** Assuming the iterator does point to a table with an external PK, this
|
| +** function creates a WITHOUT ROWID imposter table named "rbu_imposter2"
|
| +** used to access that PK index. For example, if the target table is
|
| +** declared as follows:
|
| +**
|
| +** CREATE TABLE t1(a, b TEXT, c REAL, PRIMARY KEY(b, c));
|
| +**
|
| +** then the imposter table schema is:
|
| +**
|
| +** CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID;
|
| +**
|
| +*/
|
| +static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){
|
| + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){
|
| + int tnum = pIter->iPkTnum; /* Root page of PK index */
|
| + sqlite3_stmt *pQuery = 0; /* SELECT name ... WHERE rootpage = $tnum */
|
| + const char *zIdx = 0; /* Name of PK index */
|
| + sqlite3_stmt *pXInfo = 0; /* PRAGMA main.index_xinfo = $zIdx */
|
| + const char *zComma = "";
|
| + char *zCols = 0; /* Used to build up list of table cols */
|
| + char *zPk = 0; /* Used to build up table PK declaration */
|
| +
|
| + /* Figure out the name of the primary key index for the current table.
|
| + ** This is needed for the argument to "PRAGMA index_xinfo". Set
|
| + ** zIdx to point to a nul-terminated string containing this name. */
|
| + p->rc = prepareAndCollectError(p->dbMain, &pQuery, &p->zErrmsg,
|
| + "SELECT name FROM sqlite_master WHERE rootpage = ?"
|
| + );
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_bind_int(pQuery, 1, tnum);
|
| + if( SQLITE_ROW==sqlite3_step(pQuery) ){
|
| + zIdx = (const char*)sqlite3_column_text(pQuery, 0);
|
| + }
|
| + }
|
| + if( zIdx ){
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
|
| + );
|
| + }
|
| + rbuFinalize(p, pQuery);
|
| +
|
| + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
|
| + int bKey = sqlite3_column_int(pXInfo, 5);
|
| + if( bKey ){
|
| + int iCid = sqlite3_column_int(pXInfo, 1);
|
| + int bDesc = sqlite3_column_int(pXInfo, 3);
|
| + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
|
| + zCols = rbuMPrintf(p, "%z%sc%d %s COLLATE %s", zCols, zComma,
|
| + iCid, pIter->azTblType[iCid], zCollate
|
| + );
|
| + zPk = rbuMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":"");
|
| + zComma = ", ";
|
| + }
|
| + }
|
| + zCols = rbuMPrintf(p, "%z, id INTEGER", zCols);
|
| + rbuFinalize(p, pXInfo);
|
| +
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum);
|
| + rbuMPrintfExec(p, p->dbMain,
|
| + "CREATE TABLE rbu_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID",
|
| + zCols, zPk
|
| + );
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** If an error has already occurred when this function is called, it
|
| +** immediately returns zero (without doing any work). Or, if an error
|
| +** occurs during the execution of this function, it sets the error code
|
| +** in the sqlite3rbu object indicated by the first argument and returns
|
| +** zero.
|
| +**
|
| +** The iterator passed as the second argument is guaranteed to point to
|
| +** a table (not an index) when this function is called. This function
|
| +** attempts to create any imposter table required to write to the main
|
| +** table b-tree of the table before returning. Non-zero is returned if
|
| +** an imposter table are created, or zero otherwise.
|
| +**
|
| +** An imposter table is required in all cases except RBU_PK_VTAB. Only
|
| +** virtual tables are written to directly. The imposter table has the
|
| +** same schema as the actual target table (less any UNIQUE constraints).
|
| +** More precisely, the "same schema" means the same columns, types,
|
| +** collation sequences. For tables that do not have an external PRIMARY
|
| +** KEY, it also means the same PRIMARY KEY declaration.
|
| +*/
|
| +static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){
|
| + if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){
|
| + int tnum = pIter->iTnum;
|
| + const char *zComma = "";
|
| + char *zSql = 0;
|
| + int iCol;
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1);
|
| +
|
| + for(iCol=0; p->rc==SQLITE_OK && iCol<pIter->nTblCol; iCol++){
|
| + const char *zPk = "";
|
| + const char *zCol = pIter->azTblCol[iCol];
|
| + const char *zColl = 0;
|
| +
|
| + p->rc = sqlite3_table_column_metadata(
|
| + p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0
|
| + );
|
| +
|
| + if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){
|
| + /* If the target table column is an "INTEGER PRIMARY KEY", add
|
| + ** "PRIMARY KEY" to the imposter table column declaration. */
|
| + zPk = "PRIMARY KEY ";
|
| + }
|
| + zSql = rbuMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %s%s",
|
| + zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl,
|
| + (pIter->abNotNull[iCol] ? " NOT NULL" : "")
|
| + );
|
| + zComma = ", ";
|
| + }
|
| +
|
| + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){
|
| + char *zPk = rbuWithoutRowidPK(p, pIter);
|
| + if( zPk ){
|
| + zSql = rbuMPrintf(p, "%z, %z", zSql, zPk);
|
| + }
|
| + }
|
| +
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum);
|
| + rbuMPrintfExec(p, p->dbMain, "CREATE TABLE \"rbu_imp_%w\"(%z)%s",
|
| + pIter->zTbl, zSql,
|
| + (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "")
|
| + );
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table.
|
| +** Specifically a statement of the form:
|
| +**
|
| +** INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...);
|
| +**
|
| +** The number of bound variables is equal to the number of columns in
|
| +** the target table, plus one (for the rbu_control column), plus one more
|
| +** (for the rbu_rowid column) if the target table is an implicit IPK or
|
| +** virtual table.
|
| +*/
|
| +static void rbuObjIterPrepareTmpInsert(
|
| + sqlite3rbu *p,
|
| + RbuObjIter *pIter,
|
| + const char *zCollist,
|
| + const char *zRbuRowid
|
| +){
|
| + int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE);
|
| + char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid);
|
| + if( zBind ){
|
| + assert( pIter->pTmpInsert==0 );
|
| + p->rc = prepareFreeAndCollectError(
|
| + p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf(
|
| + "INSERT INTO %s.'rbu_tmp_%q'(rbu_control,%s%s) VALUES(%z)",
|
| + p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind
|
| + ));
|
| + }
|
| +}
|
| +
|
| +static void rbuTmpInsertFunc(
|
| + sqlite3_context *pCtx,
|
| + int nVal,
|
| + sqlite3_value **apVal
|
| +){
|
| + sqlite3rbu *p = sqlite3_user_data(pCtx);
|
| + int rc = SQLITE_OK;
|
| + int i;
|
| +
|
| + assert( sqlite3_value_int(apVal[0])!=0
|
| + || p->objiter.eType==RBU_PK_EXTERNAL
|
| + || p->objiter.eType==RBU_PK_NONE
|
| + );
|
| + if( sqlite3_value_int(apVal[0])!=0 ){
|
| + p->nPhaseOneStep += p->objiter.nIndex;
|
| + }
|
| +
|
| + for(i=0; rc==SQLITE_OK && i<nVal; i++){
|
| + rc = sqlite3_bind_value(p->objiter.pTmpInsert, i+1, apVal[i]);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + sqlite3_step(p->objiter.pTmpInsert);
|
| + rc = sqlite3_reset(p->objiter.pTmpInsert);
|
| + }
|
| +
|
| + if( rc!=SQLITE_OK ){
|
| + sqlite3_result_error_code(pCtx, rc);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Ensure that the SQLite statement handles required to update the
|
| +** target database object currently indicated by the iterator passed
|
| +** as the second argument are available.
|
| +*/
|
| +static int rbuObjIterPrepareAll(
|
| + sqlite3rbu *p,
|
| + RbuObjIter *pIter,
|
| + int nOffset /* Add "LIMIT -1 OFFSET $nOffset" to SELECT */
|
| +){
|
| + assert( pIter->bCleanup==0 );
|
| + if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){
|
| + const int tnum = pIter->iTnum;
|
| + char *zCollist = 0; /* List of indexed columns */
|
| + char **pz = &p->zErrmsg;
|
| + const char *zIdx = pIter->zIdx;
|
| + char *zLimit = 0;
|
| +
|
| + if( nOffset ){
|
| + zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset);
|
| + if( !zLimit ) p->rc = SQLITE_NOMEM;
|
| + }
|
| +
|
| + if( zIdx ){
|
| + const char *zTbl = pIter->zTbl;
|
| + char *zImposterCols = 0; /* Columns for imposter table */
|
| + char *zImposterPK = 0; /* Primary key declaration for imposter */
|
| + char *zWhere = 0; /* WHERE clause on PK columns */
|
| + char *zBind = 0;
|
| + int nBind = 0;
|
| +
|
| + assert( pIter->eType!=RBU_PK_VTAB );
|
| + zCollist = rbuObjIterGetIndexCols(
|
| + p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind
|
| + );
|
| + zBind = rbuObjIterGetBindlist(p, nBind);
|
| +
|
| + /* Create the imposter table used to write to this index. */
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1);
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1,tnum);
|
| + rbuMPrintfExec(p, p->dbMain,
|
| + "CREATE TABLE \"rbu_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID",
|
| + zTbl, zImposterCols, zImposterPK
|
| + );
|
| + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0);
|
| +
|
| + /* Create the statement to insert index entries */
|
| + pIter->nCol = nBind;
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareFreeAndCollectError(
|
| + p->dbMain, &pIter->pInsert, &p->zErrmsg,
|
| + sqlite3_mprintf("INSERT INTO \"rbu_imp_%w\" VALUES(%s)", zTbl, zBind)
|
| + );
|
| + }
|
| +
|
| + /* And to delete index entries */
|
| + if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
|
| + p->rc = prepareFreeAndCollectError(
|
| + p->dbMain, &pIter->pDelete, &p->zErrmsg,
|
| + sqlite3_mprintf("DELETE FROM \"rbu_imp_%w\" WHERE %s", zTbl, zWhere)
|
| + );
|
| + }
|
| +
|
| + /* Create the SELECT statement to read keys in sorted order */
|
| + if( p->rc==SQLITE_OK ){
|
| + char *zSql;
|
| + if( rbuIsVacuum(p) ){
|
| + zSql = sqlite3_mprintf(
|
| + "SELECT %s, 0 AS rbu_control FROM '%q' ORDER BY %s%s",
|
| + zCollist,
|
| + pIter->zDataTbl,
|
| + zCollist, zLimit
|
| + );
|
| + }else
|
| +
|
| + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
|
| + zSql = sqlite3_mprintf(
|
| + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' ORDER BY %s%s",
|
| + zCollist, p->zStateDb, pIter->zDataTbl,
|
| + zCollist, zLimit
|
| + );
|
| + }else{
|
| + zSql = sqlite3_mprintf(
|
| + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' "
|
| + "UNION ALL "
|
| + "SELECT %s, rbu_control FROM '%q' "
|
| + "WHERE typeof(rbu_control)='integer' AND rbu_control!=1 "
|
| + "ORDER BY %s%s",
|
| + zCollist, p->zStateDb, pIter->zDataTbl,
|
| + zCollist, pIter->zDataTbl,
|
| + zCollist, zLimit
|
| + );
|
| + }
|
| + p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, zSql);
|
| + }
|
| +
|
| + sqlite3_free(zImposterCols);
|
| + sqlite3_free(zImposterPK);
|
| + sqlite3_free(zWhere);
|
| + sqlite3_free(zBind);
|
| + }else{
|
| + int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
|
| + ||(pIter->eType==RBU_PK_NONE)
|
| + ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p));
|
| + const char *zTbl = pIter->zTbl; /* Table this step applies to */
|
| + const char *zWrite; /* Imposter table name */
|
| +
|
| + char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid);
|
| + char *zWhere = rbuObjIterGetWhere(p, pIter);
|
| + char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old");
|
| + char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new");
|
| +
|
| + zCollist = rbuObjIterGetCollist(p, pIter);
|
| + pIter->nCol = pIter->nTblCol;
|
| +
|
| + /* Create the imposter table or tables (if required). */
|
| + rbuCreateImposterTable(p, pIter);
|
| + rbuCreateImposterTable2(p, pIter);
|
| + zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_");
|
| +
|
| + /* Create the INSERT statement to write to the target PK b-tree */
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz,
|
| + sqlite3_mprintf(
|
| + "INSERT INTO \"%s%w\"(%s%s) VALUES(%s)",
|
| + zWrite, zTbl, zCollist, (bRbuRowid ? ", _rowid_" : ""), zBindings
|
| + )
|
| + );
|
| + }
|
| +
|
| + /* Create the DELETE statement to write to the target PK b-tree.
|
| + ** Because it only performs INSERT operations, this is not required for
|
| + ** an rbu vacuum handle. */
|
| + if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){
|
| + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz,
|
| + sqlite3_mprintf(
|
| + "DELETE FROM \"%s%w\" WHERE %s", zWrite, zTbl, zWhere
|
| + )
|
| + );
|
| + }
|
| +
|
| + if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
|
| + const char *zRbuRowid = "";
|
| + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
|
| + zRbuRowid = ", rbu_rowid";
|
| + }
|
| +
|
| + /* Create the rbu_tmp_xxx table and the triggers to populate it. */
|
| + rbuMPrintfExec(p, p->dbRbu,
|
| + "CREATE TABLE IF NOT EXISTS %s.'rbu_tmp_%q' AS "
|
| + "SELECT *%s FROM '%q' WHERE 0;"
|
| + , p->zStateDb, pIter->zDataTbl
|
| + , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "")
|
| + , pIter->zDataTbl
|
| + );
|
| +
|
| + rbuMPrintfExec(p, p->dbMain,
|
| + "CREATE TEMP TRIGGER rbu_delete_tr BEFORE DELETE ON \"%s%w\" "
|
| + "BEGIN "
|
| + " SELECT rbu_tmp_insert(3, %s);"
|
| + "END;"
|
| +
|
| + "CREATE TEMP TRIGGER rbu_update1_tr BEFORE UPDATE ON \"%s%w\" "
|
| + "BEGIN "
|
| + " SELECT rbu_tmp_insert(3, %s);"
|
| + "END;"
|
| +
|
| + "CREATE TEMP TRIGGER rbu_update2_tr AFTER UPDATE ON \"%s%w\" "
|
| + "BEGIN "
|
| + " SELECT rbu_tmp_insert(4, %s);"
|
| + "END;",
|
| + zWrite, zTbl, zOldlist,
|
| + zWrite, zTbl, zOldlist,
|
| + zWrite, zTbl, zNewlist
|
| + );
|
| +
|
| + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
|
| + rbuMPrintfExec(p, p->dbMain,
|
| + "CREATE TEMP TRIGGER rbu_insert_tr AFTER INSERT ON \"%s%w\" "
|
| + "BEGIN "
|
| + " SELECT rbu_tmp_insert(0, %s);"
|
| + "END;",
|
| + zWrite, zTbl, zNewlist
|
| + );
|
| + }
|
| +
|
| + rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid);
|
| + }
|
| +
|
| + /* Create the SELECT statement to read keys from data_xxx */
|
| + if( p->rc==SQLITE_OK ){
|
| + const char *zRbuRowid = "";
|
| + if( bRbuRowid ){
|
| + zRbuRowid = rbuIsVacuum(p) ? ",_rowid_ " : ",rbu_rowid";
|
| + }
|
| + p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
|
| + sqlite3_mprintf(
|
| + "SELECT %s,%s rbu_control%s FROM '%q'%s",
|
| + zCollist,
|
| + (rbuIsVacuum(p) ? "0 AS " : ""),
|
| + zRbuRowid,
|
| + pIter->zDataTbl, zLimit
|
| + )
|
| + );
|
| + }
|
| +
|
| + sqlite3_free(zWhere);
|
| + sqlite3_free(zOldlist);
|
| + sqlite3_free(zNewlist);
|
| + sqlite3_free(zBindings);
|
| + }
|
| + sqlite3_free(zCollist);
|
| + sqlite3_free(zLimit);
|
| + }
|
| +
|
| + return p->rc;
|
| +}
|
| +
|
| +/*
|
| +** Set output variable *ppStmt to point to an UPDATE statement that may
|
| +** be used to update the imposter table for the main table b-tree of the
|
| +** table object that pIter currently points to, assuming that the
|
| +** rbu_control column of the data_xyz table contains zMask.
|
| +**
|
| +** If the zMask string does not specify any columns to update, then this
|
| +** is not an error. Output variable *ppStmt is set to NULL in this case.
|
| +*/
|
| +static int rbuGetUpdateStmt(
|
| + sqlite3rbu *p, /* RBU handle */
|
| + RbuObjIter *pIter, /* Object iterator */
|
| + const char *zMask, /* rbu_control value ('x.x.') */
|
| + sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */
|
| +){
|
| + RbuUpdateStmt **pp;
|
| + RbuUpdateStmt *pUp = 0;
|
| + int nUp = 0;
|
| +
|
| + /* In case an error occurs */
|
| + *ppStmt = 0;
|
| +
|
| + /* Search for an existing statement. If one is found, shift it to the front
|
| + ** of the LRU queue and return immediately. Otherwise, leave nUp pointing
|
| + ** to the number of statements currently in the cache and pUp to the
|
| + ** last object in the list. */
|
| + for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){
|
| + pUp = *pp;
|
| + if( strcmp(pUp->zMask, zMask)==0 ){
|
| + *pp = pUp->pNext;
|
| + pUp->pNext = pIter->pRbuUpdate;
|
| + pIter->pRbuUpdate = pUp;
|
| + *ppStmt = pUp->pUpdate;
|
| + return SQLITE_OK;
|
| + }
|
| + nUp++;
|
| + }
|
| + assert( pUp==0 || pUp->pNext==0 );
|
| +
|
| + if( nUp>=SQLITE_RBU_UPDATE_CACHESIZE ){
|
| + for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext));
|
| + *pp = 0;
|
| + sqlite3_finalize(pUp->pUpdate);
|
| + pUp->pUpdate = 0;
|
| + }else{
|
| + pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1);
|
| + }
|
| +
|
| + if( pUp ){
|
| + char *zWhere = rbuObjIterGetWhere(p, pIter);
|
| + char *zSet = rbuObjIterGetSetlist(p, pIter, zMask);
|
| + char *zUpdate = 0;
|
| +
|
| + pUp->zMask = (char*)&pUp[1];
|
| + memcpy(pUp->zMask, zMask, pIter->nTblCol);
|
| + pUp->pNext = pIter->pRbuUpdate;
|
| + pIter->pRbuUpdate = pUp;
|
| +
|
| + if( zSet ){
|
| + const char *zPrefix = "";
|
| +
|
| + if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_";
|
| + zUpdate = sqlite3_mprintf("UPDATE \"%s%w\" SET %s WHERE %s",
|
| + zPrefix, pIter->zTbl, zSet, zWhere
|
| + );
|
| + p->rc = prepareFreeAndCollectError(
|
| + p->dbMain, &pUp->pUpdate, &p->zErrmsg, zUpdate
|
| + );
|
| + *ppStmt = pUp->pUpdate;
|
| + }
|
| + sqlite3_free(zWhere);
|
| + sqlite3_free(zSet);
|
| + }
|
| +
|
| + return p->rc;
|
| +}
|
| +
|
| +static sqlite3 *rbuOpenDbhandle(
|
| + sqlite3rbu *p,
|
| + const char *zName,
|
| + int bUseVfs
|
| +){
|
| + sqlite3 *db = 0;
|
| + if( p->rc==SQLITE_OK ){
|
| + const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI;
|
| + p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0);
|
| + if( p->rc ){
|
| + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
|
| + sqlite3_close(db);
|
| + db = 0;
|
| + }
|
| + }
|
| + return db;
|
| +}
|
| +
|
| +/*
|
| +** Free an RbuState object allocated by rbuLoadState().
|
| +*/
|
| +static void rbuFreeState(RbuState *p){
|
| + if( p ){
|
| + sqlite3_free(p->zTbl);
|
| + sqlite3_free(p->zIdx);
|
| + sqlite3_free(p);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Allocate an RbuState object and load the contents of the rbu_state
|
| +** table into it. Return a pointer to the new object. It is the
|
| +** responsibility of the caller to eventually free the object using
|
| +** sqlite3_free().
|
| +**
|
| +** If an error occurs, leave an error code and message in the rbu handle
|
| +** and return NULL.
|
| +*/
|
| +static RbuState *rbuLoadState(sqlite3rbu *p){
|
| + RbuState *pRet = 0;
|
| + sqlite3_stmt *pStmt = 0;
|
| + int rc;
|
| + int rc2;
|
| +
|
| + pRet = (RbuState*)rbuMalloc(p, sizeof(RbuState));
|
| + if( pRet==0 ) return 0;
|
| +
|
| + rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
|
| + sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb)
|
| + );
|
| + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + switch( sqlite3_column_int(pStmt, 0) ){
|
| + case RBU_STATE_STAGE:
|
| + pRet->eStage = sqlite3_column_int(pStmt, 1);
|
| + if( pRet->eStage!=RBU_STAGE_OAL
|
| + && pRet->eStage!=RBU_STAGE_MOVE
|
| + && pRet->eStage!=RBU_STAGE_CKPT
|
| + ){
|
| + p->rc = SQLITE_CORRUPT;
|
| + }
|
| + break;
|
| +
|
| + case RBU_STATE_TBL:
|
| + pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
|
| + break;
|
| +
|
| + case RBU_STATE_IDX:
|
| + pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
|
| + break;
|
| +
|
| + case RBU_STATE_ROW:
|
| + pRet->nRow = sqlite3_column_int(pStmt, 1);
|
| + break;
|
| +
|
| + case RBU_STATE_PROGRESS:
|
| + pRet->nProgress = sqlite3_column_int64(pStmt, 1);
|
| + break;
|
| +
|
| + case RBU_STATE_CKPT:
|
| + pRet->iWalCksum = sqlite3_column_int64(pStmt, 1);
|
| + break;
|
| +
|
| + case RBU_STATE_COOKIE:
|
| + pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1);
|
| + break;
|
| +
|
| + case RBU_STATE_OALSZ:
|
| + pRet->iOalSz = (u32)sqlite3_column_int64(pStmt, 1);
|
| + break;
|
| +
|
| + case RBU_STATE_PHASEONESTEP:
|
| + pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1);
|
| + break;
|
| +
|
| + default:
|
| + rc = SQLITE_CORRUPT;
|
| + break;
|
| + }
|
| + }
|
| + rc2 = sqlite3_finalize(pStmt);
|
| + if( rc==SQLITE_OK ) rc = rc2;
|
| +
|
| + p->rc = rc;
|
| + return pRet;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Open the database handle and attach the RBU database as "rbu". If an
|
| +** error occurs, leave an error code and message in the RBU handle.
|
| +*/
|
| +static void rbuOpenDatabase(sqlite3rbu *p, int *pbRetry){
|
| + assert( p->rc || (p->dbMain==0 && p->dbRbu==0) );
|
| + assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 );
|
| +
|
| + /* Open the RBU database */
|
| + p->dbRbu = rbuOpenDbhandle(p, p->zRbu, 1);
|
| +
|
| + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
|
| + sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p);
|
| + if( p->zState==0 ){
|
| + const char *zFile = sqlite3_db_filename(p->dbRbu, "main");
|
| + p->zState = rbuMPrintf(p, "file://%s-vacuum?modeof=%s", zFile, zFile);
|
| + }
|
| + }
|
| +
|
| + /* If using separate RBU and state databases, attach the state database to
|
| + ** the RBU db handle now. */
|
| + if( p->zState ){
|
| + rbuMPrintfExec(p, p->dbRbu, "ATTACH %Q AS stat", p->zState);
|
| + memcpy(p->zStateDb, "stat", 4);
|
| + }else{
|
| + memcpy(p->zStateDb, "main", 4);
|
| + }
|
| +
|
| +#if 0
|
| + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
|
| + p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, 0);
|
| + }
|
| +#endif
|
| +
|
| + /* If it has not already been created, create the rbu_state table */
|
| + rbuMPrintfExec(p, p->dbRbu, RBU_CREATE_STATE, p->zStateDb);
|
| +
|
| +#if 0
|
| + if( rbuIsVacuum(p) ){
|
| + if( p->rc==SQLITE_OK ){
|
| + int rc2;
|
| + int bOk = 0;
|
| + sqlite3_stmt *pCnt = 0;
|
| + p->rc = prepareAndCollectError(p->dbRbu, &pCnt, &p->zErrmsg,
|
| + "SELECT count(*) FROM stat.sqlite_master"
|
| + );
|
| + if( p->rc==SQLITE_OK
|
| + && sqlite3_step(pCnt)==SQLITE_ROW
|
| + && 1==sqlite3_column_int(pCnt, 0)
|
| + ){
|
| + bOk = 1;
|
| + }
|
| + rc2 = sqlite3_finalize(pCnt);
|
| + if( p->rc==SQLITE_OK ) p->rc = rc2;
|
| +
|
| + if( p->rc==SQLITE_OK && bOk==0 ){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("invalid state database");
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
|
| + }
|
| + }
|
| + }
|
| +#endif
|
| +
|
| + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){
|
| + int bOpen = 0;
|
| + int rc;
|
| + p->nRbu = 0;
|
| + p->pRbuFd = 0;
|
| + rc = sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p);
|
| + if( rc!=SQLITE_NOTFOUND ) p->rc = rc;
|
| + if( p->eStage>=RBU_STAGE_MOVE ){
|
| + bOpen = 1;
|
| + }else{
|
| + RbuState *pState = rbuLoadState(p);
|
| + if( pState ){
|
| + bOpen = (pState->eStage>=RBU_STAGE_MOVE);
|
| + rbuFreeState(pState);
|
| + }
|
| + }
|
| + if( bOpen ) p->dbMain = rbuOpenDbhandle(p, p->zRbu, p->nRbu<=1);
|
| + }
|
| +
|
| + p->eStage = 0;
|
| + if( p->rc==SQLITE_OK && p->dbMain==0 ){
|
| + if( !rbuIsVacuum(p) ){
|
| + p->dbMain = rbuOpenDbhandle(p, p->zTarget, 1);
|
| + }else if( p->pRbuFd->pWalFd ){
|
| + if( pbRetry ){
|
| + p->pRbuFd->bNolock = 0;
|
| + sqlite3_close(p->dbRbu);
|
| + sqlite3_close(p->dbMain);
|
| + p->dbMain = 0;
|
| + p->dbRbu = 0;
|
| + *pbRetry = 1;
|
| + return;
|
| + }
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database");
|
| + }else{
|
| + char *zTarget;
|
| + char *zExtra = 0;
|
| + if( strlen(p->zRbu)>=5 && 0==memcmp("file:", p->zRbu, 5) ){
|
| + zExtra = &p->zRbu[5];
|
| + while( *zExtra ){
|
| + if( *zExtra++=='?' ) break;
|
| + }
|
| + if( *zExtra=='\0' ) zExtra = 0;
|
| + }
|
| +
|
| + zTarget = sqlite3_mprintf("file:%s-vacuum?rbu_memory=1%s%s",
|
| + sqlite3_db_filename(p->dbRbu, "main"),
|
| + (zExtra==0 ? "" : "&"), (zExtra==0 ? "" : zExtra)
|
| + );
|
| +
|
| + if( zTarget==0 ){
|
| + p->rc = SQLITE_NOMEM;
|
| + return;
|
| + }
|
| + p->dbMain = rbuOpenDbhandle(p, zTarget, p->nRbu<=1);
|
| + sqlite3_free(zTarget);
|
| + }
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_create_function(p->dbMain,
|
| + "rbu_tmp_insert", -1, SQLITE_UTF8, (void*)p, rbuTmpInsertFunc, 0, 0
|
| + );
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_create_function(p->dbMain,
|
| + "rbu_fossil_delta", 2, SQLITE_UTF8, 0, rbuFossilDeltaFunc, 0, 0
|
| + );
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_create_function(p->dbRbu,
|
| + "rbu_target_name", -1, SQLITE_UTF8, (void*)p, rbuTargetNameFunc, 0, 0
|
| + );
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p);
|
| + }
|
| + rbuMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_master");
|
| +
|
| + /* Mark the database file just opened as an RBU target database. If
|
| + ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use.
|
| + ** This is an error. */
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p);
|
| + }
|
| +
|
| + if( p->rc==SQLITE_NOTFOUND ){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("rbu vfs not found");
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This routine is a copy of the sqlite3FileSuffix3() routine from the core.
|
| +** It is a no-op unless SQLITE_ENABLE_8_3_NAMES is defined.
|
| +**
|
| +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
|
| +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
|
| +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
|
| +** three characters, then shorten the suffix on z[] to be the last three
|
| +** characters of the original suffix.
|
| +**
|
| +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
|
| +** do the suffix shortening regardless of URI parameter.
|
| +**
|
| +** Examples:
|
| +**
|
| +** test.db-journal => test.nal
|
| +** test.db-wal => test.wal
|
| +** test.db-shm => test.shm
|
| +** test.db-mj7f3319fa => test.9fa
|
| +*/
|
| +static void rbuFileSuffix3(const char *zBase, char *z){
|
| +#ifdef SQLITE_ENABLE_8_3_NAMES
|
| +#if SQLITE_ENABLE_8_3_NAMES<2
|
| + if( sqlite3_uri_boolean(zBase, "8_3_names", 0) )
|
| +#endif
|
| + {
|
| + int i, sz;
|
| + sz = (int)strlen(z)&0xffffff;
|
| + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
|
| + if( z[i]=='.' && sz>i+4 ) memmove(&z[i+1], &z[sz-3], 4);
|
| + }
|
| +#endif
|
| +}
|
| +
|
| +/*
|
| +** Return the current wal-index header checksum for the target database
|
| +** as a 64-bit integer.
|
| +**
|
| +** The checksum is store in the first page of xShmMap memory as an 8-byte
|
| +** blob starting at byte offset 40.
|
| +*/
|
| +static i64 rbuShmChecksum(sqlite3rbu *p){
|
| + i64 iRet = 0;
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_file *pDb = p->pTargetFd->pReal;
|
| + u32 volatile *ptr;
|
| + p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, (void volatile**)&ptr);
|
| + if( p->rc==SQLITE_OK ){
|
| + iRet = ((i64)ptr[10] << 32) + ptr[11];
|
| + }
|
| + }
|
| + return iRet;
|
| +}
|
| +
|
| +/*
|
| +** This function is called as part of initializing or reinitializing an
|
| +** incremental checkpoint.
|
| +**
|
| +** It populates the sqlite3rbu.aFrame[] array with the set of
|
| +** (wal frame -> db page) copy operations required to checkpoint the
|
| +** current wal file, and obtains the set of shm locks required to safely
|
| +** perform the copy operations directly on the file-system.
|
| +**
|
| +** If argument pState is not NULL, then the incremental checkpoint is
|
| +** being resumed. In this case, if the checksum of the wal-index-header
|
| +** following recovery is not the same as the checksum saved in the RbuState
|
| +** object, then the rbu handle is set to DONE state. This occurs if some
|
| +** other client appends a transaction to the wal file in the middle of
|
| +** an incremental checkpoint.
|
| +*/
|
| +static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){
|
| +
|
| + /* If pState is NULL, then the wal file may not have been opened and
|
| + ** recovered. Running a read-statement here to ensure that doing so
|
| + ** does not interfere with the "capture" process below. */
|
| + if( pState==0 ){
|
| + p->eStage = 0;
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(p->dbMain, "SELECT * FROM sqlite_master", 0, 0, 0);
|
| + }
|
| + }
|
| +
|
| + /* Assuming no error has occurred, run a "restart" checkpoint with the
|
| + ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following
|
| + ** special behaviour in the rbu VFS:
|
| + **
|
| + ** * If the exclusive shm WRITER or READ0 lock cannot be obtained,
|
| + ** the checkpoint fails with SQLITE_BUSY (normally SQLite would
|
| + ** proceed with running a passive checkpoint instead of failing).
|
| + **
|
| + ** * Attempts to read from the *-wal file or write to the database file
|
| + ** do not perform any IO. Instead, the frame/page combinations that
|
| + ** would be read/written are recorded in the sqlite3rbu.aFrame[]
|
| + ** array.
|
| + **
|
| + ** * Calls to xShmLock(UNLOCK) to release the exclusive shm WRITER,
|
| + ** READ0 and CHECKPOINT locks taken as part of the checkpoint are
|
| + ** no-ops. These locks will not be released until the connection
|
| + ** is closed.
|
| + **
|
| + ** * Attempting to xSync() the database file causes an SQLITE_INTERNAL
|
| + ** error.
|
| + **
|
| + ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the
|
| + ** checkpoint below fails with SQLITE_INTERNAL, and leaves the aFrame[]
|
| + ** array populated with a set of (frame -> page) mappings. Because the
|
| + ** WRITER, CHECKPOINT and READ0 locks are still held, it is safe to copy
|
| + ** data from the wal file into the database file according to the
|
| + ** contents of aFrame[].
|
| + */
|
| + if( p->rc==SQLITE_OK ){
|
| + int rc2;
|
| + p->eStage = RBU_STAGE_CAPTURE;
|
| + rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0);
|
| + if( rc2!=SQLITE_INTERNAL ) p->rc = rc2;
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK && p->nFrame>0 ){
|
| + p->eStage = RBU_STAGE_CKPT;
|
| + p->nStep = (pState ? pState->nRow : 0);
|
| + p->aBuf = rbuMalloc(p, p->pgsz);
|
| + p->iWalCksum = rbuShmChecksum(p);
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + if( p->nFrame==0 || (pState && pState->iWalCksum!=p->iWalCksum) ){
|
| + p->rc = SQLITE_DONE;
|
| + p->eStage = RBU_STAGE_DONE;
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Called when iAmt bytes are read from offset iOff of the wal file while
|
| +** the rbu object is in capture mode. Record the frame number of the frame
|
| +** being read in the aFrame[] array.
|
| +*/
|
| +static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){
|
| + const u32 mReq = (1<<WAL_LOCK_WRITE)|(1<<WAL_LOCK_CKPT)|(1<<WAL_LOCK_READ0);
|
| + u32 iFrame;
|
| +
|
| + if( pRbu->mLock!=mReq ){
|
| + pRbu->rc = SQLITE_BUSY;
|
| + return SQLITE_INTERNAL;
|
| + }
|
| +
|
| + pRbu->pgsz = iAmt;
|
| + if( pRbu->nFrame==pRbu->nFrameAlloc ){
|
| + int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
|
| + RbuFrame *aNew;
|
| + aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
|
| + if( aNew==0 ) return SQLITE_NOMEM;
|
| + pRbu->aFrame = aNew;
|
| + pRbu->nFrameAlloc = nNew;
|
| + }
|
| +
|
| + iFrame = (u32)((iOff-32) / (i64)(iAmt+24)) + 1;
|
| + if( pRbu->iMaxFrame<iFrame ) pRbu->iMaxFrame = iFrame;
|
| + pRbu->aFrame[pRbu->nFrame].iWalFrame = iFrame;
|
| + pRbu->aFrame[pRbu->nFrame].iDbPage = 0;
|
| + pRbu->nFrame++;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Called when a page of data is written to offset iOff of the database
|
| +** file while the rbu handle is in capture mode. Record the page number
|
| +** of the page being written in the aFrame[] array.
|
| +*/
|
| +static int rbuCaptureDbWrite(sqlite3rbu *pRbu, i64 iOff){
|
| + pRbu->aFrame[pRbu->nFrame-1].iDbPage = (u32)(iOff / pRbu->pgsz) + 1;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** This is called as part of an incremental checkpoint operation. Copy
|
| +** a single frame of data from the wal file into the database file, as
|
| +** indicated by the RbuFrame object.
|
| +*/
|
| +static void rbuCheckpointFrame(sqlite3rbu *p, RbuFrame *pFrame){
|
| + sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal;
|
| + sqlite3_file *pDb = p->pTargetFd->pReal;
|
| + i64 iOff;
|
| +
|
| + assert( p->rc==SQLITE_OK );
|
| + iOff = (i64)(pFrame->iWalFrame-1) * (p->pgsz + 24) + 32 + 24;
|
| + p->rc = pWal->pMethods->xRead(pWal, p->aBuf, p->pgsz, iOff);
|
| + if( p->rc ) return;
|
| +
|
| + iOff = (i64)(pFrame->iDbPage-1) * p->pgsz;
|
| + p->rc = pDb->pMethods->xWrite(pDb, p->aBuf, p->pgsz, iOff);
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Take an EXCLUSIVE lock on the database file.
|
| +*/
|
| +static void rbuLockDatabase(sqlite3rbu *p){
|
| + sqlite3_file *pReal = p->pTargetFd->pReal;
|
| + assert( p->rc==SQLITE_OK );
|
| + p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_SHARED);
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = pReal->pMethods->xLock(pReal, SQLITE_LOCK_EXCLUSIVE);
|
| + }
|
| +}
|
| +
|
| +#if defined(_WIN32_WCE)
|
| +static LPWSTR rbuWinUtf8ToUnicode(const char *zFilename){
|
| + int nChar;
|
| + LPWSTR zWideFilename;
|
| +
|
| + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
|
| + if( nChar==0 ){
|
| + return 0;
|
| + }
|
| + zWideFilename = sqlite3_malloc64( nChar*sizeof(zWideFilename[0]) );
|
| + if( zWideFilename==0 ){
|
| + return 0;
|
| + }
|
| + memset(zWideFilename, 0, nChar*sizeof(zWideFilename[0]));
|
| + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename,
|
| + nChar);
|
| + if( nChar==0 ){
|
| + sqlite3_free(zWideFilename);
|
| + zWideFilename = 0;
|
| + }
|
| + return zWideFilename;
|
| +}
|
| +#endif
|
| +
|
| +/*
|
| +** The RBU handle is currently in RBU_STAGE_OAL state, with a SHARED lock
|
| +** on the database file. This proc moves the *-oal file to the *-wal path,
|
| +** then reopens the database file (this time in vanilla, non-oal, WAL mode).
|
| +** If an error occurs, leave an error code and error message in the rbu
|
| +** handle.
|
| +*/
|
| +static void rbuMoveOalFile(sqlite3rbu *p){
|
| + const char *zBase = sqlite3_db_filename(p->dbMain, "main");
|
| + const char *zMove = zBase;
|
| + char *zOal;
|
| + char *zWal;
|
| +
|
| + if( rbuIsVacuum(p) ){
|
| + zMove = sqlite3_db_filename(p->dbRbu, "main");
|
| + }
|
| + zOal = sqlite3_mprintf("%s-oal", zMove);
|
| + zWal = sqlite3_mprintf("%s-wal", zMove);
|
| +
|
| + assert( p->eStage==RBU_STAGE_MOVE );
|
| + assert( p->rc==SQLITE_OK && p->zErrmsg==0 );
|
| + if( zWal==0 || zOal==0 ){
|
| + p->rc = SQLITE_NOMEM;
|
| + }else{
|
| + /* Move the *-oal file to *-wal. At this point connection p->db is
|
| + ** holding a SHARED lock on the target database file (because it is
|
| + ** in WAL mode). So no other connection may be writing the db.
|
| + **
|
| + ** In order to ensure that there are no database readers, an EXCLUSIVE
|
| + ** lock is obtained here before the *-oal is moved to *-wal.
|
| + */
|
| + rbuLockDatabase(p);
|
| + if( p->rc==SQLITE_OK ){
|
| + rbuFileSuffix3(zBase, zWal);
|
| + rbuFileSuffix3(zBase, zOal);
|
| +
|
| + /* Re-open the databases. */
|
| + rbuObjIterFinalize(&p->objiter);
|
| + sqlite3_close(p->dbRbu);
|
| + sqlite3_close(p->dbMain);
|
| + p->dbMain = 0;
|
| + p->dbRbu = 0;
|
| +
|
| +#if defined(_WIN32_WCE)
|
| + {
|
| + LPWSTR zWideOal;
|
| + LPWSTR zWideWal;
|
| +
|
| + zWideOal = rbuWinUtf8ToUnicode(zOal);
|
| + if( zWideOal ){
|
| + zWideWal = rbuWinUtf8ToUnicode(zWal);
|
| + if( zWideWal ){
|
| + if( MoveFileW(zWideOal, zWideWal) ){
|
| + p->rc = SQLITE_OK;
|
| + }else{
|
| + p->rc = SQLITE_IOERR;
|
| + }
|
| + sqlite3_free(zWideWal);
|
| + }else{
|
| + p->rc = SQLITE_IOERR_NOMEM;
|
| + }
|
| + sqlite3_free(zWideOal);
|
| + }else{
|
| + p->rc = SQLITE_IOERR_NOMEM;
|
| + }
|
| + }
|
| +#else
|
| + p->rc = rename(zOal, zWal) ? SQLITE_IOERR : SQLITE_OK;
|
| +#endif
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + rbuOpenDatabase(p, 0);
|
| + rbuSetupCheckpoint(p, 0);
|
| + }
|
| + }
|
| + }
|
| +
|
| + sqlite3_free(zWal);
|
| + sqlite3_free(zOal);
|
| +}
|
| +
|
| +/*
|
| +** The SELECT statement iterating through the keys for the current object
|
| +** (p->objiter.pSelect) currently points to a valid row. This function
|
| +** determines the type of operation requested by this row and returns
|
| +** one of the following values to indicate the result:
|
| +**
|
| +** * RBU_INSERT
|
| +** * RBU_DELETE
|
| +** * RBU_IDX_DELETE
|
| +** * RBU_UPDATE
|
| +**
|
| +** If RBU_UPDATE is returned, then output variable *pzMask is set to
|
| +** point to the text value indicating the columns to update.
|
| +**
|
| +** If the rbu_control field contains an invalid value, an error code and
|
| +** message are left in the RBU handle and zero returned.
|
| +*/
|
| +static int rbuStepType(sqlite3rbu *p, const char **pzMask){
|
| + int iCol = p->objiter.nCol; /* Index of rbu_control column */
|
| + int res = 0; /* Return value */
|
| +
|
| + switch( sqlite3_column_type(p->objiter.pSelect, iCol) ){
|
| + case SQLITE_INTEGER: {
|
| + int iVal = sqlite3_column_int(p->objiter.pSelect, iCol);
|
| + switch( iVal ){
|
| + case 0: res = RBU_INSERT; break;
|
| + case 1: res = RBU_DELETE; break;
|
| + case 2: res = RBU_REPLACE; break;
|
| + case 3: res = RBU_IDX_DELETE; break;
|
| + case 4: res = RBU_IDX_INSERT; break;
|
| + }
|
| + break;
|
| + }
|
| +
|
| + case SQLITE_TEXT: {
|
| + const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
|
| + if( z==0 ){
|
| + p->rc = SQLITE_NOMEM;
|
| + }else{
|
| + *pzMask = (const char*)z;
|
| + }
|
| + res = RBU_UPDATE;
|
| +
|
| + break;
|
| + }
|
| +
|
| + default:
|
| + break;
|
| + }
|
| +
|
| + if( res==0 ){
|
| + rbuBadControlError(p);
|
| + }
|
| + return res;
|
| +}
|
| +
|
| +#ifdef SQLITE_DEBUG
|
| +/*
|
| +** Assert that column iCol of statement pStmt is named zName.
|
| +*/
|
| +static void assertColumnName(sqlite3_stmt *pStmt, int iCol, const char *zName){
|
| + const char *zCol = sqlite3_column_name(pStmt, iCol);
|
| + assert( 0==sqlite3_stricmp(zName, zCol) );
|
| +}
|
| +#else
|
| +# define assertColumnName(x,y,z)
|
| +#endif
|
| +
|
| +/*
|
| +** Argument eType must be one of RBU_INSERT, RBU_DELETE, RBU_IDX_INSERT or
|
| +** RBU_IDX_DELETE. This function performs the work of a single
|
| +** sqlite3rbu_step() call for the type of operation specified by eType.
|
| +*/
|
| +static void rbuStepOneOp(sqlite3rbu *p, int eType){
|
| + RbuObjIter *pIter = &p->objiter;
|
| + sqlite3_value *pVal;
|
| + sqlite3_stmt *pWriter;
|
| + int i;
|
| +
|
| + assert( p->rc==SQLITE_OK );
|
| + assert( eType!=RBU_DELETE || pIter->zIdx==0 );
|
| + assert( eType==RBU_DELETE || eType==RBU_IDX_DELETE
|
| + || eType==RBU_INSERT || eType==RBU_IDX_INSERT
|
| + );
|
| +
|
| + /* If this is a delete, decrement nPhaseOneStep by nIndex. If the DELETE
|
| + ** statement below does actually delete a row, nPhaseOneStep will be
|
| + ** incremented by the same amount when SQL function rbu_tmp_insert()
|
| + ** is invoked by the trigger. */
|
| + if( eType==RBU_DELETE ){
|
| + p->nPhaseOneStep -= p->objiter.nIndex;
|
| + }
|
| +
|
| + if( eType==RBU_IDX_DELETE || eType==RBU_DELETE ){
|
| + pWriter = pIter->pDelete;
|
| + }else{
|
| + pWriter = pIter->pInsert;
|
| + }
|
| +
|
| + for(i=0; i<pIter->nCol; i++){
|
| + /* If this is an INSERT into a table b-tree and the table has an
|
| + ** explicit INTEGER PRIMARY KEY, check that this is not an attempt
|
| + ** to write a NULL into the IPK column. That is not permitted. */
|
| + if( eType==RBU_INSERT
|
| + && pIter->zIdx==0 && pIter->eType==RBU_PK_IPK && pIter->abTblPk[i]
|
| + && sqlite3_column_type(pIter->pSelect, i)==SQLITE_NULL
|
| + ){
|
| + p->rc = SQLITE_MISMATCH;
|
| + p->zErrmsg = sqlite3_mprintf("datatype mismatch");
|
| + return;
|
| + }
|
| +
|
| + if( eType==RBU_DELETE && pIter->abTblPk[i]==0 ){
|
| + continue;
|
| + }
|
| +
|
| + pVal = sqlite3_column_value(pIter->pSelect, i);
|
| + p->rc = sqlite3_bind_value(pWriter, i+1, pVal);
|
| + if( p->rc ) return;
|
| + }
|
| + if( pIter->zIdx==0 ){
|
| + if( pIter->eType==RBU_PK_VTAB
|
| + || pIter->eType==RBU_PK_NONE
|
| + || (pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p))
|
| + ){
|
| + /* For a virtual table, or a table with no primary key, the
|
| + ** SELECT statement is:
|
| + **
|
| + ** SELECT <cols>, rbu_control, rbu_rowid FROM ....
|
| + **
|
| + ** Hence column_value(pIter->nCol+1).
|
| + */
|
| + assertColumnName(pIter->pSelect, pIter->nCol+1,
|
| + rbuIsVacuum(p) ? "rowid" : "rbu_rowid"
|
| + );
|
| + pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
|
| + p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
|
| + }
|
| + }
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_step(pWriter);
|
| + p->rc = resetAndCollectError(pWriter, &p->zErrmsg);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function does the work for an sqlite3rbu_step() call.
|
| +**
|
| +** The object-iterator (p->objiter) currently points to a valid object,
|
| +** and the input cursor (p->objiter.pSelect) currently points to a valid
|
| +** input row. Perform whatever processing is required and return.
|
| +**
|
| +** If no error occurs, SQLITE_OK is returned. Otherwise, an error code
|
| +** and message is left in the RBU handle and a copy of the error code
|
| +** returned.
|
| +*/
|
| +static int rbuStep(sqlite3rbu *p){
|
| + RbuObjIter *pIter = &p->objiter;
|
| + const char *zMask = 0;
|
| + int eType = rbuStepType(p, &zMask);
|
| +
|
| + if( eType ){
|
| + assert( eType==RBU_INSERT || eType==RBU_DELETE
|
| + || eType==RBU_REPLACE || eType==RBU_IDX_DELETE
|
| + || eType==RBU_IDX_INSERT || eType==RBU_UPDATE
|
| + );
|
| + assert( eType!=RBU_UPDATE || pIter->zIdx==0 );
|
| +
|
| + if( pIter->zIdx==0 && (eType==RBU_IDX_DELETE || eType==RBU_IDX_INSERT) ){
|
| + rbuBadControlError(p);
|
| + }
|
| + else if( eType==RBU_REPLACE ){
|
| + if( pIter->zIdx==0 ){
|
| + p->nPhaseOneStep += p->objiter.nIndex;
|
| + rbuStepOneOp(p, RBU_DELETE);
|
| + }
|
| + if( p->rc==SQLITE_OK ) rbuStepOneOp(p, RBU_INSERT);
|
| + }
|
| + else if( eType!=RBU_UPDATE ){
|
| + rbuStepOneOp(p, eType);
|
| + }
|
| + else{
|
| + sqlite3_value *pVal;
|
| + sqlite3_stmt *pUpdate = 0;
|
| + assert( eType==RBU_UPDATE );
|
| + p->nPhaseOneStep -= p->objiter.nIndex;
|
| + rbuGetUpdateStmt(p, pIter, zMask, &pUpdate);
|
| + if( pUpdate ){
|
| + int i;
|
| + for(i=0; p->rc==SQLITE_OK && i<pIter->nCol; i++){
|
| + char c = zMask[pIter->aiSrcOrder[i]];
|
| + pVal = sqlite3_column_value(pIter->pSelect, i);
|
| + if( pIter->abTblPk[i] || c!='.' ){
|
| + p->rc = sqlite3_bind_value(pUpdate, i+1, pVal);
|
| + }
|
| + }
|
| + if( p->rc==SQLITE_OK
|
| + && (pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE)
|
| + ){
|
| + /* Bind the rbu_rowid value to column _rowid_ */
|
| + assertColumnName(pIter->pSelect, pIter->nCol+1, "rbu_rowid");
|
| + pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
|
| + p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
|
| + }
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_step(pUpdate);
|
| + p->rc = resetAndCollectError(pUpdate, &p->zErrmsg);
|
| + }
|
| + }
|
| + }
|
| + }
|
| + return p->rc;
|
| +}
|
| +
|
| +/*
|
| +** Increment the schema cookie of the main database opened by p->dbMain.
|
| +**
|
| +** Or, if this is an RBU vacuum, set the schema cookie of the main db
|
| +** opened by p->dbMain to one more than the schema cookie of the main
|
| +** db opened by p->dbRbu.
|
| +*/
|
| +static void rbuIncrSchemaCookie(sqlite3rbu *p){
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3 *dbread = (rbuIsVacuum(p) ? p->dbRbu : p->dbMain);
|
| + int iCookie = 1000000;
|
| + sqlite3_stmt *pStmt;
|
| +
|
| + p->rc = prepareAndCollectError(dbread, &pStmt, &p->zErrmsg,
|
| + "PRAGMA schema_version"
|
| + );
|
| + if( p->rc==SQLITE_OK ){
|
| + /* Coverage: it may be that this sqlite3_step() cannot fail. There
|
| + ** is already a transaction open, so the prepared statement cannot
|
| + ** throw an SQLITE_SCHEMA exception. The only database page the
|
| + ** statement reads is page 1, which is guaranteed to be in the cache.
|
| + ** And no memory allocations are required. */
|
| + if( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + iCookie = sqlite3_column_int(pStmt, 0);
|
| + }
|
| + rbuFinalize(p, pStmt);
|
| + }
|
| + if( p->rc==SQLITE_OK ){
|
| + rbuMPrintfExec(p, p->dbMain, "PRAGMA schema_version = %d", iCookie+1);
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Update the contents of the rbu_state table within the rbu database. The
|
| +** value stored in the RBU_STATE_STAGE column is eStage. All other values
|
| +** are determined by inspecting the rbu handle passed as the first argument.
|
| +*/
|
| +static void rbuSaveState(sqlite3rbu *p, int eStage){
|
| + if( p->rc==SQLITE_OK || p->rc==SQLITE_DONE ){
|
| + sqlite3_stmt *pInsert = 0;
|
| + rbu_file *pFd = (rbuIsVacuum(p) ? p->pRbuFd : p->pTargetFd);
|
| + int rc;
|
| +
|
| + assert( p->zErrmsg==0 );
|
| + rc = prepareFreeAndCollectError(p->dbRbu, &pInsert, &p->zErrmsg,
|
| + sqlite3_mprintf(
|
| + "INSERT OR REPLACE INTO %s.rbu_state(k, v) VALUES "
|
| + "(%d, %d), "
|
| + "(%d, %Q), "
|
| + "(%d, %Q), "
|
| + "(%d, %d), "
|
| + "(%d, %d), "
|
| + "(%d, %lld), "
|
| + "(%d, %lld), "
|
| + "(%d, %lld), "
|
| + "(%d, %lld) ",
|
| + p->zStateDb,
|
| + RBU_STATE_STAGE, eStage,
|
| + RBU_STATE_TBL, p->objiter.zTbl,
|
| + RBU_STATE_IDX, p->objiter.zIdx,
|
| + RBU_STATE_ROW, p->nStep,
|
| + RBU_STATE_PROGRESS, p->nProgress,
|
| + RBU_STATE_CKPT, p->iWalCksum,
|
| + RBU_STATE_COOKIE, (i64)pFd->iCookie,
|
| + RBU_STATE_OALSZ, p->iOalSz,
|
| + RBU_STATE_PHASEONESTEP, p->nPhaseOneStep
|
| + )
|
| + );
|
| + assert( pInsert==0 || rc==SQLITE_OK );
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + sqlite3_step(pInsert);
|
| + rc = sqlite3_finalize(pInsert);
|
| + }
|
| + if( rc!=SQLITE_OK ) p->rc = rc;
|
| + }
|
| +}
|
| +
|
| +
|
| +/*
|
| +** The second argument passed to this function is the name of a PRAGMA
|
| +** setting - "page_size", "auto_vacuum", "user_version" or "application_id".
|
| +** This function executes the following on sqlite3rbu.dbRbu:
|
| +**
|
| +** "PRAGMA main.$zPragma"
|
| +**
|
| +** where $zPragma is the string passed as the second argument, then
|
| +** on sqlite3rbu.dbMain:
|
| +**
|
| +** "PRAGMA main.$zPragma = $val"
|
| +**
|
| +** where $val is the value returned by the first PRAGMA invocation.
|
| +**
|
| +** In short, it copies the value of the specified PRAGMA setting from
|
| +** dbRbu to dbMain.
|
| +*/
|
| +static void rbuCopyPragma(sqlite3rbu *p, const char *zPragma){
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_stmt *pPragma = 0;
|
| + p->rc = prepareFreeAndCollectError(p->dbRbu, &pPragma, &p->zErrmsg,
|
| + sqlite3_mprintf("PRAGMA main.%s", zPragma)
|
| + );
|
| + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pPragma) ){
|
| + p->rc = rbuMPrintfExec(p, p->dbMain, "PRAGMA main.%s = %d",
|
| + zPragma, sqlite3_column_int(pPragma, 0)
|
| + );
|
| + }
|
| + rbuFinalize(p, pPragma);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** The RBU handle passed as the only argument has just been opened and
|
| +** the state database is empty. If this RBU handle was opened for an
|
| +** RBU vacuum operation, create the schema in the target db.
|
| +*/
|
| +static void rbuCreateTargetSchema(sqlite3rbu *p){
|
| + sqlite3_stmt *pSql = 0;
|
| + sqlite3_stmt *pInsert = 0;
|
| +
|
| + assert( rbuIsVacuum(p) );
|
| + p->rc = sqlite3_exec(p->dbMain, "PRAGMA writable_schema=1", 0,0, &p->zErrmsg);
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareAndCollectError(p->dbRbu, &pSql, &p->zErrmsg,
|
| + "SELECT sql FROM sqlite_master WHERE sql!='' AND rootpage!=0"
|
| + " AND name!='sqlite_sequence' "
|
| + " ORDER BY type DESC"
|
| + );
|
| + }
|
| +
|
| + while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
|
| + const char *zSql = (const char*)sqlite3_column_text(pSql, 0);
|
| + p->rc = sqlite3_exec(p->dbMain, zSql, 0, 0, &p->zErrmsg);
|
| + }
|
| + rbuFinalize(p, pSql);
|
| + if( p->rc!=SQLITE_OK ) return;
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareAndCollectError(p->dbRbu, &pSql, &p->zErrmsg,
|
| + "SELECT * FROM sqlite_master WHERE rootpage=0 OR rootpage IS NULL"
|
| + );
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareAndCollectError(p->dbMain, &pInsert, &p->zErrmsg,
|
| + "INSERT INTO sqlite_master VALUES(?,?,?,?,?)"
|
| + );
|
| + }
|
| +
|
| + while( p->rc==SQLITE_OK && sqlite3_step(pSql)==SQLITE_ROW ){
|
| + int i;
|
| + for(i=0; i<5; i++){
|
| + sqlite3_bind_value(pInsert, i+1, sqlite3_column_value(pSql, i));
|
| + }
|
| + sqlite3_step(pInsert);
|
| + p->rc = sqlite3_reset(pInsert);
|
| + }
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(p->dbMain, "PRAGMA writable_schema=0",0,0,&p->zErrmsg);
|
| + }
|
| +
|
| + rbuFinalize(p, pSql);
|
| + rbuFinalize(p, pInsert);
|
| +}
|
| +
|
| +/*
|
| +** Step the RBU object.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_step(sqlite3rbu *p){
|
| + if( p ){
|
| + switch( p->eStage ){
|
| + case RBU_STAGE_OAL: {
|
| + RbuObjIter *pIter = &p->objiter;
|
| +
|
| + /* If this is an RBU vacuum operation and the state table was empty
|
| + ** when this handle was opened, create the target database schema. */
|
| + if( rbuIsVacuum(p) && p->nProgress==0 && p->rc==SQLITE_OK ){
|
| + rbuCreateTargetSchema(p);
|
| + rbuCopyPragma(p, "user_version");
|
| + rbuCopyPragma(p, "application_id");
|
| + }
|
| +
|
| + while( p->rc==SQLITE_OK && pIter->zTbl ){
|
| +
|
| + if( pIter->bCleanup ){
|
| + /* Clean up the rbu_tmp_xxx table for the previous table. It
|
| + ** cannot be dropped as there are currently active SQL statements.
|
| + ** But the contents can be deleted. */
|
| + if( rbuIsVacuum(p)==0 && pIter->abIndexed ){
|
| + rbuMPrintfExec(p, p->dbRbu,
|
| + "DELETE FROM %s.'rbu_tmp_%q'", p->zStateDb, pIter->zDataTbl
|
| + );
|
| + }
|
| + }else{
|
| + rbuObjIterPrepareAll(p, pIter, 0);
|
| +
|
| + /* Advance to the next row to process. */
|
| + if( p->rc==SQLITE_OK ){
|
| + int rc = sqlite3_step(pIter->pSelect);
|
| + if( rc==SQLITE_ROW ){
|
| + p->nProgress++;
|
| + p->nStep++;
|
| + return rbuStep(p);
|
| + }
|
| + p->rc = sqlite3_reset(pIter->pSelect);
|
| + p->nStep = 0;
|
| + }
|
| + }
|
| +
|
| + rbuObjIterNext(p, pIter);
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + assert( pIter->zTbl==0 );
|
| + rbuSaveState(p, RBU_STAGE_MOVE);
|
| + rbuIncrSchemaCookie(p);
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
|
| + }
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
|
| + }
|
| + p->eStage = RBU_STAGE_MOVE;
|
| + }
|
| + break;
|
| + }
|
| +
|
| + case RBU_STAGE_MOVE: {
|
| + if( p->rc==SQLITE_OK ){
|
| + rbuMoveOalFile(p);
|
| + p->nProgress++;
|
| + }
|
| + break;
|
| + }
|
| +
|
| + case RBU_STAGE_CKPT: {
|
| + if( p->rc==SQLITE_OK ){
|
| + if( p->nStep>=p->nFrame ){
|
| + sqlite3_file *pDb = p->pTargetFd->pReal;
|
| +
|
| + /* Sync the db file */
|
| + p->rc = pDb->pMethods->xSync(pDb, SQLITE_SYNC_NORMAL);
|
| +
|
| + /* Update nBackfill */
|
| + if( p->rc==SQLITE_OK ){
|
| + void volatile *ptr;
|
| + p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, &ptr);
|
| + if( p->rc==SQLITE_OK ){
|
| + ((u32 volatile*)ptr)[24] = p->iMaxFrame;
|
| + }
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + p->eStage = RBU_STAGE_DONE;
|
| + p->rc = SQLITE_DONE;
|
| + }
|
| + }else{
|
| + RbuFrame *pFrame = &p->aFrame[p->nStep];
|
| + rbuCheckpointFrame(p, pFrame);
|
| + p->nStep++;
|
| + }
|
| + p->nProgress++;
|
| + }
|
| + break;
|
| + }
|
| +
|
| + default:
|
| + break;
|
| + }
|
| + return p->rc;
|
| + }else{
|
| + return SQLITE_NOMEM;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Compare strings z1 and z2, returning 0 if they are identical, or non-zero
|
| +** otherwise. Either or both argument may be NULL. Two NULL values are
|
| +** considered equal, and NULL is considered distinct from all other values.
|
| +*/
|
| +static int rbuStrCompare(const char *z1, const char *z2){
|
| + if( z1==0 && z2==0 ) return 0;
|
| + if( z1==0 || z2==0 ) return 1;
|
| + return (sqlite3_stricmp(z1, z2)!=0);
|
| +}
|
| +
|
| +/*
|
| +** This function is called as part of sqlite3rbu_open() when initializing
|
| +** an rbu handle in OAL stage. If the rbu update has not started (i.e.
|
| +** the rbu_state table was empty) it is a no-op. Otherwise, it arranges
|
| +** things so that the next call to sqlite3rbu_step() continues on from
|
| +** where the previous rbu handle left off.
|
| +**
|
| +** If an error occurs, an error code and error message are left in the
|
| +** rbu handle passed as the first argument.
|
| +*/
|
| +static void rbuSetupOal(sqlite3rbu *p, RbuState *pState){
|
| + assert( p->rc==SQLITE_OK );
|
| + if( pState->zTbl ){
|
| + RbuObjIter *pIter = &p->objiter;
|
| + int rc = SQLITE_OK;
|
| +
|
| + while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
|
| + || rbuStrCompare(pIter->zIdx, pState->zIdx)
|
| + || rbuStrCompare(pIter->zTbl, pState->zTbl)
|
| + )){
|
| + rc = rbuObjIterNext(p, pIter);
|
| + }
|
| +
|
| + if( rc==SQLITE_OK && !pIter->zTbl ){
|
| + rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("rbu_state mismatch error");
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + p->nStep = pState->nRow;
|
| + rc = rbuObjIterPrepareAll(p, &p->objiter, p->nStep);
|
| + }
|
| +
|
| + p->rc = rc;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** If there is a "*-oal" file in the file-system corresponding to the
|
| +** target database in the file-system, delete it. If an error occurs,
|
| +** leave an error code and error message in the rbu handle.
|
| +*/
|
| +static void rbuDeleteOalFile(sqlite3rbu *p){
|
| + char *zOal = rbuMPrintf(p, "%s-oal", p->zTarget);
|
| + if( zOal ){
|
| + sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
|
| + assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );
|
| + pVfs->xDelete(pVfs, zOal, 0);
|
| + sqlite3_free(zOal);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Allocate a private rbu VFS for the rbu handle passed as the only
|
| +** argument. This VFS will be used unless the call to sqlite3rbu_open()
|
| +** specified a URI with a vfs=? option in place of a target database
|
| +** file name.
|
| +*/
|
| +static void rbuCreateVfs(sqlite3rbu *p){
|
| + int rnd;
|
| + char zRnd[64];
|
| +
|
| + assert( p->rc==SQLITE_OK );
|
| + sqlite3_randomness(sizeof(int), (void*)&rnd);
|
| + sqlite3_snprintf(sizeof(zRnd), zRnd, "rbu_vfs_%d", rnd);
|
| + p->rc = sqlite3rbu_create_vfs(zRnd, 0);
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_vfs *pVfs = sqlite3_vfs_find(zRnd);
|
| + assert( pVfs );
|
| + p->zVfsName = pVfs->zName;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Destroy the private VFS created for the rbu handle passed as the only
|
| +** argument by an earlier call to rbuCreateVfs().
|
| +*/
|
| +static void rbuDeleteVfs(sqlite3rbu *p){
|
| + if( p->zVfsName ){
|
| + sqlite3rbu_destroy_vfs(p->zVfsName);
|
| + p->zVfsName = 0;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This user-defined SQL function is invoked with a single argument - the
|
| +** name of a table expected to appear in the target database. It returns
|
| +** the number of auxilliary indexes on the table.
|
| +*/
|
| +static void rbuIndexCntFunc(
|
| + sqlite3_context *pCtx,
|
| + int nVal,
|
| + sqlite3_value **apVal
|
| +){
|
| + sqlite3rbu *p = (sqlite3rbu*)sqlite3_user_data(pCtx);
|
| + sqlite3_stmt *pStmt = 0;
|
| + char *zErrmsg = 0;
|
| + int rc;
|
| +
|
| + assert( nVal==1 );
|
| +
|
| + rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &zErrmsg,
|
| + sqlite3_mprintf("SELECT count(*) FROM sqlite_master "
|
| + "WHERE type='index' AND tbl_name = %Q", sqlite3_value_text(apVal[0]))
|
| + );
|
| + if( rc!=SQLITE_OK ){
|
| + sqlite3_result_error(pCtx, zErrmsg, -1);
|
| + }else{
|
| + int nIndex = 0;
|
| + if( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + nIndex = sqlite3_column_int(pStmt, 0);
|
| + }
|
| + rc = sqlite3_finalize(pStmt);
|
| + if( rc==SQLITE_OK ){
|
| + sqlite3_result_int(pCtx, nIndex);
|
| + }else{
|
| + sqlite3_result_error(pCtx, sqlite3_errmsg(p->dbMain), -1);
|
| + }
|
| + }
|
| +
|
| + sqlite3_free(zErrmsg);
|
| +}
|
| +
|
| +/*
|
| +** If the RBU database contains the rbu_count table, use it to initialize
|
| +** the sqlite3rbu.nPhaseOneStep variable. The schema of the rbu_count table
|
| +** is assumed to contain the same columns as:
|
| +**
|
| +** CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
|
| +**
|
| +** There should be one row in the table for each data_xxx table in the
|
| +** database. The 'tbl' column should contain the name of a data_xxx table,
|
| +** and the cnt column the number of rows it contains.
|
| +**
|
| +** sqlite3rbu.nPhaseOneStep is initialized to the sum of (1 + nIndex) * cnt
|
| +** for all rows in the rbu_count table, where nIndex is the number of
|
| +** indexes on the corresponding target database table.
|
| +*/
|
| +static void rbuInitPhaseOneSteps(sqlite3rbu *p){
|
| + if( p->rc==SQLITE_OK ){
|
| + sqlite3_stmt *pStmt = 0;
|
| + int bExists = 0; /* True if rbu_count exists */
|
| +
|
| + p->nPhaseOneStep = -1;
|
| +
|
| + p->rc = sqlite3_create_function(p->dbRbu,
|
| + "rbu_index_cnt", 1, SQLITE_UTF8, (void*)p, rbuIndexCntFunc, 0, 0
|
| + );
|
| +
|
| + /* Check for the rbu_count table. If it does not exist, or if an error
|
| + ** occurs, nPhaseOneStep will be left set to -1. */
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
|
| + "SELECT 1 FROM sqlite_master WHERE tbl_name = 'rbu_count'"
|
| + );
|
| + }
|
| + if( p->rc==SQLITE_OK ){
|
| + if( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + bExists = 1;
|
| + }
|
| + p->rc = sqlite3_finalize(pStmt);
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK && bExists ){
|
| + p->rc = prepareAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg,
|
| + "SELECT sum(cnt * (1 + rbu_index_cnt(rbu_target_name(tbl))))"
|
| + "FROM rbu_count"
|
| + );
|
| + if( p->rc==SQLITE_OK ){
|
| + if( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + p->nPhaseOneStep = sqlite3_column_int64(pStmt, 0);
|
| + }
|
| + p->rc = sqlite3_finalize(pStmt);
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +
|
| +static sqlite3rbu *openRbuHandle(
|
| + const char *zTarget,
|
| + const char *zRbu,
|
| + const char *zState
|
| +){
|
| + sqlite3rbu *p;
|
| + size_t nTarget = zTarget ? strlen(zTarget) : 0;
|
| + size_t nRbu = strlen(zRbu);
|
| + size_t nByte = sizeof(sqlite3rbu) + nTarget+1 + nRbu+1;
|
| +
|
| + p = (sqlite3rbu*)sqlite3_malloc64(nByte);
|
| + if( p ){
|
| + RbuState *pState = 0;
|
| +
|
| + /* Create the custom VFS. */
|
| + memset(p, 0, sizeof(sqlite3rbu));
|
| + rbuCreateVfs(p);
|
| +
|
| + /* Open the target, RBU and state databases */
|
| + if( p->rc==SQLITE_OK ){
|
| + char *pCsr = (char*)&p[1];
|
| + int bRetry = 0;
|
| + if( zTarget ){
|
| + p->zTarget = pCsr;
|
| + memcpy(p->zTarget, zTarget, nTarget+1);
|
| + pCsr += nTarget+1;
|
| + }
|
| + p->zRbu = pCsr;
|
| + memcpy(p->zRbu, zRbu, nRbu+1);
|
| + pCsr += nRbu+1;
|
| + if( zState ){
|
| + p->zState = rbuMPrintf(p, "%s", zState);
|
| + }
|
| +
|
| + /* If the first attempt to open the database file fails and the bRetry
|
| + ** flag it set, this means that the db was not opened because it seemed
|
| + ** to be a wal-mode db. But, this may have happened due to an earlier
|
| + ** RBU vacuum operation leaving an old wal file in the directory.
|
| + ** If this is the case, it will have been checkpointed and deleted
|
| + ** when the handle was closed and a second attempt to open the
|
| + ** database may succeed. */
|
| + rbuOpenDatabase(p, &bRetry);
|
| + if( bRetry ){
|
| + rbuOpenDatabase(p, 0);
|
| + }
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + pState = rbuLoadState(p);
|
| + assert( pState || p->rc!=SQLITE_OK );
|
| + if( p->rc==SQLITE_OK ){
|
| +
|
| + if( pState->eStage==0 ){
|
| + rbuDeleteOalFile(p);
|
| + rbuInitPhaseOneSteps(p);
|
| + p->eStage = RBU_STAGE_OAL;
|
| + }else{
|
| + p->eStage = pState->eStage;
|
| + p->nPhaseOneStep = pState->nPhaseOneStep;
|
| + }
|
| + p->nProgress = pState->nProgress;
|
| + p->iOalSz = pState->iOalSz;
|
| + }
|
| + }
|
| + assert( p->rc!=SQLITE_OK || p->eStage!=0 );
|
| +
|
| + if( p->rc==SQLITE_OK && p->pTargetFd->pWalFd ){
|
| + if( p->eStage==RBU_STAGE_OAL ){
|
| + p->rc = SQLITE_ERROR;
|
| + p->zErrmsg = sqlite3_mprintf("cannot update wal mode database");
|
| + }else if( p->eStage==RBU_STAGE_MOVE ){
|
| + p->eStage = RBU_STAGE_CKPT;
|
| + p->nStep = 0;
|
| + }
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK
|
| + && (p->eStage==RBU_STAGE_OAL || p->eStage==RBU_STAGE_MOVE)
|
| + && pState->eStage!=0
|
| + ){
|
| + rbu_file *pFd = (rbuIsVacuum(p) ? p->pRbuFd : p->pTargetFd);
|
| + if( pFd->iCookie!=pState->iCookie ){
|
| + /* At this point (pTargetFd->iCookie) contains the value of the
|
| + ** change-counter cookie (the thing that gets incremented when a
|
| + ** transaction is committed in rollback mode) currently stored on
|
| + ** page 1 of the database file. */
|
| + p->rc = SQLITE_BUSY;
|
| + p->zErrmsg = sqlite3_mprintf("database modified during rbu %s",
|
| + (rbuIsVacuum(p) ? "vacuum" : "update")
|
| + );
|
| + }
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + if( p->eStage==RBU_STAGE_OAL ){
|
| + sqlite3 *db = p->dbMain;
|
| + p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, &p->zErrmsg);
|
| +
|
| + /* Point the object iterator at the first object */
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = rbuObjIterFirst(p, &p->objiter);
|
| + }
|
| +
|
| + /* If the RBU database contains no data_xxx tables, declare the RBU
|
| + ** update finished. */
|
| + if( p->rc==SQLITE_OK && p->objiter.zTbl==0 ){
|
| + p->rc = SQLITE_DONE;
|
| + p->eStage = RBU_STAGE_DONE;
|
| + }else{
|
| + if( p->rc==SQLITE_OK && pState->eStage==0 && rbuIsVacuum(p) ){
|
| + rbuCopyPragma(p, "page_size");
|
| + rbuCopyPragma(p, "auto_vacuum");
|
| + }
|
| +
|
| + /* Open transactions both databases. The *-oal file is opened or
|
| + ** created at this point. */
|
| + if( p->rc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(db, "BEGIN IMMEDIATE", 0, 0, &p->zErrmsg);
|
| + }
|
| +
|
| + /* Check if the main database is a zipvfs db. If it is, set the upper
|
| + ** level pager to use "journal_mode=off". This prevents it from
|
| + ** generating a large journal using a temp file. */
|
| + if( p->rc==SQLITE_OK ){
|
| + int frc = sqlite3_file_control(db, "main", SQLITE_FCNTL_ZIPVFS, 0);
|
| + if( frc==SQLITE_OK ){
|
| + p->rc = sqlite3_exec(
|
| + db, "PRAGMA journal_mode=off",0,0,&p->zErrmsg);
|
| + }
|
| + }
|
| +
|
| + if( p->rc==SQLITE_OK ){
|
| + rbuSetupOal(p, pState);
|
| + }
|
| + }
|
| + }else if( p->eStage==RBU_STAGE_MOVE ){
|
| + /* no-op */
|
| + }else if( p->eStage==RBU_STAGE_CKPT ){
|
| + rbuSetupCheckpoint(p, pState);
|
| + }else if( p->eStage==RBU_STAGE_DONE ){
|
| + p->rc = SQLITE_DONE;
|
| + }else{
|
| + p->rc = SQLITE_CORRUPT;
|
| + }
|
| + }
|
| +
|
| + rbuFreeState(pState);
|
| + }
|
| +
|
| + return p;
|
| +}
|
| +
|
| +/*
|
| +** Allocate and return an RBU handle with all fields zeroed except for the
|
| +** error code, which is set to SQLITE_MISUSE.
|
| +*/
|
| +static sqlite3rbu *rbuMisuseError(void){
|
| + sqlite3rbu *pRet;
|
| + pRet = sqlite3_malloc64(sizeof(sqlite3rbu));
|
| + if( pRet ){
|
| + memset(pRet, 0, sizeof(sqlite3rbu));
|
| + pRet->rc = SQLITE_MISUSE;
|
| + }
|
| + return pRet;
|
| +}
|
| +
|
| +/*
|
| +** Open and return a new RBU handle.
|
| +*/
|
| +SQLITE_API sqlite3rbu *sqlite3rbu_open(
|
| + const char *zTarget,
|
| + const char *zRbu,
|
| + const char *zState
|
| +){
|
| + if( zTarget==0 || zRbu==0 ){ return rbuMisuseError(); }
|
| + /* TODO: Check that zTarget and zRbu are non-NULL */
|
| + return openRbuHandle(zTarget, zRbu, zState);
|
| +}
|
| +
|
| +/*
|
| +** Open a handle to begin or resume an RBU VACUUM operation.
|
| +*/
|
| +SQLITE_API sqlite3rbu *sqlite3rbu_vacuum(
|
| + const char *zTarget,
|
| + const char *zState
|
| +){
|
| + if( zTarget==0 ){ return rbuMisuseError(); }
|
| + /* TODO: Check that both arguments are non-NULL */
|
| + return openRbuHandle(0, zTarget, zState);
|
| +}
|
| +
|
| +/*
|
| +** Return the database handle used by pRbu.
|
| +*/
|
| +SQLITE_API sqlite3 *sqlite3rbu_db(sqlite3rbu *pRbu, int bRbu){
|
| + sqlite3 *db = 0;
|
| + if( pRbu ){
|
| + db = (bRbu ? pRbu->dbRbu : pRbu->dbMain);
|
| + }
|
| + return db;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** If the error code currently stored in the RBU handle is SQLITE_CONSTRAINT,
|
| +** then edit any error message string so as to remove all occurrences of
|
| +** the pattern "rbu_imp_[0-9]*".
|
| +*/
|
| +static void rbuEditErrmsg(sqlite3rbu *p){
|
| + if( p->rc==SQLITE_CONSTRAINT && p->zErrmsg ){
|
| + unsigned int i;
|
| + size_t nErrmsg = strlen(p->zErrmsg);
|
| + for(i=0; i<(nErrmsg-8); i++){
|
| + if( memcmp(&p->zErrmsg[i], "rbu_imp_", 8)==0 ){
|
| + int nDel = 8;
|
| + while( p->zErrmsg[i+nDel]>='0' && p->zErrmsg[i+nDel]<='9' ) nDel++;
|
| + memmove(&p->zErrmsg[i], &p->zErrmsg[i+nDel], nErrmsg + 1 - i - nDel);
|
| + nErrmsg -= nDel;
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Close the RBU handle.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_close(sqlite3rbu *p, char **pzErrmsg){
|
| + int rc;
|
| + if( p ){
|
| +
|
| + /* Commit the transaction to the *-oal file. */
|
| + if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
|
| + p->rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, &p->zErrmsg);
|
| + }
|
| +
|
| + rbuSaveState(p, p->eStage);
|
| +
|
| + if( p->rc==SQLITE_OK && p->eStage==RBU_STAGE_OAL ){
|
| + p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, &p->zErrmsg);
|
| + }
|
| +
|
| + /* Close any open statement handles. */
|
| + rbuObjIterFinalize(&p->objiter);
|
| +
|
| + /* If this is an RBU vacuum handle and the vacuum has either finished
|
| + ** successfully or encountered an error, delete the contents of the
|
| + ** state table. This causes the next call to sqlite3rbu_vacuum()
|
| + ** specifying the current target and state databases to start a new
|
| + ** vacuum from scratch. */
|
| + if( rbuIsVacuum(p) && p->rc!=SQLITE_OK && p->dbRbu ){
|
| + int rc2 = sqlite3_exec(p->dbRbu, "DELETE FROM stat.rbu_state", 0, 0, 0);
|
| + if( p->rc==SQLITE_DONE && rc2!=SQLITE_OK ) p->rc = rc2;
|
| + }
|
| +
|
| + /* Close the open database handle and VFS object. */
|
| + sqlite3_close(p->dbRbu);
|
| + sqlite3_close(p->dbMain);
|
| + rbuDeleteVfs(p);
|
| + sqlite3_free(p->aBuf);
|
| + sqlite3_free(p->aFrame);
|
| +
|
| + rbuEditErrmsg(p);
|
| + rc = p->rc;
|
| + *pzErrmsg = p->zErrmsg;
|
| + sqlite3_free(p->zState);
|
| + sqlite3_free(p);
|
| + }else{
|
| + rc = SQLITE_NOMEM;
|
| + *pzErrmsg = 0;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Return the total number of key-value operations (inserts, deletes or
|
| +** updates) that have been performed on the target database since the
|
| +** current RBU update was started.
|
| +*/
|
| +SQLITE_API sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu){
|
| + return pRbu->nProgress;
|
| +}
|
| +
|
| +/*
|
| +** Return permyriadage progress indications for the two main stages of
|
| +** an RBU update.
|
| +*/
|
| +SQLITE_API void sqlite3rbu_bp_progress(sqlite3rbu *p, int *pnOne, int *pnTwo){
|
| + const int MAX_PROGRESS = 10000;
|
| + switch( p->eStage ){
|
| + case RBU_STAGE_OAL:
|
| + if( p->nPhaseOneStep>0 ){
|
| + *pnOne = (int)(MAX_PROGRESS * (i64)p->nProgress/(i64)p->nPhaseOneStep);
|
| + }else{
|
| + *pnOne = -1;
|
| + }
|
| + *pnTwo = 0;
|
| + break;
|
| +
|
| + case RBU_STAGE_MOVE:
|
| + *pnOne = MAX_PROGRESS;
|
| + *pnTwo = 0;
|
| + break;
|
| +
|
| + case RBU_STAGE_CKPT:
|
| + *pnOne = MAX_PROGRESS;
|
| + *pnTwo = (int)(MAX_PROGRESS * (i64)p->nStep / (i64)p->nFrame);
|
| + break;
|
| +
|
| + case RBU_STAGE_DONE:
|
| + *pnOne = MAX_PROGRESS;
|
| + *pnTwo = MAX_PROGRESS;
|
| + break;
|
| +
|
| + default:
|
| + assert( 0 );
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Return the current state of the RBU vacuum or update operation.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_state(sqlite3rbu *p){
|
| + int aRes[] = {
|
| + 0, SQLITE_RBU_STATE_OAL, SQLITE_RBU_STATE_MOVE,
|
| + 0, SQLITE_RBU_STATE_CHECKPOINT, SQLITE_RBU_STATE_DONE
|
| + };
|
| +
|
| + assert( RBU_STAGE_OAL==1 );
|
| + assert( RBU_STAGE_MOVE==2 );
|
| + assert( RBU_STAGE_CKPT==4 );
|
| + assert( RBU_STAGE_DONE==5 );
|
| + assert( aRes[RBU_STAGE_OAL]==SQLITE_RBU_STATE_OAL );
|
| + assert( aRes[RBU_STAGE_MOVE]==SQLITE_RBU_STATE_MOVE );
|
| + assert( aRes[RBU_STAGE_CKPT]==SQLITE_RBU_STATE_CHECKPOINT );
|
| + assert( aRes[RBU_STAGE_DONE]==SQLITE_RBU_STATE_DONE );
|
| +
|
| + if( p->rc!=SQLITE_OK && p->rc!=SQLITE_DONE ){
|
| + return SQLITE_RBU_STATE_ERROR;
|
| + }else{
|
| + assert( p->rc!=SQLITE_DONE || p->eStage==RBU_STAGE_DONE );
|
| + assert( p->eStage==RBU_STAGE_OAL
|
| + || p->eStage==RBU_STAGE_MOVE
|
| + || p->eStage==RBU_STAGE_CKPT
|
| + || p->eStage==RBU_STAGE_DONE
|
| + );
|
| + return aRes[p->eStage];
|
| + }
|
| +}
|
| +
|
| +SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *p){
|
| + int rc = p->rc;
|
| + if( rc==SQLITE_DONE ) return SQLITE_OK;
|
| +
|
| + assert( p->eStage>=RBU_STAGE_OAL && p->eStage<=RBU_STAGE_DONE );
|
| + if( p->eStage==RBU_STAGE_OAL ){
|
| + assert( rc!=SQLITE_DONE );
|
| + if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "COMMIT", 0, 0, 0);
|
| + }
|
| +
|
| + p->rc = rc;
|
| + rbuSaveState(p, p->eStage);
|
| + rc = p->rc;
|
| +
|
| + if( p->eStage==RBU_STAGE_OAL ){
|
| + assert( rc!=SQLITE_DONE );
|
| + if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
|
| + if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "BEGIN IMMEDIATE", 0, 0, 0);
|
| + if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0,0);
|
| + }
|
| +
|
| + p->rc = rc;
|
| + return rc;
|
| +}
|
| +
|
| +/**************************************************************************
|
| +** Beginning of RBU VFS shim methods. The VFS shim modifies the behaviour
|
| +** of a standard VFS in the following ways:
|
| +**
|
| +** 1. Whenever the first page of a main database file is read or
|
| +** written, the value of the change-counter cookie is stored in
|
| +** rbu_file.iCookie. Similarly, the value of the "write-version"
|
| +** database header field is stored in rbu_file.iWriteVer. This ensures
|
| +** that the values are always trustworthy within an open transaction.
|
| +**
|
| +** 2. Whenever an SQLITE_OPEN_WAL file is opened, the (rbu_file.pWalFd)
|
| +** member variable of the associated database file descriptor is set
|
| +** to point to the new file. A mutex protected linked list of all main
|
| +** db fds opened using a particular RBU VFS is maintained at
|
| +** rbu_vfs.pMain to facilitate this.
|
| +**
|
| +** 3. Using a new file-control "SQLITE_FCNTL_RBU", a main db rbu_file
|
| +** object can be marked as the target database of an RBU update. This
|
| +** turns on the following extra special behaviour:
|
| +**
|
| +** 3a. If xAccess() is called to check if there exists a *-wal file
|
| +** associated with an RBU target database currently in RBU_STAGE_OAL
|
| +** stage (preparing the *-oal file), the following special handling
|
| +** applies:
|
| +**
|
| +** * if the *-wal file does exist, return SQLITE_CANTOPEN. An RBU
|
| +** target database may not be in wal mode already.
|
| +**
|
| +** * if the *-wal file does not exist, set the output parameter to
|
| +** non-zero (to tell SQLite that it does exist) anyway.
|
| +**
|
| +** Then, when xOpen() is called to open the *-wal file associated with
|
| +** the RBU target in RBU_STAGE_OAL stage, instead of opening the *-wal
|
| +** file, the rbu vfs opens the corresponding *-oal file instead.
|
| +**
|
| +** 3b. The *-shm pages returned by xShmMap() for a target db file in
|
| +** RBU_STAGE_OAL mode are actually stored in heap memory. This is to
|
| +** avoid creating a *-shm file on disk. Additionally, xShmLock() calls
|
| +** are no-ops on target database files in RBU_STAGE_OAL mode. This is
|
| +** because assert() statements in some VFS implementations fail if
|
| +** xShmLock() is called before xShmMap().
|
| +**
|
| +** 3c. If an EXCLUSIVE lock is attempted on a target database file in any
|
| +** mode except RBU_STAGE_DONE (all work completed and checkpointed), it
|
| +** fails with an SQLITE_BUSY error. This is to stop RBU connections
|
| +** from automatically checkpointing a *-wal (or *-oal) file from within
|
| +** sqlite3_close().
|
| +**
|
| +** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
|
| +** all xWrite() calls on the target database file perform no IO.
|
| +** Instead the frame and page numbers that would be read and written
|
| +** are recorded. Additionally, successful attempts to obtain exclusive
|
| +** xShmLock() WRITER, CHECKPOINTER and READ0 locks on the target
|
| +** database file are recorded. xShmLock() calls to unlock the same
|
| +** locks are no-ops (so that once obtained, these locks are never
|
| +** relinquished). Finally, calls to xSync() on the target database
|
| +** file fail with SQLITE_INTERNAL errors.
|
| +*/
|
| +
|
| +static void rbuUnlockShm(rbu_file *p){
|
| + if( p->pRbu ){
|
| + int (*xShmLock)(sqlite3_file*,int,int,int) = p->pReal->pMethods->xShmLock;
|
| + int i;
|
| + for(i=0; i<SQLITE_SHM_NLOCK;i++){
|
| + if( (1<<i) & p->pRbu->mLock ){
|
| + xShmLock(p->pReal, i, 1, SQLITE_SHM_UNLOCK|SQLITE_SHM_EXCLUSIVE);
|
| + }
|
| + }
|
| + p->pRbu->mLock = 0;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Close an rbu file.
|
| +*/
|
| +static int rbuVfsClose(sqlite3_file *pFile){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + int rc;
|
| + int i;
|
| +
|
| + /* Free the contents of the apShm[] array. And the array itself. */
|
| + for(i=0; i<p->nShm; i++){
|
| + sqlite3_free(p->apShm[i]);
|
| + }
|
| + sqlite3_free(p->apShm);
|
| + p->apShm = 0;
|
| + sqlite3_free(p->zDel);
|
| +
|
| + if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
|
| + rbu_file **pp;
|
| + sqlite3_mutex_enter(p->pRbuVfs->mutex);
|
| + for(pp=&p->pRbuVfs->pMain; *pp!=p; pp=&((*pp)->pMainNext));
|
| + *pp = p->pMainNext;
|
| + sqlite3_mutex_leave(p->pRbuVfs->mutex);
|
| + rbuUnlockShm(p);
|
| + p->pReal->pMethods->xShmUnmap(p->pReal, 0);
|
| + }
|
| +
|
| + /* Close the underlying file handle */
|
| + rc = p->pReal->pMethods->xClose(p->pReal);
|
| + return rc;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Read and return an unsigned 32-bit big-endian integer from the buffer
|
| +** passed as the only argument.
|
| +*/
|
| +static u32 rbuGetU32(u8 *aBuf){
|
| + return ((u32)aBuf[0] << 24)
|
| + + ((u32)aBuf[1] << 16)
|
| + + ((u32)aBuf[2] << 8)
|
| + + ((u32)aBuf[3]);
|
| +}
|
| +
|
| +/*
|
| +** Write an unsigned 32-bit value in big-endian format to the supplied
|
| +** buffer.
|
| +*/
|
| +static void rbuPutU32(u8 *aBuf, u32 iVal){
|
| + aBuf[0] = (iVal >> 24) & 0xFF;
|
| + aBuf[1] = (iVal >> 16) & 0xFF;
|
| + aBuf[2] = (iVal >> 8) & 0xFF;
|
| + aBuf[3] = (iVal >> 0) & 0xFF;
|
| +}
|
| +
|
| +static void rbuPutU16(u8 *aBuf, u16 iVal){
|
| + aBuf[0] = (iVal >> 8) & 0xFF;
|
| + aBuf[1] = (iVal >> 0) & 0xFF;
|
| +}
|
| +
|
| +/*
|
| +** Read data from an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsRead(
|
| + sqlite3_file *pFile,
|
| + void *zBuf,
|
| + int iAmt,
|
| + sqlite_int64 iOfst
|
| +){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + sqlite3rbu *pRbu = p->pRbu;
|
| + int rc;
|
| +
|
| + if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
|
| + assert( p->openFlags & SQLITE_OPEN_WAL );
|
| + rc = rbuCaptureWalRead(p->pRbu, iOfst, iAmt);
|
| + }else{
|
| + if( pRbu && pRbu->eStage==RBU_STAGE_OAL
|
| + && (p->openFlags & SQLITE_OPEN_WAL)
|
| + && iOfst>=pRbu->iOalSz
|
| + ){
|
| + rc = SQLITE_OK;
|
| + memset(zBuf, 0, iAmt);
|
| + }else{
|
| + rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
|
| +#if 1
|
| + /* If this is being called to read the first page of the target
|
| + ** database as part of an rbu vacuum operation, synthesize the
|
| + ** contents of the first page if it does not yet exist. Otherwise,
|
| + ** SQLite will not check for a *-wal file. */
|
| + if( pRbu && rbuIsVacuum(pRbu)
|
| + && rc==SQLITE_IOERR_SHORT_READ && iOfst==0
|
| + && (p->openFlags & SQLITE_OPEN_MAIN_DB)
|
| + && pRbu->rc==SQLITE_OK
|
| + ){
|
| + sqlite3_file *pFd = (sqlite3_file*)pRbu->pRbuFd;
|
| + rc = pFd->pMethods->xRead(pFd, zBuf, iAmt, iOfst);
|
| + if( rc==SQLITE_OK ){
|
| + u8 *aBuf = (u8*)zBuf;
|
| + u32 iRoot = rbuGetU32(&aBuf[52]) ? 1 : 0;
|
| + rbuPutU32(&aBuf[52], iRoot); /* largest root page number */
|
| + rbuPutU32(&aBuf[36], 0); /* number of free pages */
|
| + rbuPutU32(&aBuf[32], 0); /* first page on free list trunk */
|
| + rbuPutU32(&aBuf[28], 1); /* size of db file in pages */
|
| + rbuPutU32(&aBuf[24], pRbu->pRbuFd->iCookie+1); /* Change counter */
|
| +
|
| + if( iAmt>100 ){
|
| + memset(&aBuf[100], 0, iAmt-100);
|
| + rbuPutU16(&aBuf[105], iAmt & 0xFFFF);
|
| + aBuf[100] = 0x0D;
|
| + }
|
| + }
|
| + }
|
| +#endif
|
| + }
|
| + if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
|
| + /* These look like magic numbers. But they are stable, as they are part
|
| + ** of the definition of the SQLite file format, which may not change. */
|
| + u8 *pBuf = (u8*)zBuf;
|
| + p->iCookie = rbuGetU32(&pBuf[24]);
|
| + p->iWriteVer = pBuf[19];
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Write data to an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsWrite(
|
| + sqlite3_file *pFile,
|
| + const void *zBuf,
|
| + int iAmt,
|
| + sqlite_int64 iOfst
|
| +){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + sqlite3rbu *pRbu = p->pRbu;
|
| + int rc;
|
| +
|
| + if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
|
| + assert( p->openFlags & SQLITE_OPEN_MAIN_DB );
|
| + rc = rbuCaptureDbWrite(p->pRbu, iOfst);
|
| + }else{
|
| + if( pRbu && pRbu->eStage==RBU_STAGE_OAL
|
| + && (p->openFlags & SQLITE_OPEN_WAL)
|
| + && iOfst>=pRbu->iOalSz
|
| + ){
|
| + pRbu->iOalSz = iAmt + iOfst;
|
| + }
|
| + rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
|
| + if( rc==SQLITE_OK && iOfst==0 && (p->openFlags & SQLITE_OPEN_MAIN_DB) ){
|
| + /* These look like magic numbers. But they are stable, as they are part
|
| + ** of the definition of the SQLite file format, which may not change. */
|
| + u8 *pBuf = (u8*)zBuf;
|
| + p->iCookie = rbuGetU32(&pBuf[24]);
|
| + p->iWriteVer = pBuf[19];
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Truncate an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsTruncate(sqlite3_file *pFile, sqlite_int64 size){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + return p->pReal->pMethods->xTruncate(p->pReal, size);
|
| +}
|
| +
|
| +/*
|
| +** Sync an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsSync(sqlite3_file *pFile, int flags){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + if( p->pRbu && p->pRbu->eStage==RBU_STAGE_CAPTURE ){
|
| + if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
|
| + return SQLITE_INTERNAL;
|
| + }
|
| + return SQLITE_OK;
|
| + }
|
| + return p->pReal->pMethods->xSync(p->pReal, flags);
|
| +}
|
| +
|
| +/*
|
| +** Return the current file-size of an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + int rc;
|
| + rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
|
| +
|
| + /* If this is an RBU vacuum operation and this is the target database,
|
| + ** pretend that it has at least one page. Otherwise, SQLite will not
|
| + ** check for the existance of a *-wal file. rbuVfsRead() contains
|
| + ** similar logic. */
|
| + if( rc==SQLITE_OK && *pSize==0
|
| + && p->pRbu && rbuIsVacuum(p->pRbu)
|
| + && (p->openFlags & SQLITE_OPEN_MAIN_DB)
|
| + ){
|
| + *pSize = 1024;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Lock an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsLock(sqlite3_file *pFile, int eLock){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + sqlite3rbu *pRbu = p->pRbu;
|
| + int rc = SQLITE_OK;
|
| +
|
| + assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
|
| + if( eLock==SQLITE_LOCK_EXCLUSIVE
|
| + && (p->bNolock || (pRbu && pRbu->eStage!=RBU_STAGE_DONE))
|
| + ){
|
| + /* Do not allow EXCLUSIVE locks. Preventing SQLite from taking this
|
| + ** prevents it from checkpointing the database from sqlite3_close(). */
|
| + rc = SQLITE_BUSY;
|
| + }else{
|
| + rc = p->pReal->pMethods->xLock(p->pReal, eLock);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Unlock an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsUnlock(sqlite3_file *pFile, int eLock){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + return p->pReal->pMethods->xUnlock(p->pReal, eLock);
|
| +}
|
| +
|
| +/*
|
| +** Check if another file-handle holds a RESERVED lock on an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsCheckReservedLock(sqlite3_file *pFile, int *pResOut){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + return p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
|
| +}
|
| +
|
| +/*
|
| +** File control method. For custom operations on an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + int (*xControl)(sqlite3_file*,int,void*) = p->pReal->pMethods->xFileControl;
|
| + int rc;
|
| +
|
| + assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB)
|
| + || p->openFlags & (SQLITE_OPEN_TRANSIENT_DB|SQLITE_OPEN_TEMP_JOURNAL)
|
| + );
|
| + if( op==SQLITE_FCNTL_RBU ){
|
| + sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
|
| +
|
| + /* First try to find another RBU vfs lower down in the vfs stack. If
|
| + ** one is found, this vfs will operate in pass-through mode. The lower
|
| + ** level vfs will do the special RBU handling. */
|
| + rc = xControl(p->pReal, op, pArg);
|
| +
|
| + if( rc==SQLITE_NOTFOUND ){
|
| + /* Now search for a zipvfs instance lower down in the VFS stack. If
|
| + ** one is found, this is an error. */
|
| + void *dummy = 0;
|
| + rc = xControl(p->pReal, SQLITE_FCNTL_ZIPVFS, &dummy);
|
| + if( rc==SQLITE_OK ){
|
| + rc = SQLITE_ERROR;
|
| + pRbu->zErrmsg = sqlite3_mprintf("rbu/zipvfs setup error");
|
| + }else if( rc==SQLITE_NOTFOUND ){
|
| + pRbu->pTargetFd = p;
|
| + p->pRbu = pRbu;
|
| + if( p->pWalFd ) p->pWalFd->pRbu = pRbu;
|
| + rc = SQLITE_OK;
|
| + }
|
| + }
|
| + return rc;
|
| + }
|
| + else if( op==SQLITE_FCNTL_RBUCNT ){
|
| + sqlite3rbu *pRbu = (sqlite3rbu*)pArg;
|
| + pRbu->nRbu++;
|
| + pRbu->pRbuFd = p;
|
| + p->bNolock = 1;
|
| + }
|
| +
|
| + rc = xControl(p->pReal, op, pArg);
|
| + if( rc==SQLITE_OK && op==SQLITE_FCNTL_VFSNAME ){
|
| + rbu_vfs *pRbuVfs = p->pRbuVfs;
|
| + char *zIn = *(char**)pArg;
|
| + char *zOut = sqlite3_mprintf("rbu(%s)/%z", pRbuVfs->base.zName, zIn);
|
| + *(char**)pArg = zOut;
|
| + if( zOut==0 ) rc = SQLITE_NOMEM;
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Return the sector-size in bytes for an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsSectorSize(sqlite3_file *pFile){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + return p->pReal->pMethods->xSectorSize(p->pReal);
|
| +}
|
| +
|
| +/*
|
| +** Return the device characteristic flags supported by an rbuVfs-file.
|
| +*/
|
| +static int rbuVfsDeviceCharacteristics(sqlite3_file *pFile){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + return p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
|
| +}
|
| +
|
| +/*
|
| +** Take or release a shared-memory lock.
|
| +*/
|
| +static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + sqlite3rbu *pRbu = p->pRbu;
|
| + int rc = SQLITE_OK;
|
| +
|
| +#ifdef SQLITE_AMALGAMATION
|
| + assert( WAL_CKPT_LOCK==1 );
|
| +#endif
|
| +
|
| + assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
|
| + if( pRbu && (pRbu->eStage==RBU_STAGE_OAL || pRbu->eStage==RBU_STAGE_MOVE) ){
|
| + /* Magic number 1 is the WAL_CKPT_LOCK lock. Preventing SQLite from
|
| + ** taking this lock also prevents any checkpoints from occurring.
|
| + ** todo: really, it's not clear why this might occur, as
|
| + ** wal_autocheckpoint ought to be turned off. */
|
| + if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY;
|
| + }else{
|
| + int bCapture = 0;
|
| + if( n==1 && (flags & SQLITE_SHM_EXCLUSIVE)
|
| + && pRbu && pRbu->eStage==RBU_STAGE_CAPTURE
|
| + && (ofst==WAL_LOCK_WRITE || ofst==WAL_LOCK_CKPT || ofst==WAL_LOCK_READ0)
|
| + ){
|
| + bCapture = 1;
|
| + }
|
| +
|
| + if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
|
| + rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
|
| + if( bCapture && rc==SQLITE_OK ){
|
| + pRbu->mLock |= (1 << ofst);
|
| + }
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Obtain a pointer to a mapping of a single 32KiB page of the *-shm file.
|
| +*/
|
| +static int rbuVfsShmMap(
|
| + sqlite3_file *pFile,
|
| + int iRegion,
|
| + int szRegion,
|
| + int isWrite,
|
| + void volatile **pp
|
| +){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + int rc = SQLITE_OK;
|
| + int eStage = (p->pRbu ? p->pRbu->eStage : 0);
|
| +
|
| + /* If not in RBU_STAGE_OAL, allow this call to pass through. Or, if this
|
| + ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
|
| + ** instead of a file on disk. */
|
| + assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
|
| + if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
|
| + if( iRegion<=p->nShm ){
|
| + int nByte = (iRegion+1) * sizeof(char*);
|
| + char **apNew = (char**)sqlite3_realloc64(p->apShm, nByte);
|
| + if( apNew==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + memset(&apNew[p->nShm], 0, sizeof(char*) * (1 + iRegion - p->nShm));
|
| + p->apShm = apNew;
|
| + p->nShm = iRegion+1;
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK && p->apShm[iRegion]==0 ){
|
| + char *pNew = (char*)sqlite3_malloc64(szRegion);
|
| + if( pNew==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + memset(pNew, 0, szRegion);
|
| + p->apShm[iRegion] = pNew;
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + *pp = p->apShm[iRegion];
|
| + }else{
|
| + *pp = 0;
|
| + }
|
| + }else{
|
| + assert( p->apShm==0 );
|
| + rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Memory barrier.
|
| +*/
|
| +static void rbuVfsShmBarrier(sqlite3_file *pFile){
|
| + rbu_file *p = (rbu_file *)pFile;
|
| + p->pReal->pMethods->xShmBarrier(p->pReal);
|
| +}
|
| +
|
| +/*
|
| +** The xShmUnmap method.
|
| +*/
|
| +static int rbuVfsShmUnmap(sqlite3_file *pFile, int delFlag){
|
| + rbu_file *p = (rbu_file*)pFile;
|
| + int rc = SQLITE_OK;
|
| + int eStage = (p->pRbu ? p->pRbu->eStage : 0);
|
| +
|
| + assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
|
| + if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
|
| + /* no-op */
|
| + }else{
|
| + /* Release the checkpointer and writer locks */
|
| + rbuUnlockShm(p);
|
| + rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Given that zWal points to a buffer containing a wal file name passed to
|
| +** either the xOpen() or xAccess() VFS method, return a pointer to the
|
| +** file-handle opened by the same database connection on the corresponding
|
| +** database file.
|
| +*/
|
| +static rbu_file *rbuFindMaindb(rbu_vfs *pRbuVfs, const char *zWal){
|
| + rbu_file *pDb;
|
| + sqlite3_mutex_enter(pRbuVfs->mutex);
|
| + for(pDb=pRbuVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext){}
|
| + sqlite3_mutex_leave(pRbuVfs->mutex);
|
| + return pDb;
|
| +}
|
| +
|
| +/*
|
| +** A main database named zName has just been opened. The following
|
| +** function returns a pointer to a buffer owned by SQLite that contains
|
| +** the name of the *-wal file this db connection will use. SQLite
|
| +** happens to pass a pointer to this buffer when using xAccess()
|
| +** or xOpen() to operate on the *-wal file.
|
| +*/
|
| +static const char *rbuMainToWal(const char *zName, int flags){
|
| + int n = (int)strlen(zName);
|
| + const char *z = &zName[n];
|
| + if( flags & SQLITE_OPEN_URI ){
|
| + int odd = 0;
|
| + while( 1 ){
|
| + if( z[0]==0 ){
|
| + odd = 1 - odd;
|
| + if( odd && z[1]==0 ) break;
|
| + }
|
| + z++;
|
| + }
|
| + z += 2;
|
| + }else{
|
| + while( *z==0 ) z++;
|
| + }
|
| + z += (n + 8 + 1);
|
| + return z;
|
| +}
|
| +
|
| +/*
|
| +** Open an rbu file handle.
|
| +*/
|
| +static int rbuVfsOpen(
|
| + sqlite3_vfs *pVfs,
|
| + const char *zName,
|
| + sqlite3_file *pFile,
|
| + int flags,
|
| + int *pOutFlags
|
| +){
|
| + static sqlite3_io_methods rbuvfs_io_methods = {
|
| + 2, /* iVersion */
|
| + rbuVfsClose, /* xClose */
|
| + rbuVfsRead, /* xRead */
|
| + rbuVfsWrite, /* xWrite */
|
| + rbuVfsTruncate, /* xTruncate */
|
| + rbuVfsSync, /* xSync */
|
| + rbuVfsFileSize, /* xFileSize */
|
| + rbuVfsLock, /* xLock */
|
| + rbuVfsUnlock, /* xUnlock */
|
| + rbuVfsCheckReservedLock, /* xCheckReservedLock */
|
| + rbuVfsFileControl, /* xFileControl */
|
| + rbuVfsSectorSize, /* xSectorSize */
|
| + rbuVfsDeviceCharacteristics, /* xDeviceCharacteristics */
|
| + rbuVfsShmMap, /* xShmMap */
|
| + rbuVfsShmLock, /* xShmLock */
|
| + rbuVfsShmBarrier, /* xShmBarrier */
|
| + rbuVfsShmUnmap, /* xShmUnmap */
|
| + 0, 0 /* xFetch, xUnfetch */
|
| + };
|
| + rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
|
| + sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
|
| + rbu_file *pFd = (rbu_file *)pFile;
|
| + int rc = SQLITE_OK;
|
| + const char *zOpen = zName;
|
| + int oflags = flags;
|
| +
|
| + memset(pFd, 0, sizeof(rbu_file));
|
| + pFd->pReal = (sqlite3_file*)&pFd[1];
|
| + pFd->pRbuVfs = pRbuVfs;
|
| + pFd->openFlags = flags;
|
| + if( zName ){
|
| + if( flags & SQLITE_OPEN_MAIN_DB ){
|
| + /* A main database has just been opened. The following block sets
|
| + ** (pFd->zWal) to point to a buffer owned by SQLite that contains
|
| + ** the name of the *-wal file this db connection will use. SQLite
|
| + ** happens to pass a pointer to this buffer when using xAccess()
|
| + ** or xOpen() to operate on the *-wal file. */
|
| + pFd->zWal = rbuMainToWal(zName, flags);
|
| + }
|
| + else if( flags & SQLITE_OPEN_WAL ){
|
| + rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName);
|
| + if( pDb ){
|
| + if( pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
|
| + /* This call is to open a *-wal file. Intead, open the *-oal. This
|
| + ** code ensures that the string passed to xOpen() is terminated by a
|
| + ** pair of '\0' bytes in case the VFS attempts to extract a URI
|
| + ** parameter from it. */
|
| + const char *zBase = zName;
|
| + size_t nCopy;
|
| + char *zCopy;
|
| + if( rbuIsVacuum(pDb->pRbu) ){
|
| + zBase = sqlite3_db_filename(pDb->pRbu->dbRbu, "main");
|
| + zBase = rbuMainToWal(zBase, SQLITE_OPEN_URI);
|
| + }
|
| + nCopy = strlen(zBase);
|
| + zCopy = sqlite3_malloc64(nCopy+2);
|
| + if( zCopy ){
|
| + memcpy(zCopy, zBase, nCopy);
|
| + zCopy[nCopy-3] = 'o';
|
| + zCopy[nCopy] = '\0';
|
| + zCopy[nCopy+1] = '\0';
|
| + zOpen = (const char*)(pFd->zDel = zCopy);
|
| + }else{
|
| + rc = SQLITE_NOMEM;
|
| + }
|
| + pFd->pRbu = pDb->pRbu;
|
| + }
|
| + pDb->pWalFd = pFd;
|
| + }
|
| + }
|
| + }
|
| +
|
| + if( oflags & SQLITE_OPEN_MAIN_DB
|
| + && sqlite3_uri_boolean(zName, "rbu_memory", 0)
|
| + ){
|
| + assert( oflags & SQLITE_OPEN_MAIN_DB );
|
| + oflags = SQLITE_OPEN_TEMP_DB | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
|
| + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
|
| + zOpen = 0;
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = pRealVfs->xOpen(pRealVfs, zOpen, pFd->pReal, oflags, pOutFlags);
|
| + }
|
| + if( pFd->pReal->pMethods ){
|
| + /* The xOpen() operation has succeeded. Set the sqlite3_file.pMethods
|
| + ** pointer and, if the file is a main database file, link it into the
|
| + ** mutex protected linked list of all such files. */
|
| + pFile->pMethods = &rbuvfs_io_methods;
|
| + if( flags & SQLITE_OPEN_MAIN_DB ){
|
| + sqlite3_mutex_enter(pRbuVfs->mutex);
|
| + pFd->pMainNext = pRbuVfs->pMain;
|
| + pRbuVfs->pMain = pFd;
|
| + sqlite3_mutex_leave(pRbuVfs->mutex);
|
| + }
|
| + }else{
|
| + sqlite3_free(pFd->zDel);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Delete the file located at zPath.
|
| +*/
|
| +static int rbuVfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xDelete(pRealVfs, zPath, dirSync);
|
| +}
|
| +
|
| +/*
|
| +** Test for access permissions. Return true if the requested permission
|
| +** is available, or false otherwise.
|
| +*/
|
| +static int rbuVfsAccess(
|
| + sqlite3_vfs *pVfs,
|
| + const char *zPath,
|
| + int flags,
|
| + int *pResOut
|
| +){
|
| + rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;
|
| + sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;
|
| + int rc;
|
| +
|
| + rc = pRealVfs->xAccess(pRealVfs, zPath, flags, pResOut);
|
| +
|
| + /* If this call is to check if a *-wal file associated with an RBU target
|
| + ** database connection exists, and the RBU update is in RBU_STAGE_OAL,
|
| + ** the following special handling is activated:
|
| + **
|
| + ** a) if the *-wal file does exist, return SQLITE_CANTOPEN. This
|
| + ** ensures that the RBU extension never tries to update a database
|
| + ** in wal mode, even if the first page of the database file has
|
| + ** been damaged.
|
| + **
|
| + ** b) if the *-wal file does not exist, claim that it does anyway,
|
| + ** causing SQLite to call xOpen() to open it. This call will also
|
| + ** be intercepted (see the rbuVfsOpen() function) and the *-oal
|
| + ** file opened instead.
|
| + */
|
| + if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
|
| + rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath);
|
| + if( pDb && pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
|
| + if( *pResOut ){
|
| + rc = SQLITE_CANTOPEN;
|
| + }else{
|
| + *pResOut = 1;
|
| + }
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Populate buffer zOut with the full canonical pathname corresponding
|
| +** to the pathname in zPath. zOut is guaranteed to point to a buffer
|
| +** of at least (DEVSYM_MAX_PATHNAME+1) bytes.
|
| +*/
|
| +static int rbuVfsFullPathname(
|
| + sqlite3_vfs *pVfs,
|
| + const char *zPath,
|
| + int nOut,
|
| + char *zOut
|
| +){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xFullPathname(pRealVfs, zPath, nOut, zOut);
|
| +}
|
| +
|
| +#ifndef SQLITE_OMIT_LOAD_EXTENSION
|
| +/*
|
| +** Open the dynamic library located at zPath and return a handle.
|
| +*/
|
| +static void *rbuVfsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xDlOpen(pRealVfs, zPath);
|
| +}
|
| +
|
| +/*
|
| +** Populate the buffer zErrMsg (size nByte bytes) with a human readable
|
| +** utf-8 string describing the most recent error encountered associated
|
| +** with dynamic libraries.
|
| +*/
|
| +static void rbuVfsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + pRealVfs->xDlError(pRealVfs, nByte, zErrMsg);
|
| +}
|
| +
|
| +/*
|
| +** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
|
| +*/
|
| +static void (*rbuVfsDlSym(
|
| + sqlite3_vfs *pVfs,
|
| + void *pArg,
|
| + const char *zSym
|
| +))(void){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xDlSym(pRealVfs, pArg, zSym);
|
| +}
|
| +
|
| +/*
|
| +** Close the dynamic library handle pHandle.
|
| +*/
|
| +static void rbuVfsDlClose(sqlite3_vfs *pVfs, void *pHandle){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + pRealVfs->xDlClose(pRealVfs, pHandle);
|
| +}
|
| +#endif /* SQLITE_OMIT_LOAD_EXTENSION */
|
| +
|
| +/*
|
| +** Populate the buffer pointed to by zBufOut with nByte bytes of
|
| +** random data.
|
| +*/
|
| +static int rbuVfsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xRandomness(pRealVfs, nByte, zBufOut);
|
| +}
|
| +
|
| +/*
|
| +** Sleep for nMicro microseconds. Return the number of microseconds
|
| +** actually slept.
|
| +*/
|
| +static int rbuVfsSleep(sqlite3_vfs *pVfs, int nMicro){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xSleep(pRealVfs, nMicro);
|
| +}
|
| +
|
| +/*
|
| +** Return the current time as a Julian Day number in *pTimeOut.
|
| +*/
|
| +static int rbuVfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
|
| + sqlite3_vfs *pRealVfs = ((rbu_vfs*)pVfs)->pRealVfs;
|
| + return pRealVfs->xCurrentTime(pRealVfs, pTimeOut);
|
| +}
|
| +
|
| +/*
|
| +** No-op.
|
| +*/
|
| +static int rbuVfsGetLastError(sqlite3_vfs *pVfs, int a, char *b){
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Deregister and destroy an RBU vfs created by an earlier call to
|
| +** sqlite3rbu_create_vfs().
|
| +*/
|
| +SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName){
|
| + sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
|
| + if( pVfs && pVfs->xOpen==rbuVfsOpen ){
|
| + sqlite3_mutex_free(((rbu_vfs*)pVfs)->mutex);
|
| + sqlite3_vfs_unregister(pVfs);
|
| + sqlite3_free(pVfs);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Create an RBU VFS named zName that accesses the underlying file-system
|
| +** via existing VFS zParent. The new object is registered as a non-default
|
| +** VFS with SQLite before returning.
|
| +*/
|
| +SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent){
|
| +
|
| + /* Template for VFS */
|
| + static sqlite3_vfs vfs_template = {
|
| + 1, /* iVersion */
|
| + 0, /* szOsFile */
|
| + 0, /* mxPathname */
|
| + 0, /* pNext */
|
| + 0, /* zName */
|
| + 0, /* pAppData */
|
| + rbuVfsOpen, /* xOpen */
|
| + rbuVfsDelete, /* xDelete */
|
| + rbuVfsAccess, /* xAccess */
|
| + rbuVfsFullPathname, /* xFullPathname */
|
| +
|
| +#ifndef SQLITE_OMIT_LOAD_EXTENSION
|
| + rbuVfsDlOpen, /* xDlOpen */
|
| + rbuVfsDlError, /* xDlError */
|
| + rbuVfsDlSym, /* xDlSym */
|
| + rbuVfsDlClose, /* xDlClose */
|
| +#else
|
| + 0, 0, 0, 0,
|
| +#endif
|
| +
|
| + rbuVfsRandomness, /* xRandomness */
|
| + rbuVfsSleep, /* xSleep */
|
| + rbuVfsCurrentTime, /* xCurrentTime */
|
| + rbuVfsGetLastError, /* xGetLastError */
|
| + 0, /* xCurrentTimeInt64 (version 2) */
|
| + 0, 0, 0 /* Unimplemented version 3 methods */
|
| + };
|
| +
|
| + rbu_vfs *pNew = 0; /* Newly allocated VFS */
|
| + int rc = SQLITE_OK;
|
| + size_t nName;
|
| + size_t nByte;
|
| +
|
| + nName = strlen(zName);
|
| + nByte = sizeof(rbu_vfs) + nName + 1;
|
| + pNew = (rbu_vfs*)sqlite3_malloc64(nByte);
|
| + if( pNew==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + sqlite3_vfs *pParent; /* Parent VFS */
|
| + memset(pNew, 0, nByte);
|
| + pParent = sqlite3_vfs_find(zParent);
|
| + if( pParent==0 ){
|
| + rc = SQLITE_NOTFOUND;
|
| + }else{
|
| + char *zSpace;
|
| + memcpy(&pNew->base, &vfs_template, sizeof(sqlite3_vfs));
|
| + pNew->base.mxPathname = pParent->mxPathname;
|
| + pNew->base.szOsFile = sizeof(rbu_file) + pParent->szOsFile;
|
| + pNew->pRealVfs = pParent;
|
| + pNew->base.zName = (const char*)(zSpace = (char*)&pNew[1]);
|
| + memcpy(zSpace, zName, nName);
|
| +
|
| + /* Allocate the mutex and register the new VFS (not as the default) */
|
| + pNew->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
|
| + if( pNew->mutex==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + rc = sqlite3_vfs_register(&pNew->base, 0);
|
| + }
|
| + }
|
| +
|
| + if( rc!=SQLITE_OK ){
|
| + sqlite3_mutex_free(pNew->mutex);
|
| + sqlite3_free(pNew);
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +
|
| +/**************************************************************************/
|
| +
|
| +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
|
| +
|
| +/************** End of sqlite3rbu.c ******************************************/
|
| +/************** Begin file dbstat.c ******************************************/
|
| +/*
|
| +** 2010 July 12
|
| +**
|
| +** The author disclaims copyright to this source code. In place of
|
| +** a legal notice, here is a blessing:
|
| +**
|
| +** May you do good and not evil.
|
| +** May you find forgiveness for yourself and forgive others.
|
| +** May you share freely, never taking more than you give.
|
| +**
|
| +******************************************************************************
|
| +**
|
| +** This file contains an implementation of the "dbstat" virtual table.
|
| +**
|
| +** The dbstat virtual table is used to extract low-level formatting
|
| +** information from an SQLite database in order to implement the
|
| +** "sqlite3_analyzer" utility. See the ../tool/spaceanal.tcl script
|
| +** for an example implementation.
|
| +**
|
| +** Additional information is available on the "dbstat.html" page of the
|
| +** official SQLite documentation.
|
| +*/
|
| +
|
| +/* #include "sqliteInt.h" ** Requires access to internal data structures ** */
|
| +#if (defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)) \
|
| + && !defined(SQLITE_OMIT_VIRTUALTABLE)
|
| +
|
| +/*
|
| +** Page paths:
|
| +**
|
| +** The value of the 'path' column describes the path taken from the
|
| +** root-node of the b-tree structure to each page. The value of the
|
| +** root-node path is '/'.
|
| +**
|
| +** The value of the path for the left-most child page of the root of
|
| +** a b-tree is '/000/'. (Btrees store content ordered from left to right
|
| +** so the pages to the left have smaller keys than the pages to the right.)
|
| +** The next to left-most child of the root page is
|
| +** '/001', and so on, each sibling page identified by a 3-digit hex
|
| +** value. The children of the 451st left-most sibling have paths such
|
| +** as '/1c2/000/, '/1c2/001/' etc.
|
| +**
|
| +** Overflow pages are specified by appending a '+' character and a
|
| +** six-digit hexadecimal value to the path to the cell they are linked
|
| +** from. For example, the three overflow pages in a chain linked from
|
| +** the left-most cell of the 450th child of the root page are identified
|
| +** by the paths:
|
| +**
|
| +** '/1c2/000+000000' // First page in overflow chain
|
| +** '/1c2/000+000001' // Second page in overflow chain
|
| +** '/1c2/000+000002' // Third page in overflow chain
|
| +**
|
| +** If the paths are sorted using the BINARY collation sequence, then
|
| +** the overflow pages associated with a cell will appear earlier in the
|
| +** sort-order than its child page:
|
| +**
|
| +** '/1c2/000/' // Left-most child of 451st child of root
|
| +*/
|
| +#define VTAB_SCHEMA \
|
| + "CREATE TABLE xx( " \
|
| + " name TEXT, /* Name of table or index */" \
|
| + " path TEXT, /* Path to page from root */" \
|
| + " pageno INTEGER, /* Page number */" \
|
| + " pagetype TEXT, /* 'internal', 'leaf' or 'overflow' */" \
|
| + " ncell INTEGER, /* Cells on page (0 for overflow) */" \
|
| + " payload INTEGER, /* Bytes of payload on this page */" \
|
| + " unused INTEGER, /* Bytes of unused space on this page */" \
|
| + " mx_payload INTEGER, /* Largest payload size of all cells */" \
|
| + " pgoffset INTEGER, /* Offset of page in file */" \
|
| + " pgsize INTEGER, /* Size of the page */" \
|
| + " schema TEXT HIDDEN /* Database schema being analyzed */" \
|
| + ");"
|
| +
|
| +
|
| +typedef struct StatTable StatTable;
|
| +typedef struct StatCursor StatCursor;
|
| +typedef struct StatPage StatPage;
|
| +typedef struct StatCell StatCell;
|
| +
|
| +struct StatCell {
|
| + int nLocal; /* Bytes of local payload */
|
| + u32 iChildPg; /* Child node (or 0 if this is a leaf) */
|
| + int nOvfl; /* Entries in aOvfl[] */
|
| + u32 *aOvfl; /* Array of overflow page numbers */
|
| + int nLastOvfl; /* Bytes of payload on final overflow page */
|
| + int iOvfl; /* Iterates through aOvfl[] */
|
| +};
|
| +
|
| +struct StatPage {
|
| + u32 iPgno;
|
| + DbPage *pPg;
|
| + int iCell;
|
| +
|
| + char *zPath; /* Path to this page */
|
| +
|
| + /* Variables populated by statDecodePage(): */
|
| + u8 flags; /* Copy of flags byte */
|
| + int nCell; /* Number of cells on page */
|
| + int nUnused; /* Number of unused bytes on page */
|
| + StatCell *aCell; /* Array of parsed cells */
|
| + u32 iRightChildPg; /* Right-child page number (or 0) */
|
| + int nMxPayload; /* Largest payload of any cell on this page */
|
| +};
|
| +
|
| +struct StatCursor {
|
| + sqlite3_vtab_cursor base;
|
| + sqlite3_stmt *pStmt; /* Iterates through set of root pages */
|
| + int isEof; /* After pStmt has returned SQLITE_DONE */
|
| + int iDb; /* Schema used for this query */
|
| +
|
| + StatPage aPage[32];
|
| + int iPage; /* Current entry in aPage[] */
|
| +
|
| + /* Values to return. */
|
| + char *zName; /* Value of 'name' column */
|
| + char *zPath; /* Value of 'path' column */
|
| + u32 iPageno; /* Value of 'pageno' column */
|
| + char *zPagetype; /* Value of 'pagetype' column */
|
| + int nCell; /* Value of 'ncell' column */
|
| + int nPayload; /* Value of 'payload' column */
|
| + int nUnused; /* Value of 'unused' column */
|
| + int nMxPayload; /* Value of 'mx_payload' column */
|
| + i64 iOffset; /* Value of 'pgOffset' column */
|
| + int szPage; /* Value of 'pgSize' column */
|
| +};
|
| +
|
| +struct StatTable {
|
| + sqlite3_vtab base;
|
| + sqlite3 *db;
|
| + int iDb; /* Index of database to analyze */
|
| +};
|
| +
|
| +#ifndef get2byte
|
| +# define get2byte(x) ((x)[0]<<8 | (x)[1])
|
| +#endif
|
| +
|
| +/*
|
| +** Connect to or create a statvfs virtual table.
|
| +*/
|
| +static int statConnect(
|
| + sqlite3 *db,
|
| + void *pAux,
|
| + int argc, const char *const*argv,
|
| + sqlite3_vtab **ppVtab,
|
| + char **pzErr
|
| +){
|
| + StatTable *pTab = 0;
|
| + int rc = SQLITE_OK;
|
| + int iDb;
|
| +
|
| + if( argc>=4 ){
|
| + Token nm;
|
| + sqlite3TokenInit(&nm, (char*)argv[3]);
|
| + iDb = sqlite3FindDb(db, &nm);
|
| + if( iDb<0 ){
|
| + *pzErr = sqlite3_mprintf("no such database: %s", argv[3]);
|
| + return SQLITE_ERROR;
|
| + }
|
| + }else{
|
| + iDb = 0;
|
| + }
|
| + rc = sqlite3_declare_vtab(db, VTAB_SCHEMA);
|
| + if( rc==SQLITE_OK ){
|
| + pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable));
|
| + if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
|
| + }
|
| +
|
| + assert( rc==SQLITE_OK || pTab==0 );
|
| + if( rc==SQLITE_OK ){
|
| + memset(pTab, 0, sizeof(StatTable));
|
| + pTab->db = db;
|
| + pTab->iDb = iDb;
|
| + }
|
| +
|
| + *ppVtab = (sqlite3_vtab*)pTab;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Disconnect from or destroy a statvfs virtual table.
|
| +*/
|
| +static int statDisconnect(sqlite3_vtab *pVtab){
|
| + sqlite3_free(pVtab);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** There is no "best-index". This virtual table always does a linear
|
| +** scan. However, a schema=? constraint should cause this table to
|
| +** operate on a different database schema, so check for it.
|
| +**
|
| +** idxNum is normally 0, but will be 1 if a schema=? constraint exists.
|
| +*/
|
| +static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
|
| + int i;
|
| +
|
| + pIdxInfo->estimatedCost = 1.0e6; /* Initial cost estimate */
|
| +
|
| + /* Look for a valid schema=? constraint. If found, change the idxNum to
|
| + ** 1 and request the value of that constraint be sent to xFilter. And
|
| + ** lower the cost estimate to encourage the constrained version to be
|
| + ** used.
|
| + */
|
| + for(i=0; i<pIdxInfo->nConstraint; i++){
|
| + if( pIdxInfo->aConstraint[i].usable==0 ) continue;
|
| + if( pIdxInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
|
| + if( pIdxInfo->aConstraint[i].iColumn!=10 ) continue;
|
| + pIdxInfo->idxNum = 1;
|
| + pIdxInfo->estimatedCost = 1.0;
|
| + pIdxInfo->aConstraintUsage[i].argvIndex = 1;
|
| + pIdxInfo->aConstraintUsage[i].omit = 1;
|
| + break;
|
| + }
|
| +
|
| +
|
| + /* Records are always returned in ascending order of (name, path).
|
| + ** If this will satisfy the client, set the orderByConsumed flag so that
|
| + ** SQLite does not do an external sort.
|
| + */
|
| + if( ( pIdxInfo->nOrderBy==1
|
| + && pIdxInfo->aOrderBy[0].iColumn==0
|
| + && pIdxInfo->aOrderBy[0].desc==0
|
| + ) ||
|
| + ( pIdxInfo->nOrderBy==2
|
| + && pIdxInfo->aOrderBy[0].iColumn==0
|
| + && pIdxInfo->aOrderBy[0].desc==0
|
| + && pIdxInfo->aOrderBy[1].iColumn==1
|
| + && pIdxInfo->aOrderBy[1].desc==0
|
| + )
|
| + ){
|
| + pIdxInfo->orderByConsumed = 1;
|
| + }
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Open a new statvfs cursor.
|
| +*/
|
| +static int statOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
|
| + StatTable *pTab = (StatTable *)pVTab;
|
| + StatCursor *pCsr;
|
| +
|
| + pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor));
|
| + if( pCsr==0 ){
|
| + return SQLITE_NOMEM_BKPT;
|
| + }else{
|
| + memset(pCsr, 0, sizeof(StatCursor));
|
| + pCsr->base.pVtab = pVTab;
|
| + pCsr->iDb = pTab->iDb;
|
| + }
|
| +
|
| + *ppCursor = (sqlite3_vtab_cursor *)pCsr;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +static void statClearPage(StatPage *p){
|
| + int i;
|
| + if( p->aCell ){
|
| + for(i=0; i<p->nCell; i++){
|
| + sqlite3_free(p->aCell[i].aOvfl);
|
| + }
|
| + sqlite3_free(p->aCell);
|
| + }
|
| + sqlite3PagerUnref(p->pPg);
|
| + sqlite3_free(p->zPath);
|
| + memset(p, 0, sizeof(StatPage));
|
| +}
|
| +
|
| +static void statResetCsr(StatCursor *pCsr){
|
| + int i;
|
| + sqlite3_reset(pCsr->pStmt);
|
| + for(i=0; i<ArraySize(pCsr->aPage); i++){
|
| + statClearPage(&pCsr->aPage[i]);
|
| + }
|
| + pCsr->iPage = 0;
|
| + sqlite3_free(pCsr->zPath);
|
| + pCsr->zPath = 0;
|
| + pCsr->isEof = 0;
|
| +}
|
| +
|
| +/*
|
| +** Close a statvfs cursor.
|
| +*/
|
| +static int statClose(sqlite3_vtab_cursor *pCursor){
|
| + StatCursor *pCsr = (StatCursor *)pCursor;
|
| + statResetCsr(pCsr);
|
| + sqlite3_finalize(pCsr->pStmt);
|
| + sqlite3_free(pCsr);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +static void getLocalPayload(
|
| + int nUsable, /* Usable bytes per page */
|
| + u8 flags, /* Page flags */
|
| + int nTotal, /* Total record (payload) size */
|
| + int *pnLocal /* OUT: Bytes stored locally */
|
| +){
|
| + int nLocal;
|
| + int nMinLocal;
|
| + int nMaxLocal;
|
| +
|
| + if( flags==0x0D ){ /* Table leaf node */
|
| + nMinLocal = (nUsable - 12) * 32 / 255 - 23;
|
| + nMaxLocal = nUsable - 35;
|
| + }else{ /* Index interior and leaf nodes */
|
| + nMinLocal = (nUsable - 12) * 32 / 255 - 23;
|
| + nMaxLocal = (nUsable - 12) * 64 / 255 - 23;
|
| + }
|
| +
|
| + nLocal = nMinLocal + (nTotal - nMinLocal) % (nUsable - 4);
|
| + if( nLocal>nMaxLocal ) nLocal = nMinLocal;
|
| + *pnLocal = nLocal;
|
| +}
|
| +
|
| +static int statDecodePage(Btree *pBt, StatPage *p){
|
| + int nUnused;
|
| + int iOff;
|
| + int nHdr;
|
| + int isLeaf;
|
| + int szPage;
|
| +
|
| + u8 *aData = sqlite3PagerGetData(p->pPg);
|
| + u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
|
| +
|
| + p->flags = aHdr[0];
|
| + p->nCell = get2byte(&aHdr[3]);
|
| + p->nMxPayload = 0;
|
| +
|
| + isLeaf = (p->flags==0x0A || p->flags==0x0D);
|
| + nHdr = 12 - isLeaf*4 + (p->iPgno==1)*100;
|
| +
|
| + nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
|
| + nUnused += (int)aHdr[7];
|
| + iOff = get2byte(&aHdr[1]);
|
| + while( iOff ){
|
| + nUnused += get2byte(&aData[iOff+2]);
|
| + iOff = get2byte(&aData[iOff]);
|
| + }
|
| + p->nUnused = nUnused;
|
| + p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
|
| + szPage = sqlite3BtreeGetPageSize(pBt);
|
| +
|
| + if( p->nCell ){
|
| + int i; /* Used to iterate through cells */
|
| + int nUsable; /* Usable bytes per page */
|
| +
|
| + sqlite3BtreeEnter(pBt);
|
| + nUsable = szPage - sqlite3BtreeGetReserveNoMutex(pBt);
|
| + sqlite3BtreeLeave(pBt);
|
| + p->aCell = sqlite3_malloc64((p->nCell+1) * sizeof(StatCell));
|
| + if( p->aCell==0 ) return SQLITE_NOMEM_BKPT;
|
| + memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));
|
| +
|
| + for(i=0; i<p->nCell; i++){
|
| + StatCell *pCell = &p->aCell[i];
|
| +
|
| + iOff = get2byte(&aData[nHdr+i*2]);
|
| + if( !isLeaf ){
|
| + pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
|
| + iOff += 4;
|
| + }
|
| + if( p->flags==0x05 ){
|
| + /* A table interior node. nPayload==0. */
|
| + }else{
|
| + u32 nPayload; /* Bytes of payload total (local+overflow) */
|
| + int nLocal; /* Bytes of payload stored locally */
|
| + iOff += getVarint32(&aData[iOff], nPayload);
|
| + if( p->flags==0x0D ){
|
| + u64 dummy;
|
| + iOff += sqlite3GetVarint(&aData[iOff], &dummy);
|
| + }
|
| + if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
|
| + getLocalPayload(nUsable, p->flags, nPayload, &nLocal);
|
| + pCell->nLocal = nLocal;
|
| + assert( nLocal>=0 );
|
| + assert( nPayload>=(u32)nLocal );
|
| + assert( nLocal<=(nUsable-35) );
|
| + if( nPayload>(u32)nLocal ){
|
| + int j;
|
| + int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
|
| + pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
|
| + pCell->nOvfl = nOvfl;
|
| + pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
|
| + if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;
|
| + pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
|
| + for(j=1; j<nOvfl; j++){
|
| + int rc;
|
| + u32 iPrev = pCell->aOvfl[j-1];
|
| + DbPage *pPg = 0;
|
| + rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);
|
| + if( rc!=SQLITE_OK ){
|
| + assert( pPg==0 );
|
| + return rc;
|
| + }
|
| + pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
|
| + sqlite3PagerUnref(pPg);
|
| + }
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
|
| +** the current value of pCsr->iPageno.
|
| +*/
|
| +static void statSizeAndOffset(StatCursor *pCsr){
|
| + StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
|
| + Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
|
| + Pager *pPager = sqlite3BtreePager(pBt);
|
| + sqlite3_file *fd;
|
| + sqlite3_int64 x[2];
|
| +
|
| + /* The default page size and offset */
|
| + pCsr->szPage = sqlite3BtreeGetPageSize(pBt);
|
| + pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
|
| +
|
| + /* If connected to a ZIPVFS backend, override the page size and
|
| + ** offset with actual values obtained from ZIPVFS.
|
| + */
|
| + fd = sqlite3PagerFile(pPager);
|
| + x[0] = pCsr->iPageno;
|
| + if( fd->pMethods!=0 && sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
|
| + pCsr->iOffset = x[0];
|
| + pCsr->szPage = (int)x[1];
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Move a statvfs cursor to the next entry in the file.
|
| +*/
|
| +static int statNext(sqlite3_vtab_cursor *pCursor){
|
| + int rc;
|
| + int nPayload;
|
| + char *z;
|
| + StatCursor *pCsr = (StatCursor *)pCursor;
|
| + StatTable *pTab = (StatTable *)pCursor->pVtab;
|
| + Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
|
| + Pager *pPager = sqlite3BtreePager(pBt);
|
| +
|
| + sqlite3_free(pCsr->zPath);
|
| + pCsr->zPath = 0;
|
| +
|
| +statNextRestart:
|
| + if( pCsr->aPage[0].pPg==0 ){
|
| + rc = sqlite3_step(pCsr->pStmt);
|
| + if( rc==SQLITE_ROW ){
|
| + int nPage;
|
| + u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
|
| + sqlite3PagerPagecount(pPager, &nPage);
|
| + if( nPage==0 ){
|
| + pCsr->isEof = 1;
|
| + return sqlite3_reset(pCsr->pStmt);
|
| + }
|
| + rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0);
|
| + pCsr->aPage[0].iPgno = iRoot;
|
| + pCsr->aPage[0].iCell = 0;
|
| + pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
|
| + pCsr->iPage = 0;
|
| + if( z==0 ) rc = SQLITE_NOMEM_BKPT;
|
| + }else{
|
| + pCsr->isEof = 1;
|
| + return sqlite3_reset(pCsr->pStmt);
|
| + }
|
| + }else{
|
| +
|
| + /* Page p itself has already been visited. */
|
| + StatPage *p = &pCsr->aPage[pCsr->iPage];
|
| +
|
| + while( p->iCell<p->nCell ){
|
| + StatCell *pCell = &p->aCell[p->iCell];
|
| + if( pCell->iOvfl<pCell->nOvfl ){
|
| + int nUsable;
|
| + sqlite3BtreeEnter(pBt);
|
| + nUsable = sqlite3BtreeGetPageSize(pBt) -
|
| + sqlite3BtreeGetReserveNoMutex(pBt);
|
| + sqlite3BtreeLeave(pBt);
|
| + pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
|
| + pCsr->iPageno = pCell->aOvfl[pCell->iOvfl];
|
| + pCsr->zPagetype = "overflow";
|
| + pCsr->nCell = 0;
|
| + pCsr->nMxPayload = 0;
|
| + pCsr->zPath = z = sqlite3_mprintf(
|
| + "%s%.3x+%.6x", p->zPath, p->iCell, pCell->iOvfl
|
| + );
|
| + if( pCell->iOvfl<pCell->nOvfl-1 ){
|
| + pCsr->nUnused = 0;
|
| + pCsr->nPayload = nUsable - 4;
|
| + }else{
|
| + pCsr->nPayload = pCell->nLastOvfl;
|
| + pCsr->nUnused = nUsable - 4 - pCsr->nPayload;
|
| + }
|
| + pCell->iOvfl++;
|
| + statSizeAndOffset(pCsr);
|
| + return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
|
| + }
|
| + if( p->iRightChildPg ) break;
|
| + p->iCell++;
|
| + }
|
| +
|
| + if( !p->iRightChildPg || p->iCell>p->nCell ){
|
| + statClearPage(p);
|
| + if( pCsr->iPage==0 ) return statNext(pCursor);
|
| + pCsr->iPage--;
|
| + goto statNextRestart; /* Tail recursion */
|
| + }
|
| + pCsr->iPage++;
|
| + assert( p==&pCsr->aPage[pCsr->iPage-1] );
|
| +
|
| + if( p->iCell==p->nCell ){
|
| + p[1].iPgno = p->iRightChildPg;
|
| + }else{
|
| + p[1].iPgno = p->aCell[p->iCell].iChildPg;
|
| + }
|
| + rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg, 0);
|
| + p[1].iCell = 0;
|
| + p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
|
| + p->iCell++;
|
| + if( z==0 ) rc = SQLITE_NOMEM_BKPT;
|
| + }
|
| +
|
| +
|
| + /* Populate the StatCursor fields with the values to be returned
|
| + ** by the xColumn() and xRowid() methods.
|
| + */
|
| + if( rc==SQLITE_OK ){
|
| + int i;
|
| + StatPage *p = &pCsr->aPage[pCsr->iPage];
|
| + pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
|
| + pCsr->iPageno = p->iPgno;
|
| +
|
| + rc = statDecodePage(pBt, p);
|
| + if( rc==SQLITE_OK ){
|
| + statSizeAndOffset(pCsr);
|
| +
|
| + switch( p->flags ){
|
| + case 0x05: /* table internal */
|
| + case 0x02: /* index internal */
|
| + pCsr->zPagetype = "internal";
|
| + break;
|
| + case 0x0D: /* table leaf */
|
| + case 0x0A: /* index leaf */
|
| + pCsr->zPagetype = "leaf";
|
| + break;
|
| + default:
|
| + pCsr->zPagetype = "corrupted";
|
| + break;
|
| + }
|
| + pCsr->nCell = p->nCell;
|
| + pCsr->nUnused = p->nUnused;
|
| + pCsr->nMxPayload = p->nMxPayload;
|
| + pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
|
| + if( z==0 ) rc = SQLITE_NOMEM_BKPT;
|
| + nPayload = 0;
|
| + for(i=0; i<p->nCell; i++){
|
| + nPayload += p->aCell[i].nLocal;
|
| + }
|
| + pCsr->nPayload = nPayload;
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +static int statEof(sqlite3_vtab_cursor *pCursor){
|
| + StatCursor *pCsr = (StatCursor *)pCursor;
|
| + return pCsr->isEof;
|
| +}
|
| +
|
| +static int statFilter(
|
| + sqlite3_vtab_cursor *pCursor,
|
| + int idxNum, const char *idxStr,
|
| + int argc, sqlite3_value **argv
|
| +){
|
| + StatCursor *pCsr = (StatCursor *)pCursor;
|
| + StatTable *pTab = (StatTable*)(pCursor->pVtab);
|
| + char *zSql;
|
| + int rc = SQLITE_OK;
|
| + char *zMaster;
|
| +
|
| + if( idxNum==1 ){
|
| + const char *zDbase = (const char*)sqlite3_value_text(argv[0]);
|
| + pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
|
| + if( pCsr->iDb<0 ){
|
| + sqlite3_free(pCursor->pVtab->zErrMsg);
|
| + pCursor->pVtab->zErrMsg = sqlite3_mprintf("no such schema: %s", zDbase);
|
| + return pCursor->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM_BKPT;
|
| + }
|
| + }else{
|
| + pCsr->iDb = pTab->iDb;
|
| + }
|
| + statResetCsr(pCsr);
|
| + sqlite3_finalize(pCsr->pStmt);
|
| + pCsr->pStmt = 0;
|
| + zMaster = pCsr->iDb==1 ? "sqlite_temp_master" : "sqlite_master";
|
| + zSql = sqlite3_mprintf(
|
| + "SELECT 'sqlite_master' AS name, 1 AS rootpage, 'table' AS type"
|
| + " UNION ALL "
|
| + "SELECT name, rootpage, type"
|
| + " FROM \"%w\".%s WHERE rootpage!=0"
|
| + " ORDER BY name", pTab->db->aDb[pCsr->iDb].zDbSName, zMaster);
|
| + if( zSql==0 ){
|
| + return SQLITE_NOMEM_BKPT;
|
| + }else{
|
| + rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
|
| + sqlite3_free(zSql);
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = statNext(pCursor);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +static int statColumn(
|
| + sqlite3_vtab_cursor *pCursor,
|
| + sqlite3_context *ctx,
|
| + int i
|
| +){
|
| + StatCursor *pCsr = (StatCursor *)pCursor;
|
| + switch( i ){
|
| + case 0: /* name */
|
| + sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
|
| + break;
|
| + case 1: /* path */
|
| + sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
|
| + break;
|
| + case 2: /* pageno */
|
| + sqlite3_result_int64(ctx, pCsr->iPageno);
|
| + break;
|
| + case 3: /* pagetype */
|
| + sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
|
| + break;
|
| + case 4: /* ncell */
|
| + sqlite3_result_int(ctx, pCsr->nCell);
|
| + break;
|
| + case 5: /* payload */
|
| + sqlite3_result_int(ctx, pCsr->nPayload);
|
| + break;
|
| + case 6: /* unused */
|
| + sqlite3_result_int(ctx, pCsr->nUnused);
|
| + break;
|
| + case 7: /* mx_payload */
|
| + sqlite3_result_int(ctx, pCsr->nMxPayload);
|
| + break;
|
| + case 8: /* pgoffset */
|
| + sqlite3_result_int64(ctx, pCsr->iOffset);
|
| + break;
|
| + case 9: /* pgsize */
|
| + sqlite3_result_int(ctx, pCsr->szPage);
|
| + break;
|
| + default: { /* schema */
|
| + sqlite3 *db = sqlite3_context_db_handle(ctx);
|
| + int iDb = pCsr->iDb;
|
| + sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
|
| + break;
|
| + }
|
| + }
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +static int statRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
|
| + StatCursor *pCsr = (StatCursor *)pCursor;
|
| + *pRowid = pCsr->iPageno;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Invoke this routine to register the "dbstat" virtual table module
|
| +*/
|
| +SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){
|
| + static sqlite3_module dbstat_module = {
|
| + 0, /* iVersion */
|
| + statConnect, /* xCreate */
|
| + statConnect, /* xConnect */
|
| + statBestIndex, /* xBestIndex */
|
| + statDisconnect, /* xDisconnect */
|
| + statDisconnect, /* xDestroy */
|
| + statOpen, /* xOpen - open a cursor */
|
| + statClose, /* xClose - close a cursor */
|
| + statFilter, /* xFilter - configure scan constraints */
|
| + statNext, /* xNext - advance a cursor */
|
| + statEof, /* xEof - check for end of scan */
|
| + statColumn, /* xColumn - read data */
|
| + statRowid, /* xRowid - read data */
|
| + 0, /* xUpdate */
|
| + 0, /* xBegin */
|
| + 0, /* xSync */
|
| + 0, /* xCommit */
|
| + 0, /* xRollback */
|
| + 0, /* xFindMethod */
|
| + 0, /* xRename */
|
| + };
|
| + return sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
|
| +}
|
| +#elif defined(SQLITE_ENABLE_DBSTAT_VTAB)
|
| +SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; }
|
| +#endif /* SQLITE_ENABLE_DBSTAT_VTAB */
|
| +
|
| +/************** End of dbstat.c **********************************************/
|
| +/************** Begin file sqlite3session.c **********************************/
|
| +
|
| +#if defined(SQLITE_ENABLE_SESSION) && defined(SQLITE_ENABLE_PREUPDATE_HOOK)
|
| +/* #include "sqlite3session.h" */
|
| +/* #include <assert.h> */
|
| +/* #include <string.h> */
|
| +
|
| +#ifndef SQLITE_AMALGAMATION
|
| +/* # include "sqliteInt.h" */
|
| +/* # include "vdbeInt.h" */
|
| +#endif
|
| +
|
| +typedef struct SessionTable SessionTable;
|
| +typedef struct SessionChange SessionChange;
|
| +typedef struct SessionBuffer SessionBuffer;
|
| +typedef struct SessionInput SessionInput;
|
| +
|
| +/*
|
| +** Minimum chunk size used by streaming versions of functions.
|
| +*/
|
| +#ifndef SESSIONS_STRM_CHUNK_SIZE
|
| +# ifdef SQLITE_TEST
|
| +# define SESSIONS_STRM_CHUNK_SIZE 64
|
| +# else
|
| +# define SESSIONS_STRM_CHUNK_SIZE 1024
|
| +# endif
|
| +#endif
|
| +
|
| +typedef struct SessionHook SessionHook;
|
| +struct SessionHook {
|
| + void *pCtx;
|
| + int (*xOld)(void*,int,sqlite3_value**);
|
| + int (*xNew)(void*,int,sqlite3_value**);
|
| + int (*xCount)(void*);
|
| + int (*xDepth)(void*);
|
| +};
|
| +
|
| +/*
|
| +** Session handle structure.
|
| +*/
|
| +struct sqlite3_session {
|
| + sqlite3 *db; /* Database handle session is attached to */
|
| + char *zDb; /* Name of database session is attached to */
|
| + int bEnable; /* True if currently recording */
|
| + int bIndirect; /* True if all changes are indirect */
|
| + int bAutoAttach; /* True to auto-attach tables */
|
| + int rc; /* Non-zero if an error has occurred */
|
| + void *pFilterCtx; /* First argument to pass to xTableFilter */
|
| + int (*xTableFilter)(void *pCtx, const char *zTab);
|
| + sqlite3_session *pNext; /* Next session object on same db. */
|
| + SessionTable *pTable; /* List of attached tables */
|
| + SessionHook hook; /* APIs to grab new and old data with */
|
| +};
|
| +
|
| +/*
|
| +** Instances of this structure are used to build strings or binary records.
|
| +*/
|
| +struct SessionBuffer {
|
| + u8 *aBuf; /* Pointer to changeset buffer */
|
| + int nBuf; /* Size of buffer aBuf */
|
| + int nAlloc; /* Size of allocation containing aBuf */
|
| +};
|
| +
|
| +/*
|
| +** An object of this type is used internally as an abstraction for
|
| +** input data. Input data may be supplied either as a single large buffer
|
| +** (e.g. sqlite3changeset_start()) or using a stream function (e.g.
|
| +** sqlite3changeset_start_strm()).
|
| +*/
|
| +struct SessionInput {
|
| + int bNoDiscard; /* If true, discard no data */
|
| + int iCurrent; /* Offset in aData[] of current change */
|
| + int iNext; /* Offset in aData[] of next change */
|
| + u8 *aData; /* Pointer to buffer containing changeset */
|
| + int nData; /* Number of bytes in aData */
|
| +
|
| + SessionBuffer buf; /* Current read buffer */
|
| + int (*xInput)(void*, void*, int*); /* Input stream call (or NULL) */
|
| + void *pIn; /* First argument to xInput */
|
| + int bEof; /* Set to true after xInput finished */
|
| +};
|
| +
|
| +/*
|
| +** Structure for changeset iterators.
|
| +*/
|
| +struct sqlite3_changeset_iter {
|
| + SessionInput in; /* Input buffer or stream */
|
| + SessionBuffer tblhdr; /* Buffer to hold apValue/zTab/abPK/ */
|
| + int bPatchset; /* True if this is a patchset */
|
| + int rc; /* Iterator error code */
|
| + sqlite3_stmt *pConflict; /* Points to conflicting row, if any */
|
| + char *zTab; /* Current table */
|
| + int nCol; /* Number of columns in zTab */
|
| + int op; /* Current operation */
|
| + int bIndirect; /* True if current change was indirect */
|
| + u8 *abPK; /* Primary key array */
|
| + sqlite3_value **apValue; /* old.* and new.* values */
|
| +};
|
| +
|
| +/*
|
| +** Each session object maintains a set of the following structures, one
|
| +** for each table the session object is monitoring. The structures are
|
| +** stored in a linked list starting at sqlite3_session.pTable.
|
| +**
|
| +** The keys of the SessionTable.aChange[] hash table are all rows that have
|
| +** been modified in any way since the session object was attached to the
|
| +** table.
|
| +**
|
| +** The data associated with each hash-table entry is a structure containing
|
| +** a subset of the initial values that the modified row contained at the
|
| +** start of the session. Or no initial values if the row was inserted.
|
| +*/
|
| +struct SessionTable {
|
| + SessionTable *pNext;
|
| + char *zName; /* Local name of table */
|
| + int nCol; /* Number of columns in table zName */
|
| + const char **azCol; /* Column names */
|
| + u8 *abPK; /* Array of primary key flags */
|
| + int nEntry; /* Total number of entries in hash table */
|
| + int nChange; /* Size of apChange[] array */
|
| + SessionChange **apChange; /* Hash table buckets */
|
| +};
|
| +
|
| +/*
|
| +** RECORD FORMAT:
|
| +**
|
| +** The following record format is similar to (but not compatible with) that
|
| +** used in SQLite database files. This format is used as part of the
|
| +** change-set binary format, and so must be architecture independent.
|
| +**
|
| +** Unlike the SQLite database record format, each field is self-contained -
|
| +** there is no separation of header and data. Each field begins with a
|
| +** single byte describing its type, as follows:
|
| +**
|
| +** 0x00: Undefined value.
|
| +** 0x01: Integer value.
|
| +** 0x02: Real value.
|
| +** 0x03: Text value.
|
| +** 0x04: Blob value.
|
| +** 0x05: SQL NULL value.
|
| +**
|
| +** Note that the above match the definitions of SQLITE_INTEGER, SQLITE_TEXT
|
| +** and so on in sqlite3.h. For undefined and NULL values, the field consists
|
| +** only of the single type byte. For other types of values, the type byte
|
| +** is followed by:
|
| +**
|
| +** Text values:
|
| +** A varint containing the number of bytes in the value (encoded using
|
| +** UTF-8). Followed by a buffer containing the UTF-8 representation
|
| +** of the text value. There is no nul terminator.
|
| +**
|
| +** Blob values:
|
| +** A varint containing the number of bytes in the value, followed by
|
| +** a buffer containing the value itself.
|
| +**
|
| +** Integer values:
|
| +** An 8-byte big-endian integer value.
|
| +**
|
| +** Real values:
|
| +** An 8-byte big-endian IEEE 754-2008 real value.
|
| +**
|
| +** Varint values are encoded in the same way as varints in the SQLite
|
| +** record format.
|
| +**
|
| +** CHANGESET FORMAT:
|
| +**
|
| +** A changeset is a collection of DELETE, UPDATE and INSERT operations on
|
| +** one or more tables. Operations on a single table are grouped together,
|
| +** but may occur in any order (i.e. deletes, updates and inserts are all
|
| +** mixed together).
|
| +**
|
| +** Each group of changes begins with a table header:
|
| +**
|
| +** 1 byte: Constant 0x54 (capital 'T')
|
| +** Varint: Number of columns in the table.
|
| +** nCol bytes: 0x01 for PK columns, 0x00 otherwise.
|
| +** N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
|
| +**
|
| +** Followed by one or more changes to the table.
|
| +**
|
| +** 1 byte: Either SQLITE_INSERT (0x12), UPDATE (0x17) or DELETE (0x09).
|
| +** 1 byte: The "indirect-change" flag.
|
| +** old.* record: (delete and update only)
|
| +** new.* record: (insert and update only)
|
| +**
|
| +** The "old.*" and "new.*" records, if present, are N field records in the
|
| +** format described above under "RECORD FORMAT", where N is the number of
|
| +** columns in the table. The i'th field of each record is associated with
|
| +** the i'th column of the table, counting from left to right in the order
|
| +** in which columns were declared in the CREATE TABLE statement.
|
| +**
|
| +** The new.* record that is part of each INSERT change contains the values
|
| +** that make up the new row. Similarly, the old.* record that is part of each
|
| +** DELETE change contains the values that made up the row that was deleted
|
| +** from the database. In the changeset format, the records that are part
|
| +** of INSERT or DELETE changes never contain any undefined (type byte 0x00)
|
| +** fields.
|
| +**
|
| +** Within the old.* record associated with an UPDATE change, all fields
|
| +** associated with table columns that are not PRIMARY KEY columns and are
|
| +** not modified by the UPDATE change are set to "undefined". Other fields
|
| +** are set to the values that made up the row before the UPDATE that the
|
| +** change records took place. Within the new.* record, fields associated
|
| +** with table columns modified by the UPDATE change contain the new
|
| +** values. Fields associated with table columns that are not modified
|
| +** are set to "undefined".
|
| +**
|
| +** PATCHSET FORMAT:
|
| +**
|
| +** A patchset is also a collection of changes. It is similar to a changeset,
|
| +** but leaves undefined those fields that are not useful if no conflict
|
| +** resolution is required when applying the changeset.
|
| +**
|
| +** Each group of changes begins with a table header:
|
| +**
|
| +** 1 byte: Constant 0x50 (capital 'P')
|
| +** Varint: Number of columns in the table.
|
| +** nCol bytes: 0x01 for PK columns, 0x00 otherwise.
|
| +** N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
|
| +**
|
| +** Followed by one or more changes to the table.
|
| +**
|
| +** 1 byte: Either SQLITE_INSERT (0x12), UPDATE (0x17) or DELETE (0x09).
|
| +** 1 byte: The "indirect-change" flag.
|
| +** single record: (PK fields for DELETE, PK and modified fields for UPDATE,
|
| +** full record for INSERT).
|
| +**
|
| +** As in the changeset format, each field of the single record that is part
|
| +** of a patchset change is associated with the correspondingly positioned
|
| +** table column, counting from left to right within the CREATE TABLE
|
| +** statement.
|
| +**
|
| +** For a DELETE change, all fields within the record except those associated
|
| +** with PRIMARY KEY columns are set to "undefined". The PRIMARY KEY fields
|
| +** contain the values identifying the row to delete.
|
| +**
|
| +** For an UPDATE change, all fields except those associated with PRIMARY KEY
|
| +** columns and columns that are modified by the UPDATE are set to "undefined".
|
| +** PRIMARY KEY fields contain the values identifying the table row to update,
|
| +** and fields associated with modified columns contain the new column values.
|
| +**
|
| +** The records associated with INSERT changes are in the same format as for
|
| +** changesets. It is not possible for a record associated with an INSERT
|
| +** change to contain a field set to "undefined".
|
| +*/
|
| +
|
| +/*
|
| +** For each row modified during a session, there exists a single instance of
|
| +** this structure stored in a SessionTable.aChange[] hash table.
|
| +*/
|
| +struct SessionChange {
|
| + int op; /* One of UPDATE, DELETE, INSERT */
|
| + int bIndirect; /* True if this change is "indirect" */
|
| + int nRecord; /* Number of bytes in buffer aRecord[] */
|
| + u8 *aRecord; /* Buffer containing old.* record */
|
| + SessionChange *pNext; /* For hash-table collisions */
|
| +};
|
| +
|
| +/*
|
| +** Write a varint with value iVal into the buffer at aBuf. Return the
|
| +** number of bytes written.
|
| +*/
|
| +static int sessionVarintPut(u8 *aBuf, int iVal){
|
| + return putVarint32(aBuf, iVal);
|
| +}
|
| +
|
| +/*
|
| +** Return the number of bytes required to store value iVal as a varint.
|
| +*/
|
| +static int sessionVarintLen(int iVal){
|
| + return sqlite3VarintLen(iVal);
|
| +}
|
| +
|
| +/*
|
| +** Read a varint value from aBuf[] into *piVal. Return the number of
|
| +** bytes read.
|
| +*/
|
| +static int sessionVarintGet(u8 *aBuf, int *piVal){
|
| + return getVarint32(aBuf, *piVal);
|
| +}
|
| +
|
| +/* Load an unaligned and unsigned 32-bit integer */
|
| +#define SESSION_UINT32(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
|
| +
|
| +/*
|
| +** Read a 64-bit big-endian integer value from buffer aRec[]. Return
|
| +** the value read.
|
| +*/
|
| +static sqlite3_int64 sessionGetI64(u8 *aRec){
|
| + u64 x = SESSION_UINT32(aRec);
|
| + u32 y = SESSION_UINT32(aRec+4);
|
| + x = (x<<32) + y;
|
| + return (sqlite3_int64)x;
|
| +}
|
| +
|
| +/*
|
| +** Write a 64-bit big-endian integer value to the buffer aBuf[].
|
| +*/
|
| +static void sessionPutI64(u8 *aBuf, sqlite3_int64 i){
|
| + aBuf[0] = (i>>56) & 0xFF;
|
| + aBuf[1] = (i>>48) & 0xFF;
|
| + aBuf[2] = (i>>40) & 0xFF;
|
| + aBuf[3] = (i>>32) & 0xFF;
|
| + aBuf[4] = (i>>24) & 0xFF;
|
| + aBuf[5] = (i>>16) & 0xFF;
|
| + aBuf[6] = (i>> 8) & 0xFF;
|
| + aBuf[7] = (i>> 0) & 0xFF;
|
| +}
|
| +
|
| +/*
|
| +** This function is used to serialize the contents of value pValue (see
|
| +** comment titled "RECORD FORMAT" above).
|
| +**
|
| +** If it is non-NULL, the serialized form of the value is written to
|
| +** buffer aBuf. *pnWrite is set to the number of bytes written before
|
| +** returning. Or, if aBuf is NULL, the only thing this function does is
|
| +** set *pnWrite.
|
| +**
|
| +** If no error occurs, SQLITE_OK is returned. Or, if an OOM error occurs
|
| +** within a call to sqlite3_value_text() (may fail if the db is utf-16))
|
| +** SQLITE_NOMEM is returned.
|
| +*/
|
| +static int sessionSerializeValue(
|
| + u8 *aBuf, /* If non-NULL, write serialized value here */
|
| + sqlite3_value *pValue, /* Value to serialize */
|
| + int *pnWrite /* IN/OUT: Increment by bytes written */
|
| +){
|
| + int nByte; /* Size of serialized value in bytes */
|
| +
|
| + if( pValue ){
|
| + int eType; /* Value type (SQLITE_NULL, TEXT etc.) */
|
| +
|
| + eType = sqlite3_value_type(pValue);
|
| + if( aBuf ) aBuf[0] = eType;
|
| +
|
| + switch( eType ){
|
| + case SQLITE_NULL:
|
| + nByte = 1;
|
| + break;
|
| +
|
| + case SQLITE_INTEGER:
|
| + case SQLITE_FLOAT:
|
| + if( aBuf ){
|
| + /* TODO: SQLite does something special to deal with mixed-endian
|
| + ** floating point values (e.g. ARM7). This code probably should
|
| + ** too. */
|
| + u64 i;
|
| + if( eType==SQLITE_INTEGER ){
|
| + i = (u64)sqlite3_value_int64(pValue);
|
| + }else{
|
| + double r;
|
| + assert( sizeof(double)==8 && sizeof(u64)==8 );
|
| + r = sqlite3_value_double(pValue);
|
| + memcpy(&i, &r, 8);
|
| + }
|
| + sessionPutI64(&aBuf[1], i);
|
| + }
|
| + nByte = 9;
|
| + break;
|
| +
|
| + default: {
|
| + u8 *z;
|
| + int n;
|
| + int nVarint;
|
| +
|
| + assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
|
| + if( eType==SQLITE_TEXT ){
|
| + z = (u8 *)sqlite3_value_text(pValue);
|
| + }else{
|
| + z = (u8 *)sqlite3_value_blob(pValue);
|
| + }
|
| + n = sqlite3_value_bytes(pValue);
|
| + if( z==0 && (eType!=SQLITE_BLOB || n>0) ) return SQLITE_NOMEM;
|
| + nVarint = sessionVarintLen(n);
|
| +
|
| + if( aBuf ){
|
| + sessionVarintPut(&aBuf[1], n);
|
| + if( n ) memcpy(&aBuf[nVarint + 1], z, n);
|
| + }
|
| +
|
| + nByte = 1 + nVarint + n;
|
| + break;
|
| + }
|
| + }
|
| + }else{
|
| + nByte = 1;
|
| + if( aBuf ) aBuf[0] = '\0';
|
| + }
|
| +
|
| + if( pnWrite ) *pnWrite += nByte;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** This macro is used to calculate hash key values for data structures. In
|
| +** order to use this macro, the entire data structure must be represented
|
| +** as a series of unsigned integers. In order to calculate a hash-key value
|
| +** for a data structure represented as three such integers, the macro may
|
| +** then be used as follows:
|
| +**
|
| +** int hash_key_value;
|
| +** hash_key_value = HASH_APPEND(0, <value 1>);
|
| +** hash_key_value = HASH_APPEND(hash_key_value, <value 2>);
|
| +** hash_key_value = HASH_APPEND(hash_key_value, <value 3>);
|
| +**
|
| +** In practice, the data structures this macro is used for are the primary
|
| +** key values of modified rows.
|
| +*/
|
| +#define HASH_APPEND(hash, add) ((hash) << 3) ^ (hash) ^ (unsigned int)(add)
|
| +
|
| +/*
|
| +** Append the hash of the 64-bit integer passed as the second argument to the
|
| +** hash-key value passed as the first. Return the new hash-key value.
|
| +*/
|
| +static unsigned int sessionHashAppendI64(unsigned int h, i64 i){
|
| + h = HASH_APPEND(h, i & 0xFFFFFFFF);
|
| + return HASH_APPEND(h, (i>>32)&0xFFFFFFFF);
|
| +}
|
| +
|
| +/*
|
| +** Append the hash of the blob passed via the second and third arguments to
|
| +** the hash-key value passed as the first. Return the new hash-key value.
|
| +*/
|
| +static unsigned int sessionHashAppendBlob(unsigned int h, int n, const u8 *z){
|
| + int i;
|
| + for(i=0; i<n; i++) h = HASH_APPEND(h, z[i]);
|
| + return h;
|
| +}
|
| +
|
| +/*
|
| +** Append the hash of the data type passed as the second argument to the
|
| +** hash-key value passed as the first. Return the new hash-key value.
|
| +*/
|
| +static unsigned int sessionHashAppendType(unsigned int h, int eType){
|
| + return HASH_APPEND(h, eType);
|
| +}
|
| +
|
| +/*
|
| +** This function may only be called from within a pre-update callback.
|
| +** It calculates a hash based on the primary key values of the old.* or
|
| +** new.* row currently available and, assuming no error occurs, writes it to
|
| +** *piHash before returning. If the primary key contains one or more NULL
|
| +** values, *pbNullPK is set to true before returning.
|
| +**
|
| +** If an error occurs, an SQLite error code is returned and the final values
|
| +** of *piHash asn *pbNullPK are undefined. Otherwise, SQLITE_OK is returned
|
| +** and the output variables are set as described above.
|
| +*/
|
| +static int sessionPreupdateHash(
|
| + sqlite3_session *pSession, /* Session object that owns pTab */
|
| + SessionTable *pTab, /* Session table handle */
|
| + int bNew, /* True to hash the new.* PK */
|
| + int *piHash, /* OUT: Hash value */
|
| + int *pbNullPK /* OUT: True if there are NULL values in PK */
|
| +){
|
| + unsigned int h = 0; /* Hash value to return */
|
| + int i; /* Used to iterate through columns */
|
| +
|
| + assert( *pbNullPK==0 );
|
| + assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
|
| + for(i=0; i<pTab->nCol; i++){
|
| + if( pTab->abPK[i] ){
|
| + int rc;
|
| + int eType;
|
| + sqlite3_value *pVal;
|
| +
|
| + if( bNew ){
|
| + rc = pSession->hook.xNew(pSession->hook.pCtx, i, &pVal);
|
| + }else{
|
| + rc = pSession->hook.xOld(pSession->hook.pCtx, i, &pVal);
|
| + }
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + eType = sqlite3_value_type(pVal);
|
| + h = sessionHashAppendType(h, eType);
|
| + if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + i64 iVal;
|
| + if( eType==SQLITE_INTEGER ){
|
| + iVal = sqlite3_value_int64(pVal);
|
| + }else{
|
| + double rVal = sqlite3_value_double(pVal);
|
| + assert( sizeof(iVal)==8 && sizeof(rVal)==8 );
|
| + memcpy(&iVal, &rVal, 8);
|
| + }
|
| + h = sessionHashAppendI64(h, iVal);
|
| + }else if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
|
| + const u8 *z;
|
| + int n;
|
| + if( eType==SQLITE_TEXT ){
|
| + z = (const u8 *)sqlite3_value_text(pVal);
|
| + }else{
|
| + z = (const u8 *)sqlite3_value_blob(pVal);
|
| + }
|
| + n = sqlite3_value_bytes(pVal);
|
| + if( !z && (eType!=SQLITE_BLOB || n>0) ) return SQLITE_NOMEM;
|
| + h = sessionHashAppendBlob(h, n, z);
|
| + }else{
|
| + assert( eType==SQLITE_NULL );
|
| + *pbNullPK = 1;
|
| + }
|
| + }
|
| + }
|
| +
|
| + *piHash = (h % pTab->nChange);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** The buffer that the argument points to contains a serialized SQL value.
|
| +** Return the number of bytes of space occupied by the value (including
|
| +** the type byte).
|
| +*/
|
| +static int sessionSerialLen(u8 *a){
|
| + int e = *a;
|
| + int n;
|
| + if( e==0 ) return 1;
|
| + if( e==SQLITE_NULL ) return 1;
|
| + if( e==SQLITE_INTEGER || e==SQLITE_FLOAT ) return 9;
|
| + return sessionVarintGet(&a[1], &n) + 1 + n;
|
| +}
|
| +
|
| +/*
|
| +** Based on the primary key values stored in change aRecord, calculate a
|
| +** hash key. Assume the has table has nBucket buckets. The hash keys
|
| +** calculated by this function are compatible with those calculated by
|
| +** sessionPreupdateHash().
|
| +**
|
| +** The bPkOnly argument is non-zero if the record at aRecord[] is from
|
| +** a patchset DELETE. In this case the non-PK fields are omitted entirely.
|
| +*/
|
| +static unsigned int sessionChangeHash(
|
| + SessionTable *pTab, /* Table handle */
|
| + int bPkOnly, /* Record consists of PK fields only */
|
| + u8 *aRecord, /* Change record */
|
| + int nBucket /* Assume this many buckets in hash table */
|
| +){
|
| + unsigned int h = 0; /* Value to return */
|
| + int i; /* Used to iterate through columns */
|
| + u8 *a = aRecord; /* Used to iterate through change record */
|
| +
|
| + for(i=0; i<pTab->nCol; i++){
|
| + int eType = *a;
|
| + int isPK = pTab->abPK[i];
|
| + if( bPkOnly && isPK==0 ) continue;
|
| +
|
| + /* It is not possible for eType to be SQLITE_NULL here. The session
|
| + ** module does not record changes for rows with NULL values stored in
|
| + ** primary key columns. */
|
| + assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT
|
| + || eType==SQLITE_TEXT || eType==SQLITE_BLOB
|
| + || eType==SQLITE_NULL || eType==0
|
| + );
|
| + assert( !isPK || (eType!=0 && eType!=SQLITE_NULL) );
|
| +
|
| + if( isPK ){
|
| + a++;
|
| + h = sessionHashAppendType(h, eType);
|
| + if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + h = sessionHashAppendI64(h, sessionGetI64(a));
|
| + a += 8;
|
| + }else{
|
| + int n;
|
| + a += sessionVarintGet(a, &n);
|
| + h = sessionHashAppendBlob(h, n, a);
|
| + a += n;
|
| + }
|
| + }else{
|
| + a += sessionSerialLen(a);
|
| + }
|
| + }
|
| + return (h % nBucket);
|
| +}
|
| +
|
| +/*
|
| +** Arguments aLeft and aRight are pointers to change records for table pTab.
|
| +** This function returns true if the two records apply to the same row (i.e.
|
| +** have the same values stored in the primary key columns), or false
|
| +** otherwise.
|
| +*/
|
| +static int sessionChangeEqual(
|
| + SessionTable *pTab, /* Table used for PK definition */
|
| + int bLeftPkOnly, /* True if aLeft[] contains PK fields only */
|
| + u8 *aLeft, /* Change record */
|
| + int bRightPkOnly, /* True if aRight[] contains PK fields only */
|
| + u8 *aRight /* Change record */
|
| +){
|
| + u8 *a1 = aLeft; /* Cursor to iterate through aLeft */
|
| + u8 *a2 = aRight; /* Cursor to iterate through aRight */
|
| + int iCol; /* Used to iterate through table columns */
|
| +
|
| + for(iCol=0; iCol<pTab->nCol; iCol++){
|
| + if( pTab->abPK[iCol] ){
|
| + int n1 = sessionSerialLen(a1);
|
| + int n2 = sessionSerialLen(a2);
|
| +
|
| + if( pTab->abPK[iCol] && (n1!=n2 || memcmp(a1, a2, n1)) ){
|
| + return 0;
|
| + }
|
| + a1 += n1;
|
| + a2 += n2;
|
| + }else{
|
| + if( bLeftPkOnly==0 ) a1 += sessionSerialLen(a1);
|
| + if( bRightPkOnly==0 ) a2 += sessionSerialLen(a2);
|
| + }
|
| + }
|
| +
|
| + return 1;
|
| +}
|
| +
|
| +/*
|
| +** Arguments aLeft and aRight both point to buffers containing change
|
| +** records with nCol columns. This function "merges" the two records into
|
| +** a single records which is written to the buffer at *paOut. *paOut is
|
| +** then set to point to one byte after the last byte written before
|
| +** returning.
|
| +**
|
| +** The merging of records is done as follows: For each column, if the
|
| +** aRight record contains a value for the column, copy the value from
|
| +** their. Otherwise, if aLeft contains a value, copy it. If neither
|
| +** record contains a value for a given column, then neither does the
|
| +** output record.
|
| +*/
|
| +static void sessionMergeRecord(
|
| + u8 **paOut,
|
| + int nCol,
|
| + u8 *aLeft,
|
| + u8 *aRight
|
| +){
|
| + u8 *a1 = aLeft; /* Cursor used to iterate through aLeft */
|
| + u8 *a2 = aRight; /* Cursor used to iterate through aRight */
|
| + u8 *aOut = *paOut; /* Output cursor */
|
| + int iCol; /* Used to iterate from 0 to nCol */
|
| +
|
| + for(iCol=0; iCol<nCol; iCol++){
|
| + int n1 = sessionSerialLen(a1);
|
| + int n2 = sessionSerialLen(a2);
|
| + if( *a2 ){
|
| + memcpy(aOut, a2, n2);
|
| + aOut += n2;
|
| + }else{
|
| + memcpy(aOut, a1, n1);
|
| + aOut += n1;
|
| + }
|
| + a1 += n1;
|
| + a2 += n2;
|
| + }
|
| +
|
| + *paOut = aOut;
|
| +}
|
| +
|
| +/*
|
| +** This is a helper function used by sessionMergeUpdate().
|
| +**
|
| +** When this function is called, both *paOne and *paTwo point to a value
|
| +** within a change record. Before it returns, both have been advanced so
|
| +** as to point to the next value in the record.
|
| +**
|
| +** If, when this function is called, *paTwo points to a valid value (i.e.
|
| +** *paTwo[0] is not 0x00 - the "no value" placeholder), a copy of the *paTwo
|
| +** pointer is returned and *pnVal is set to the number of bytes in the
|
| +** serialized value. Otherwise, a copy of *paOne is returned and *pnVal
|
| +** set to the number of bytes in the value at *paOne. If *paOne points
|
| +** to the "no value" placeholder, *pnVal is set to 1. In other words:
|
| +**
|
| +** if( *paTwo is valid ) return *paTwo;
|
| +** return *paOne;
|
| +**
|
| +*/
|
| +static u8 *sessionMergeValue(
|
| + u8 **paOne, /* IN/OUT: Left-hand buffer pointer */
|
| + u8 **paTwo, /* IN/OUT: Right-hand buffer pointer */
|
| + int *pnVal /* OUT: Bytes in returned value */
|
| +){
|
| + u8 *a1 = *paOne;
|
| + u8 *a2 = *paTwo;
|
| + u8 *pRet = 0;
|
| + int n1;
|
| +
|
| + assert( a1 );
|
| + if( a2 ){
|
| + int n2 = sessionSerialLen(a2);
|
| + if( *a2 ){
|
| + *pnVal = n2;
|
| + pRet = a2;
|
| + }
|
| + *paTwo = &a2[n2];
|
| + }
|
| +
|
| + n1 = sessionSerialLen(a1);
|
| + if( pRet==0 ){
|
| + *pnVal = n1;
|
| + pRet = a1;
|
| + }
|
| + *paOne = &a1[n1];
|
| +
|
| + return pRet;
|
| +}
|
| +
|
| +/*
|
| +** This function is used by changeset_concat() to merge two UPDATE changes
|
| +** on the same row.
|
| +*/
|
| +static int sessionMergeUpdate(
|
| + u8 **paOut, /* IN/OUT: Pointer to output buffer */
|
| + SessionTable *pTab, /* Table change pertains to */
|
| + int bPatchset, /* True if records are patchset records */
|
| + u8 *aOldRecord1, /* old.* record for first change */
|
| + u8 *aOldRecord2, /* old.* record for second change */
|
| + u8 *aNewRecord1, /* new.* record for first change */
|
| + u8 *aNewRecord2 /* new.* record for second change */
|
| +){
|
| + u8 *aOld1 = aOldRecord1;
|
| + u8 *aOld2 = aOldRecord2;
|
| + u8 *aNew1 = aNewRecord1;
|
| + u8 *aNew2 = aNewRecord2;
|
| +
|
| + u8 *aOut = *paOut;
|
| + int i;
|
| +
|
| + if( bPatchset==0 ){
|
| + int bRequired = 0;
|
| +
|
| + assert( aOldRecord1 && aNewRecord1 );
|
| +
|
| + /* Write the old.* vector first. */
|
| + for(i=0; i<pTab->nCol; i++){
|
| + int nOld;
|
| + u8 *aOld;
|
| + int nNew;
|
| + u8 *aNew;
|
| +
|
| + aOld = sessionMergeValue(&aOld1, &aOld2, &nOld);
|
| + aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
|
| + if( pTab->abPK[i] || nOld!=nNew || memcmp(aOld, aNew, nNew) ){
|
| + if( pTab->abPK[i]==0 ) bRequired = 1;
|
| + memcpy(aOut, aOld, nOld);
|
| + aOut += nOld;
|
| + }else{
|
| + *(aOut++) = '\0';
|
| + }
|
| + }
|
| +
|
| + if( !bRequired ) return 0;
|
| + }
|
| +
|
| + /* Write the new.* vector */
|
| + aOld1 = aOldRecord1;
|
| + aOld2 = aOldRecord2;
|
| + aNew1 = aNewRecord1;
|
| + aNew2 = aNewRecord2;
|
| + for(i=0; i<pTab->nCol; i++){
|
| + int nOld;
|
| + u8 *aOld;
|
| + int nNew;
|
| + u8 *aNew;
|
| +
|
| + aOld = sessionMergeValue(&aOld1, &aOld2, &nOld);
|
| + aNew = sessionMergeValue(&aNew1, &aNew2, &nNew);
|
| + if( bPatchset==0
|
| + && (pTab->abPK[i] || (nOld==nNew && 0==memcmp(aOld, aNew, nNew)))
|
| + ){
|
| + *(aOut++) = '\0';
|
| + }else{
|
| + memcpy(aOut, aNew, nNew);
|
| + aOut += nNew;
|
| + }
|
| + }
|
| +
|
| + *paOut = aOut;
|
| + return 1;
|
| +}
|
| +
|
| +/*
|
| +** This function is only called from within a pre-update-hook callback.
|
| +** It determines if the current pre-update-hook change affects the same row
|
| +** as the change stored in argument pChange. If so, it returns true. Otherwise
|
| +** if the pre-update-hook does not affect the same row as pChange, it returns
|
| +** false.
|
| +*/
|
| +static int sessionPreupdateEqual(
|
| + sqlite3_session *pSession, /* Session object that owns SessionTable */
|
| + SessionTable *pTab, /* Table associated with change */
|
| + SessionChange *pChange, /* Change to compare to */
|
| + int op /* Current pre-update operation */
|
| +){
|
| + int iCol; /* Used to iterate through columns */
|
| + u8 *a = pChange->aRecord; /* Cursor used to scan change record */
|
| +
|
| + assert( op==SQLITE_INSERT || op==SQLITE_UPDATE || op==SQLITE_DELETE );
|
| + for(iCol=0; iCol<pTab->nCol; iCol++){
|
| + if( !pTab->abPK[iCol] ){
|
| + a += sessionSerialLen(a);
|
| + }else{
|
| + sqlite3_value *pVal; /* Value returned by preupdate_new/old */
|
| + int rc; /* Error code from preupdate_new/old */
|
| + int eType = *a++; /* Type of value from change record */
|
| +
|
| + /* The following calls to preupdate_new() and preupdate_old() can not
|
| + ** fail. This is because they cache their return values, and by the
|
| + ** time control flows to here they have already been called once from
|
| + ** within sessionPreupdateHash(). The first two asserts below verify
|
| + ** this (that the method has already been called). */
|
| + if( op==SQLITE_INSERT ){
|
| + /* assert( db->pPreUpdate->pNewUnpacked || db->pPreUpdate->aNew ); */
|
| + rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
|
| + }else{
|
| + /* assert( db->pPreUpdate->pUnpacked ); */
|
| + rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
|
| + }
|
| + assert( rc==SQLITE_OK );
|
| + if( sqlite3_value_type(pVal)!=eType ) return 0;
|
| +
|
| + /* A SessionChange object never has a NULL value in a PK column */
|
| + assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT
|
| + || eType==SQLITE_BLOB || eType==SQLITE_TEXT
|
| + );
|
| +
|
| + if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + i64 iVal = sessionGetI64(a);
|
| + a += 8;
|
| + if( eType==SQLITE_INTEGER ){
|
| + if( sqlite3_value_int64(pVal)!=iVal ) return 0;
|
| + }else{
|
| + double rVal;
|
| + assert( sizeof(iVal)==8 && sizeof(rVal)==8 );
|
| + memcpy(&rVal, &iVal, 8);
|
| + if( sqlite3_value_double(pVal)!=rVal ) return 0;
|
| + }
|
| + }else{
|
| + int n;
|
| + const u8 *z;
|
| + a += sessionVarintGet(a, &n);
|
| + if( sqlite3_value_bytes(pVal)!=n ) return 0;
|
| + if( eType==SQLITE_TEXT ){
|
| + z = sqlite3_value_text(pVal);
|
| + }else{
|
| + z = sqlite3_value_blob(pVal);
|
| + }
|
| + if( memcmp(a, z, n) ) return 0;
|
| + a += n;
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + return 1;
|
| +}
|
| +
|
| +/*
|
| +** If required, grow the hash table used to store changes on table pTab
|
| +** (part of the session pSession). If a fatal OOM error occurs, set the
|
| +** session object to failed and return SQLITE_ERROR. Otherwise, return
|
| +** SQLITE_OK.
|
| +**
|
| +** It is possible that a non-fatal OOM error occurs in this function. In
|
| +** that case the hash-table does not grow, but SQLITE_OK is returned anyway.
|
| +** Growing the hash table in this case is a performance optimization only,
|
| +** it is not required for correct operation.
|
| +*/
|
| +static int sessionGrowHash(int bPatchset, SessionTable *pTab){
|
| + if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){
|
| + int i;
|
| + SessionChange **apNew;
|
| + int nNew = (pTab->nChange ? pTab->nChange : 128) * 2;
|
| +
|
| + apNew = (SessionChange **)sqlite3_malloc(sizeof(SessionChange *) * nNew);
|
| + if( apNew==0 ){
|
| + if( pTab->nChange==0 ){
|
| + return SQLITE_ERROR;
|
| + }
|
| + return SQLITE_OK;
|
| + }
|
| + memset(apNew, 0, sizeof(SessionChange *) * nNew);
|
| +
|
| + for(i=0; i<pTab->nChange; i++){
|
| + SessionChange *p;
|
| + SessionChange *pNext;
|
| + for(p=pTab->apChange[i]; p; p=pNext){
|
| + int bPkOnly = (p->op==SQLITE_DELETE && bPatchset);
|
| + int iHash = sessionChangeHash(pTab, bPkOnly, p->aRecord, nNew);
|
| + pNext = p->pNext;
|
| + p->pNext = apNew[iHash];
|
| + apNew[iHash] = p;
|
| + }
|
| + }
|
| +
|
| + sqlite3_free(pTab->apChange);
|
| + pTab->nChange = nNew;
|
| + pTab->apChange = apNew;
|
| + }
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** This function queries the database for the names of the columns of table
|
| +** zThis, in schema zDb. It is expected that the table has nCol columns. If
|
| +** not, SQLITE_SCHEMA is returned and none of the output variables are
|
| +** populated.
|
| +**
|
| +** Otherwise, if they are not NULL, variable *pnCol is set to the number
|
| +** of columns in the database table and variable *pzTab is set to point to a
|
| +** nul-terminated copy of the table name. *pazCol (if not NULL) is set to
|
| +** point to an array of pointers to column names. And *pabPK (again, if not
|
| +** NULL) is set to point to an array of booleans - true if the corresponding
|
| +** column is part of the primary key.
|
| +**
|
| +** For example, if the table is declared as:
|
| +**
|
| +** CREATE TABLE tbl1(w, x, y, z, PRIMARY KEY(w, z));
|
| +**
|
| +** Then the four output variables are populated as follows:
|
| +**
|
| +** *pnCol = 4
|
| +** *pzTab = "tbl1"
|
| +** *pazCol = {"w", "x", "y", "z"}
|
| +** *pabPK = {1, 0, 0, 1}
|
| +**
|
| +** All returned buffers are part of the same single allocation, which must
|
| +** be freed using sqlite3_free() by the caller. If pazCol was not NULL, then
|
| +** pointer *pazCol should be freed to release all memory. Otherwise, pointer
|
| +** *pabPK. It is illegal for both pazCol and pabPK to be NULL.
|
| +*/
|
| +static int sessionTableInfo(
|
| + sqlite3 *db, /* Database connection */
|
| + const char *zDb, /* Name of attached database (e.g. "main") */
|
| + const char *zThis, /* Table name */
|
| + int *pnCol, /* OUT: number of columns */
|
| + const char **pzTab, /* OUT: Copy of zThis */
|
| + const char ***pazCol, /* OUT: Array of column names for table */
|
| + u8 **pabPK /* OUT: Array of booleans - true for PK col */
|
| +){
|
| + char *zPragma;
|
| + sqlite3_stmt *pStmt;
|
| + int rc;
|
| + int nByte;
|
| + int nDbCol = 0;
|
| + int nThis;
|
| + int i;
|
| + u8 *pAlloc = 0;
|
| + char **azCol = 0;
|
| + u8 *abPK = 0;
|
| +
|
| + assert( pazCol && pabPK );
|
| +
|
| + nThis = sqlite3Strlen30(zThis);
|
| + zPragma = sqlite3_mprintf("PRAGMA '%q'.table_info('%q')", zDb, zThis);
|
| + if( !zPragma ) return SQLITE_NOMEM;
|
| +
|
| + rc = sqlite3_prepare_v2(db, zPragma, -1, &pStmt, 0);
|
| + sqlite3_free(zPragma);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + nByte = nThis + 1;
|
| + while( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + nByte += sqlite3_column_bytes(pStmt, 1);
|
| + nDbCol++;
|
| + }
|
| + rc = sqlite3_reset(pStmt);
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + nByte += nDbCol * (sizeof(const char *) + sizeof(u8) + 1);
|
| + pAlloc = sqlite3_malloc(nByte);
|
| + if( pAlloc==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + azCol = (char **)pAlloc;
|
| + pAlloc = (u8 *)&azCol[nDbCol];
|
| + abPK = (u8 *)pAlloc;
|
| + pAlloc = &abPK[nDbCol];
|
| + if( pzTab ){
|
| + memcpy(pAlloc, zThis, nThis+1);
|
| + *pzTab = (char *)pAlloc;
|
| + pAlloc += nThis+1;
|
| + }
|
| +
|
| + i = 0;
|
| + while( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + int nName = sqlite3_column_bytes(pStmt, 1);
|
| + const unsigned char *zName = sqlite3_column_text(pStmt, 1);
|
| + if( zName==0 ) break;
|
| + memcpy(pAlloc, zName, nName+1);
|
| + azCol[i] = (char *)pAlloc;
|
| + pAlloc += nName+1;
|
| + abPK[i] = sqlite3_column_int(pStmt, 5);
|
| + i++;
|
| + }
|
| + rc = sqlite3_reset(pStmt);
|
| +
|
| + }
|
| +
|
| + /* If successful, populate the output variables. Otherwise, zero them and
|
| + ** free any allocation made. An error code will be returned in this case.
|
| + */
|
| + if( rc==SQLITE_OK ){
|
| + *pazCol = (const char **)azCol;
|
| + *pabPK = abPK;
|
| + *pnCol = nDbCol;
|
| + }else{
|
| + *pazCol = 0;
|
| + *pabPK = 0;
|
| + *pnCol = 0;
|
| + if( pzTab ) *pzTab = 0;
|
| + sqlite3_free(azCol);
|
| + }
|
| + sqlite3_finalize(pStmt);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This function is only called from within a pre-update handler for a
|
| +** write to table pTab, part of session pSession. If this is the first
|
| +** write to this table, initalize the SessionTable.nCol, azCol[] and
|
| +** abPK[] arrays accordingly.
|
| +**
|
| +** If an error occurs, an error code is stored in sqlite3_session.rc and
|
| +** non-zero returned. Or, if no error occurs but the table has no primary
|
| +** key, sqlite3_session.rc is left set to SQLITE_OK and non-zero returned to
|
| +** indicate that updates on this table should be ignored. SessionTable.abPK
|
| +** is set to NULL in this case.
|
| +*/
|
| +static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){
|
| + if( pTab->nCol==0 ){
|
| + u8 *abPK;
|
| + assert( pTab->azCol==0 || pTab->abPK==0 );
|
| + pSession->rc = sessionTableInfo(pSession->db, pSession->zDb,
|
| + pTab->zName, &pTab->nCol, 0, &pTab->azCol, &abPK
|
| + );
|
| + if( pSession->rc==SQLITE_OK ){
|
| + int i;
|
| + for(i=0; i<pTab->nCol; i++){
|
| + if( abPK[i] ){
|
| + pTab->abPK = abPK;
|
| + break;
|
| + }
|
| + }
|
| + }
|
| + }
|
| + return (pSession->rc || pTab->abPK==0);
|
| +}
|
| +
|
| +/*
|
| +** This function is only called from with a pre-update-hook reporting a
|
| +** change on table pTab (attached to session pSession). The type of change
|
| +** (UPDATE, INSERT, DELETE) is specified by the first argument.
|
| +**
|
| +** Unless one is already present or an error occurs, an entry is added
|
| +** to the changed-rows hash table associated with table pTab.
|
| +*/
|
| +static void sessionPreupdateOneChange(
|
| + int op, /* One of SQLITE_UPDATE, INSERT, DELETE */
|
| + sqlite3_session *pSession, /* Session object pTab is attached to */
|
| + SessionTable *pTab /* Table that change applies to */
|
| +){
|
| + int iHash;
|
| + int bNull = 0;
|
| + int rc = SQLITE_OK;
|
| +
|
| + if( pSession->rc ) return;
|
| +
|
| + /* Load table details if required */
|
| + if( sessionInitTable(pSession, pTab) ) return;
|
| +
|
| + /* Check the number of columns in this xPreUpdate call matches the
|
| + ** number of columns in the table. */
|
| + if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
|
| + pSession->rc = SQLITE_SCHEMA;
|
| + return;
|
| + }
|
| +
|
| + /* Grow the hash table if required */
|
| + if( sessionGrowHash(0, pTab) ){
|
| + pSession->rc = SQLITE_NOMEM;
|
| + return;
|
| + }
|
| +
|
| + /* Calculate the hash-key for this change. If the primary key of the row
|
| + ** includes a NULL value, exit early. Such changes are ignored by the
|
| + ** session module. */
|
| + rc = sessionPreupdateHash(pSession, pTab, op==SQLITE_INSERT, &iHash, &bNull);
|
| + if( rc!=SQLITE_OK ) goto error_out;
|
| +
|
| + if( bNull==0 ){
|
| + /* Search the hash table for an existing record for this row. */
|
| + SessionChange *pC;
|
| + for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
|
| + if( sessionPreupdateEqual(pSession, pTab, pC, op) ) break;
|
| + }
|
| +
|
| + if( pC==0 ){
|
| + /* Create a new change object containing all the old values (if
|
| + ** this is an SQLITE_UPDATE or SQLITE_DELETE), or just the PK
|
| + ** values (if this is an INSERT). */
|
| + SessionChange *pChange; /* New change object */
|
| + int nByte; /* Number of bytes to allocate */
|
| + int i; /* Used to iterate through columns */
|
| +
|
| + assert( rc==SQLITE_OK );
|
| + pTab->nEntry++;
|
| +
|
| + /* Figure out how large an allocation is required */
|
| + nByte = sizeof(SessionChange);
|
| + for(i=0; i<pTab->nCol; i++){
|
| + sqlite3_value *p = 0;
|
| + if( op!=SQLITE_INSERT ){
|
| + TESTONLY(int trc = ) pSession->hook.xOld(pSession->hook.pCtx, i, &p);
|
| + assert( trc==SQLITE_OK );
|
| + }else if( pTab->abPK[i] ){
|
| + TESTONLY(int trc = ) pSession->hook.xNew(pSession->hook.pCtx, i, &p);
|
| + assert( trc==SQLITE_OK );
|
| + }
|
| +
|
| + /* This may fail if SQLite value p contains a utf-16 string that must
|
| + ** be converted to utf-8 and an OOM error occurs while doing so. */
|
| + rc = sessionSerializeValue(0, p, &nByte);
|
| + if( rc!=SQLITE_OK ) goto error_out;
|
| + }
|
| +
|
| + /* Allocate the change object */
|
| + pChange = (SessionChange *)sqlite3_malloc(nByte);
|
| + if( !pChange ){
|
| + rc = SQLITE_NOMEM;
|
| + goto error_out;
|
| + }else{
|
| + memset(pChange, 0, sizeof(SessionChange));
|
| + pChange->aRecord = (u8 *)&pChange[1];
|
| + }
|
| +
|
| + /* Populate the change object. None of the preupdate_old(),
|
| + ** preupdate_new() or SerializeValue() calls below may fail as all
|
| + ** required values and encodings have already been cached in memory.
|
| + ** It is not possible for an OOM to occur in this block. */
|
| + nByte = 0;
|
| + for(i=0; i<pTab->nCol; i++){
|
| + sqlite3_value *p = 0;
|
| + if( op!=SQLITE_INSERT ){
|
| + pSession->hook.xOld(pSession->hook.pCtx, i, &p);
|
| + }else if( pTab->abPK[i] ){
|
| + pSession->hook.xNew(pSession->hook.pCtx, i, &p);
|
| + }
|
| + sessionSerializeValue(&pChange->aRecord[nByte], p, &nByte);
|
| + }
|
| +
|
| + /* Add the change to the hash-table */
|
| + if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){
|
| + pChange->bIndirect = 1;
|
| + }
|
| + pChange->nRecord = nByte;
|
| + pChange->op = op;
|
| + pChange->pNext = pTab->apChange[iHash];
|
| + pTab->apChange[iHash] = pChange;
|
| +
|
| + }else if( pC->bIndirect ){
|
| + /* If the existing change is considered "indirect", but this current
|
| + ** change is "direct", mark the change object as direct. */
|
| + if( pSession->hook.xDepth(pSession->hook.pCtx)==0
|
| + && pSession->bIndirect==0
|
| + ){
|
| + pC->bIndirect = 0;
|
| + }
|
| + }
|
| + }
|
| +
|
| + /* If an error has occurred, mark the session object as failed. */
|
| + error_out:
|
| + if( rc!=SQLITE_OK ){
|
| + pSession->rc = rc;
|
| + }
|
| +}
|
| +
|
| +static int sessionFindTable(
|
| + sqlite3_session *pSession,
|
| + const char *zName,
|
| + SessionTable **ppTab
|
| +){
|
| + int rc = SQLITE_OK;
|
| + int nName = sqlite3Strlen30(zName);
|
| + SessionTable *pRet;
|
| +
|
| + /* Search for an existing table */
|
| + for(pRet=pSession->pTable; pRet; pRet=pRet->pNext){
|
| + if( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) ) break;
|
| + }
|
| +
|
| + if( pRet==0 && pSession->bAutoAttach ){
|
| + /* If there is a table-filter configured, invoke it. If it returns 0,
|
| + ** do not automatically add the new table. */
|
| + if( pSession->xTableFilter==0
|
| + || pSession->xTableFilter(pSession->pFilterCtx, zName)
|
| + ){
|
| + rc = sqlite3session_attach(pSession, zName);
|
| + if( rc==SQLITE_OK ){
|
| + for(pRet=pSession->pTable; pRet->pNext; pRet=pRet->pNext);
|
| + assert( 0==sqlite3_strnicmp(pRet->zName, zName, nName+1) );
|
| + }
|
| + }
|
| + }
|
| +
|
| + assert( rc==SQLITE_OK || pRet==0 );
|
| + *ppTab = pRet;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** The 'pre-update' hook registered by this module with SQLite databases.
|
| +*/
|
| +static void xPreUpdate(
|
| + void *pCtx, /* Copy of third arg to preupdate_hook() */
|
| + sqlite3 *db, /* Database handle */
|
| + int op, /* SQLITE_UPDATE, DELETE or INSERT */
|
| + char const *zDb, /* Database name */
|
| + char const *zName, /* Table name */
|
| + sqlite3_int64 iKey1, /* Rowid of row about to be deleted/updated */
|
| + sqlite3_int64 iKey2 /* New rowid value (for a rowid UPDATE) */
|
| +){
|
| + sqlite3_session *pSession;
|
| + int nDb = sqlite3Strlen30(zDb);
|
| +
|
| + assert( sqlite3_mutex_held(db->mutex) );
|
| +
|
| + for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){
|
| + SessionTable *pTab;
|
| +
|
| + /* If this session is attached to a different database ("main", "temp"
|
| + ** etc.), or if it is not currently enabled, there is nothing to do. Skip
|
| + ** to the next session object attached to this database. */
|
| + if( pSession->bEnable==0 ) continue;
|
| + if( pSession->rc ) continue;
|
| + if( sqlite3_strnicmp(zDb, pSession->zDb, nDb+1) ) continue;
|
| +
|
| + pSession->rc = sessionFindTable(pSession, zName, &pTab);
|
| + if( pTab ){
|
| + assert( pSession->rc==SQLITE_OK );
|
| + sessionPreupdateOneChange(op, pSession, pTab);
|
| + if( op==SQLITE_UPDATE ){
|
| + sessionPreupdateOneChange(SQLITE_INSERT, pSession, pTab);
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** The pre-update hook implementations.
|
| +*/
|
| +static int sessionPreupdateOld(void *pCtx, int iVal, sqlite3_value **ppVal){
|
| + return sqlite3_preupdate_old((sqlite3*)pCtx, iVal, ppVal);
|
| +}
|
| +static int sessionPreupdateNew(void *pCtx, int iVal, sqlite3_value **ppVal){
|
| + return sqlite3_preupdate_new((sqlite3*)pCtx, iVal, ppVal);
|
| +}
|
| +static int sessionPreupdateCount(void *pCtx){
|
| + return sqlite3_preupdate_count((sqlite3*)pCtx);
|
| +}
|
| +static int sessionPreupdateDepth(void *pCtx){
|
| + return sqlite3_preupdate_depth((sqlite3*)pCtx);
|
| +}
|
| +
|
| +/*
|
| +** Install the pre-update hooks on the session object passed as the only
|
| +** argument.
|
| +*/
|
| +static void sessionPreupdateHooks(
|
| + sqlite3_session *pSession
|
| +){
|
| + pSession->hook.pCtx = (void*)pSession->db;
|
| + pSession->hook.xOld = sessionPreupdateOld;
|
| + pSession->hook.xNew = sessionPreupdateNew;
|
| + pSession->hook.xCount = sessionPreupdateCount;
|
| + pSession->hook.xDepth = sessionPreupdateDepth;
|
| +}
|
| +
|
| +typedef struct SessionDiffCtx SessionDiffCtx;
|
| +struct SessionDiffCtx {
|
| + sqlite3_stmt *pStmt;
|
| + int nOldOff;
|
| +};
|
| +
|
| +/*
|
| +** The diff hook implementations.
|
| +*/
|
| +static int sessionDiffOld(void *pCtx, int iVal, sqlite3_value **ppVal){
|
| + SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
|
| + *ppVal = sqlite3_column_value(p->pStmt, iVal+p->nOldOff);
|
| + return SQLITE_OK;
|
| +}
|
| +static int sessionDiffNew(void *pCtx, int iVal, sqlite3_value **ppVal){
|
| + SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
|
| + *ppVal = sqlite3_column_value(p->pStmt, iVal);
|
| + return SQLITE_OK;
|
| +}
|
| +static int sessionDiffCount(void *pCtx){
|
| + SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
|
| + return p->nOldOff ? p->nOldOff : sqlite3_column_count(p->pStmt);
|
| +}
|
| +static int sessionDiffDepth(void *pCtx){
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Install the diff hooks on the session object passed as the only
|
| +** argument.
|
| +*/
|
| +static void sessionDiffHooks(
|
| + sqlite3_session *pSession,
|
| + SessionDiffCtx *pDiffCtx
|
| +){
|
| + pSession->hook.pCtx = (void*)pDiffCtx;
|
| + pSession->hook.xOld = sessionDiffOld;
|
| + pSession->hook.xNew = sessionDiffNew;
|
| + pSession->hook.xCount = sessionDiffCount;
|
| + pSession->hook.xDepth = sessionDiffDepth;
|
| +}
|
| +
|
| +static char *sessionExprComparePK(
|
| + int nCol,
|
| + const char *zDb1, const char *zDb2,
|
| + const char *zTab,
|
| + const char **azCol, u8 *abPK
|
| +){
|
| + int i;
|
| + const char *zSep = "";
|
| + char *zRet = 0;
|
| +
|
| + for(i=0; i<nCol; i++){
|
| + if( abPK[i] ){
|
| + zRet = sqlite3_mprintf("%z%s\"%w\".\"%w\".\"%w\"=\"%w\".\"%w\".\"%w\"",
|
| + zRet, zSep, zDb1, zTab, azCol[i], zDb2, zTab, azCol[i]
|
| + );
|
| + zSep = " AND ";
|
| + if( zRet==0 ) break;
|
| + }
|
| + }
|
| +
|
| + return zRet;
|
| +}
|
| +
|
| +static char *sessionExprCompareOther(
|
| + int nCol,
|
| + const char *zDb1, const char *zDb2,
|
| + const char *zTab,
|
| + const char **azCol, u8 *abPK
|
| +){
|
| + int i;
|
| + const char *zSep = "";
|
| + char *zRet = 0;
|
| + int bHave = 0;
|
| +
|
| + for(i=0; i<nCol; i++){
|
| + if( abPK[i]==0 ){
|
| + bHave = 1;
|
| + zRet = sqlite3_mprintf(
|
| + "%z%s\"%w\".\"%w\".\"%w\" IS NOT \"%w\".\"%w\".\"%w\"",
|
| + zRet, zSep, zDb1, zTab, azCol[i], zDb2, zTab, azCol[i]
|
| + );
|
| + zSep = " OR ";
|
| + if( zRet==0 ) break;
|
| + }
|
| + }
|
| +
|
| + if( bHave==0 ){
|
| + assert( zRet==0 );
|
| + zRet = sqlite3_mprintf("0");
|
| + }
|
| +
|
| + return zRet;
|
| +}
|
| +
|
| +static char *sessionSelectFindNew(
|
| + int nCol,
|
| + const char *zDb1, /* Pick rows in this db only */
|
| + const char *zDb2, /* But not in this one */
|
| + const char *zTbl, /* Table name */
|
| + const char *zExpr
|
| +){
|
| + char *zRet = sqlite3_mprintf(
|
| + "SELECT * FROM \"%w\".\"%w\" WHERE NOT EXISTS ("
|
| + " SELECT 1 FROM \"%w\".\"%w\" WHERE %s"
|
| + ")",
|
| + zDb1, zTbl, zDb2, zTbl, zExpr
|
| + );
|
| + return zRet;
|
| +}
|
| +
|
| +static int sessionDiffFindNew(
|
| + int op,
|
| + sqlite3_session *pSession,
|
| + SessionTable *pTab,
|
| + const char *zDb1,
|
| + const char *zDb2,
|
| + char *zExpr
|
| +){
|
| + int rc = SQLITE_OK;
|
| + char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);
|
| +
|
| + if( zStmt==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + sqlite3_stmt *pStmt;
|
| + rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
|
| + if( rc==SQLITE_OK ){
|
| + SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
|
| + pDiffCtx->pStmt = pStmt;
|
| + pDiffCtx->nOldOff = 0;
|
| + while( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + sessionPreupdateOneChange(op, pSession, pTab);
|
| + }
|
| + rc = sqlite3_finalize(pStmt);
|
| + }
|
| + sqlite3_free(zStmt);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +static int sessionDiffFindModified(
|
| + sqlite3_session *pSession,
|
| + SessionTable *pTab,
|
| + const char *zFrom,
|
| + const char *zExpr
|
| +){
|
| + int rc = SQLITE_OK;
|
| +
|
| + char *zExpr2 = sessionExprCompareOther(pTab->nCol,
|
| + pSession->zDb, zFrom, pTab->zName, pTab->azCol, pTab->abPK
|
| + );
|
| + if( zExpr2==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + char *zStmt = sqlite3_mprintf(
|
| + "SELECT * FROM \"%w\".\"%w\", \"%w\".\"%w\" WHERE %s AND (%z)",
|
| + pSession->zDb, pTab->zName, zFrom, pTab->zName, zExpr, zExpr2
|
| + );
|
| + if( zStmt==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + sqlite3_stmt *pStmt;
|
| + rc = sqlite3_prepare(pSession->db, zStmt, -1, &pStmt, 0);
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
|
| + pDiffCtx->pStmt = pStmt;
|
| + pDiffCtx->nOldOff = pTab->nCol;
|
| + while( SQLITE_ROW==sqlite3_step(pStmt) ){
|
| + sessionPreupdateOneChange(SQLITE_UPDATE, pSession, pTab);
|
| + }
|
| + rc = sqlite3_finalize(pStmt);
|
| + }
|
| + sqlite3_free(zStmt);
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +SQLITE_API int sqlite3session_diff(
|
| + sqlite3_session *pSession,
|
| + const char *zFrom,
|
| + const char *zTbl,
|
| + char **pzErrMsg
|
| +){
|
| + const char *zDb = pSession->zDb;
|
| + int rc = pSession->rc;
|
| + SessionDiffCtx d;
|
| +
|
| + memset(&d, 0, sizeof(d));
|
| + sessionDiffHooks(pSession, &d);
|
| +
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
|
| + if( pzErrMsg ) *pzErrMsg = 0;
|
| + if( rc==SQLITE_OK ){
|
| + char *zExpr = 0;
|
| + sqlite3 *db = pSession->db;
|
| + SessionTable *pTo; /* Table zTbl */
|
| +
|
| + /* Locate and if necessary initialize the target table object */
|
| + rc = sessionFindTable(pSession, zTbl, &pTo);
|
| + if( pTo==0 ) goto diff_out;
|
| + if( sessionInitTable(pSession, pTo) ){
|
| + rc = pSession->rc;
|
| + goto diff_out;
|
| + }
|
| +
|
| + /* Check the table schemas match */
|
| + if( rc==SQLITE_OK ){
|
| + int bHasPk = 0;
|
| + int bMismatch = 0;
|
| + int nCol; /* Columns in zFrom.zTbl */
|
| + u8 *abPK;
|
| + const char **azCol = 0;
|
| + rc = sessionTableInfo(db, zFrom, zTbl, &nCol, 0, &azCol, &abPK);
|
| + if( rc==SQLITE_OK ){
|
| + if( pTo->nCol!=nCol ){
|
| + bMismatch = 1;
|
| + }else{
|
| + int i;
|
| + for(i=0; i<nCol; i++){
|
| + if( pTo->abPK[i]!=abPK[i] ) bMismatch = 1;
|
| + if( sqlite3_stricmp(azCol[i], pTo->azCol[i]) ) bMismatch = 1;
|
| + if( abPK[i] ) bHasPk = 1;
|
| + }
|
| + }
|
| +
|
| + }
|
| + sqlite3_free((char*)azCol);
|
| + if( bMismatch ){
|
| + *pzErrMsg = sqlite3_mprintf("table schemas do not match");
|
| + rc = SQLITE_SCHEMA;
|
| + }
|
| + if( bHasPk==0 ){
|
| + /* Ignore tables with no primary keys */
|
| + goto diff_out;
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + zExpr = sessionExprComparePK(pTo->nCol,
|
| + zDb, zFrom, pTo->zName, pTo->azCol, pTo->abPK
|
| + );
|
| + }
|
| +
|
| + /* Find new rows */
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionDiffFindNew(SQLITE_INSERT, pSession, pTo, zDb, zFrom, zExpr);
|
| + }
|
| +
|
| + /* Find old rows */
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionDiffFindNew(SQLITE_DELETE, pSession, pTo, zFrom, zDb, zExpr);
|
| + }
|
| +
|
| + /* Find modified rows */
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionDiffFindModified(pSession, pTo, zFrom, zExpr);
|
| + }
|
| +
|
| + sqlite3_free(zExpr);
|
| + }
|
| +
|
| + diff_out:
|
| + sessionPreupdateHooks(pSession);
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Create a session object. This session object will record changes to
|
| +** database zDb attached to connection db.
|
| +*/
|
| +SQLITE_API int sqlite3session_create(
|
| + sqlite3 *db, /* Database handle */
|
| + const char *zDb, /* Name of db (e.g. "main") */
|
| + sqlite3_session **ppSession /* OUT: New session object */
|
| +){
|
| + sqlite3_session *pNew; /* Newly allocated session object */
|
| + sqlite3_session *pOld; /* Session object already attached to db */
|
| + int nDb = sqlite3Strlen30(zDb); /* Length of zDb in bytes */
|
| +
|
| + /* Zero the output value in case an error occurs. */
|
| + *ppSession = 0;
|
| +
|
| + /* Allocate and populate the new session object. */
|
| + pNew = (sqlite3_session *)sqlite3_malloc(sizeof(sqlite3_session) + nDb + 1);
|
| + if( !pNew ) return SQLITE_NOMEM;
|
| + memset(pNew, 0, sizeof(sqlite3_session));
|
| + pNew->db = db;
|
| + pNew->zDb = (char *)&pNew[1];
|
| + pNew->bEnable = 1;
|
| + memcpy(pNew->zDb, zDb, nDb+1);
|
| + sessionPreupdateHooks(pNew);
|
| +
|
| + /* Add the new session object to the linked list of session objects
|
| + ** attached to database handle $db. Do this under the cover of the db
|
| + ** handle mutex. */
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(db));
|
| + pOld = (sqlite3_session*)sqlite3_preupdate_hook(db, xPreUpdate, (void*)pNew);
|
| + pNew->pNext = pOld;
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(db));
|
| +
|
| + *ppSession = pNew;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Free the list of table objects passed as the first argument. The contents
|
| +** of the changed-rows hash tables are also deleted.
|
| +*/
|
| +static void sessionDeleteTable(SessionTable *pList){
|
| + SessionTable *pNext;
|
| + SessionTable *pTab;
|
| +
|
| + for(pTab=pList; pTab; pTab=pNext){
|
| + int i;
|
| + pNext = pTab->pNext;
|
| + for(i=0; i<pTab->nChange; i++){
|
| + SessionChange *p;
|
| + SessionChange *pNextChange;
|
| + for(p=pTab->apChange[i]; p; p=pNextChange){
|
| + pNextChange = p->pNext;
|
| + sqlite3_free(p);
|
| + }
|
| + }
|
| + sqlite3_free((char*)pTab->azCol); /* cast works around VC++ bug */
|
| + sqlite3_free(pTab->apChange);
|
| + sqlite3_free(pTab);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Delete a session object previously allocated using sqlite3session_create().
|
| +*/
|
| +SQLITE_API void sqlite3session_delete(sqlite3_session *pSession){
|
| + sqlite3 *db = pSession->db;
|
| + sqlite3_session *pHead;
|
| + sqlite3_session **pp;
|
| +
|
| + /* Unlink the session from the linked list of sessions attached to the
|
| + ** database handle. Hold the db mutex while doing so. */
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(db));
|
| + pHead = (sqlite3_session*)sqlite3_preupdate_hook(db, 0, 0);
|
| + for(pp=&pHead; ALWAYS((*pp)!=0); pp=&((*pp)->pNext)){
|
| + if( (*pp)==pSession ){
|
| + *pp = (*pp)->pNext;
|
| + if( pHead ) sqlite3_preupdate_hook(db, xPreUpdate, (void*)pHead);
|
| + break;
|
| + }
|
| + }
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(db));
|
| +
|
| + /* Delete all attached table objects. And the contents of their
|
| + ** associated hash-tables. */
|
| + sessionDeleteTable(pSession->pTable);
|
| +
|
| + /* Free the session object itself. */
|
| + sqlite3_free(pSession);
|
| +}
|
| +
|
| +/*
|
| +** Set a table filter on a Session Object.
|
| +*/
|
| +SQLITE_API void sqlite3session_table_filter(
|
| + sqlite3_session *pSession,
|
| + int(*xFilter)(void*, const char*),
|
| + void *pCtx /* First argument passed to xFilter */
|
| +){
|
| + pSession->bAutoAttach = 1;
|
| + pSession->pFilterCtx = pCtx;
|
| + pSession->xTableFilter = xFilter;
|
| +}
|
| +
|
| +/*
|
| +** Attach a table to a session. All subsequent changes made to the table
|
| +** while the session object is enabled will be recorded.
|
| +**
|
| +** Only tables that have a PRIMARY KEY defined may be attached. It does
|
| +** not matter if the PRIMARY KEY is an "INTEGER PRIMARY KEY" (rowid alias)
|
| +** or not.
|
| +*/
|
| +SQLITE_API int sqlite3session_attach(
|
| + sqlite3_session *pSession, /* Session object */
|
| + const char *zName /* Table name */
|
| +){
|
| + int rc = SQLITE_OK;
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
|
| +
|
| + if( !zName ){
|
| + pSession->bAutoAttach = 1;
|
| + }else{
|
| + SessionTable *pTab; /* New table object (if required) */
|
| + int nName; /* Number of bytes in string zName */
|
| +
|
| + /* First search for an existing entry. If one is found, this call is
|
| + ** a no-op. Return early. */
|
| + nName = sqlite3Strlen30(zName);
|
| + for(pTab=pSession->pTable; pTab; pTab=pTab->pNext){
|
| + if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ) break;
|
| + }
|
| +
|
| + if( !pTab ){
|
| + /* Allocate new SessionTable object. */
|
| + pTab = (SessionTable *)sqlite3_malloc(sizeof(SessionTable) + nName + 1);
|
| + if( !pTab ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + /* Populate the new SessionTable object and link it into the list.
|
| + ** The new object must be linked onto the end of the list, not
|
| + ** simply added to the start of it in order to ensure that tables
|
| + ** appear in the correct order when a changeset or patchset is
|
| + ** eventually generated. */
|
| + SessionTable **ppTab;
|
| + memset(pTab, 0, sizeof(SessionTable));
|
| + pTab->zName = (char *)&pTab[1];
|
| + memcpy(pTab->zName, zName, nName+1);
|
| + for(ppTab=&pSession->pTable; *ppTab; ppTab=&(*ppTab)->pNext);
|
| + *ppTab = pTab;
|
| + }
|
| + }
|
| + }
|
| +
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Ensure that there is room in the buffer to append nByte bytes of data.
|
| +** If not, use sqlite3_realloc() to grow the buffer so that there is.
|
| +**
|
| +** If successful, return zero. Otherwise, if an OOM condition is encountered,
|
| +** set *pRc to SQLITE_NOMEM and return non-zero.
|
| +*/
|
| +static int sessionBufferGrow(SessionBuffer *p, int nByte, int *pRc){
|
| + if( *pRc==SQLITE_OK && p->nAlloc-p->nBuf<nByte ){
|
| + u8 *aNew;
|
| + int nNew = p->nAlloc ? p->nAlloc : 128;
|
| + do {
|
| + nNew = nNew*2;
|
| + }while( nNew<(p->nBuf+nByte) );
|
| +
|
| + aNew = (u8 *)sqlite3_realloc(p->aBuf, nNew);
|
| + if( 0==aNew ){
|
| + *pRc = SQLITE_NOMEM;
|
| + }else{
|
| + p->aBuf = aNew;
|
| + p->nAlloc = nNew;
|
| + }
|
| + }
|
| + return (*pRc!=SQLITE_OK);
|
| +}
|
| +
|
| +/*
|
| +** Append the value passed as the second argument to the buffer passed
|
| +** as the first.
|
| +**
|
| +** This function is a no-op if *pRc is non-zero when it is called.
|
| +** Otherwise, if an error occurs, *pRc is set to an SQLite error code
|
| +** before returning.
|
| +*/
|
| +static void sessionAppendValue(SessionBuffer *p, sqlite3_value *pVal, int *pRc){
|
| + int rc = *pRc;
|
| + if( rc==SQLITE_OK ){
|
| + int nByte = 0;
|
| + rc = sessionSerializeValue(0, pVal, &nByte);
|
| + sessionBufferGrow(p, nByte, &rc);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionSerializeValue(&p->aBuf[p->nBuf], pVal, 0);
|
| + p->nBuf += nByte;
|
| + }else{
|
| + *pRc = rc;
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwise, append a single byte to the buffer.
|
| +**
|
| +** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
|
| +** returning.
|
| +*/
|
| +static void sessionAppendByte(SessionBuffer *p, u8 v, int *pRc){
|
| + if( 0==sessionBufferGrow(p, 1, pRc) ){
|
| + p->aBuf[p->nBuf++] = v;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwise, append a single varint to the buffer.
|
| +**
|
| +** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
|
| +** returning.
|
| +*/
|
| +static void sessionAppendVarint(SessionBuffer *p, int v, int *pRc){
|
| + if( 0==sessionBufferGrow(p, 9, pRc) ){
|
| + p->nBuf += sessionVarintPut(&p->aBuf[p->nBuf], v);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwise, append a blob of data to the buffer.
|
| +**
|
| +** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
|
| +** returning.
|
| +*/
|
| +static void sessionAppendBlob(
|
| + SessionBuffer *p,
|
| + const u8 *aBlob,
|
| + int nBlob,
|
| + int *pRc
|
| +){
|
| + if( nBlob>0 && 0==sessionBufferGrow(p, nBlob, pRc) ){
|
| + memcpy(&p->aBuf[p->nBuf], aBlob, nBlob);
|
| + p->nBuf += nBlob;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwise, append a string to the buffer. All bytes in the string
|
| +** up to (but not including) the nul-terminator are written to the buffer.
|
| +**
|
| +** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
|
| +** returning.
|
| +*/
|
| +static void sessionAppendStr(
|
| + SessionBuffer *p,
|
| + const char *zStr,
|
| + int *pRc
|
| +){
|
| + int nStr = sqlite3Strlen30(zStr);
|
| + if( 0==sessionBufferGrow(p, nStr, pRc) ){
|
| + memcpy(&p->aBuf[p->nBuf], zStr, nStr);
|
| + p->nBuf += nStr;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwise, append the string representation of integer iVal
|
| +** to the buffer. No nul-terminator is written.
|
| +**
|
| +** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
|
| +** returning.
|
| +*/
|
| +static void sessionAppendInteger(
|
| + SessionBuffer *p, /* Buffer to append to */
|
| + int iVal, /* Value to write the string rep. of */
|
| + int *pRc /* IN/OUT: Error code */
|
| +){
|
| + char aBuf[24];
|
| + sqlite3_snprintf(sizeof(aBuf)-1, aBuf, "%d", iVal);
|
| + sessionAppendStr(p, aBuf, pRc);
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwise, append the string zStr enclosed in quotes (") and
|
| +** with any embedded quote characters escaped to the buffer. No
|
| +** nul-terminator byte is written.
|
| +**
|
| +** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
|
| +** returning.
|
| +*/
|
| +static void sessionAppendIdent(
|
| + SessionBuffer *p, /* Buffer to a append to */
|
| + const char *zStr, /* String to quote, escape and append */
|
| + int *pRc /* IN/OUT: Error code */
|
| +){
|
| + int nStr = sqlite3Strlen30(zStr)*2 + 2 + 1;
|
| + if( 0==sessionBufferGrow(p, nStr, pRc) ){
|
| + char *zOut = (char *)&p->aBuf[p->nBuf];
|
| + const char *zIn = zStr;
|
| + *zOut++ = '"';
|
| + while( *zIn ){
|
| + if( *zIn=='"' ) *zOut++ = '"';
|
| + *zOut++ = *(zIn++);
|
| + }
|
| + *zOut++ = '"';
|
| + p->nBuf = (int)((u8 *)zOut - p->aBuf);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is other than SQLITE_OK when it is
|
| +** called. Otherwse, it appends the serialized version of the value stored
|
| +** in column iCol of the row that SQL statement pStmt currently points
|
| +** to to the buffer.
|
| +*/
|
| +static void sessionAppendCol(
|
| + SessionBuffer *p, /* Buffer to append to */
|
| + sqlite3_stmt *pStmt, /* Handle pointing to row containing value */
|
| + int iCol, /* Column to read value from */
|
| + int *pRc /* IN/OUT: Error code */
|
| +){
|
| + if( *pRc==SQLITE_OK ){
|
| + int eType = sqlite3_column_type(pStmt, iCol);
|
| + sessionAppendByte(p, (u8)eType, pRc);
|
| + if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + sqlite3_int64 i;
|
| + u8 aBuf[8];
|
| + if( eType==SQLITE_INTEGER ){
|
| + i = sqlite3_column_int64(pStmt, iCol);
|
| + }else{
|
| + double r = sqlite3_column_double(pStmt, iCol);
|
| + memcpy(&i, &r, 8);
|
| + }
|
| + sessionPutI64(aBuf, i);
|
| + sessionAppendBlob(p, aBuf, 8, pRc);
|
| + }
|
| + if( eType==SQLITE_BLOB || eType==SQLITE_TEXT ){
|
| + u8 *z;
|
| + int nByte;
|
| + if( eType==SQLITE_BLOB ){
|
| + z = (u8 *)sqlite3_column_blob(pStmt, iCol);
|
| + }else{
|
| + z = (u8 *)sqlite3_column_text(pStmt, iCol);
|
| + }
|
| + nByte = sqlite3_column_bytes(pStmt, iCol);
|
| + if( z || (eType==SQLITE_BLOB && nByte==0) ){
|
| + sessionAppendVarint(p, nByte, pRc);
|
| + sessionAppendBlob(p, z, nByte, pRc);
|
| + }else{
|
| + *pRc = SQLITE_NOMEM;
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +**
|
| +** This function appends an update change to the buffer (see the comments
|
| +** under "CHANGESET FORMAT" at the top of the file). An update change
|
| +** consists of:
|
| +**
|
| +** 1 byte: SQLITE_UPDATE (0x17)
|
| +** n bytes: old.* record (see RECORD FORMAT)
|
| +** m bytes: new.* record (see RECORD FORMAT)
|
| +**
|
| +** The SessionChange object passed as the third argument contains the
|
| +** values that were stored in the row when the session began (the old.*
|
| +** values). The statement handle passed as the second argument points
|
| +** at the current version of the row (the new.* values).
|
| +**
|
| +** If all of the old.* values are equal to their corresponding new.* value
|
| +** (i.e. nothing has changed), then no data at all is appended to the buffer.
|
| +**
|
| +** Otherwise, the old.* record contains all primary key values and the
|
| +** original values of any fields that have been modified. The new.* record
|
| +** contains the new values of only those fields that have been modified.
|
| +*/
|
| +static int sessionAppendUpdate(
|
| + SessionBuffer *pBuf, /* Buffer to append to */
|
| + int bPatchset, /* True for "patchset", 0 for "changeset" */
|
| + sqlite3_stmt *pStmt, /* Statement handle pointing at new row */
|
| + SessionChange *p, /* Object containing old values */
|
| + u8 *abPK /* Boolean array - true for PK columns */
|
| +){
|
| + int rc = SQLITE_OK;
|
| + SessionBuffer buf2 = {0,0,0}; /* Buffer to accumulate new.* record in */
|
| + int bNoop = 1; /* Set to zero if any values are modified */
|
| + int nRewind = pBuf->nBuf; /* Set to zero if any values are modified */
|
| + int i; /* Used to iterate through columns */
|
| + u8 *pCsr = p->aRecord; /* Used to iterate through old.* values */
|
| +
|
| + sessionAppendByte(pBuf, SQLITE_UPDATE, &rc);
|
| + sessionAppendByte(pBuf, p->bIndirect, &rc);
|
| + for(i=0; i<sqlite3_column_count(pStmt); i++){
|
| + int bChanged = 0;
|
| + int nAdvance;
|
| + int eType = *pCsr;
|
| + switch( eType ){
|
| + case SQLITE_NULL:
|
| + nAdvance = 1;
|
| + if( sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
|
| + bChanged = 1;
|
| + }
|
| + break;
|
| +
|
| + case SQLITE_FLOAT:
|
| + case SQLITE_INTEGER: {
|
| + nAdvance = 9;
|
| + if( eType==sqlite3_column_type(pStmt, i) ){
|
| + sqlite3_int64 iVal = sessionGetI64(&pCsr[1]);
|
| + if( eType==SQLITE_INTEGER ){
|
| + if( iVal==sqlite3_column_int64(pStmt, i) ) break;
|
| + }else{
|
| + double dVal;
|
| + memcpy(&dVal, &iVal, 8);
|
| + if( dVal==sqlite3_column_double(pStmt, i) ) break;
|
| + }
|
| + }
|
| + bChanged = 1;
|
| + break;
|
| + }
|
| +
|
| + default: {
|
| + int n;
|
| + int nHdr = 1 + sessionVarintGet(&pCsr[1], &n);
|
| + assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
|
| + nAdvance = nHdr + n;
|
| + if( eType==sqlite3_column_type(pStmt, i)
|
| + && n==sqlite3_column_bytes(pStmt, i)
|
| + && (n==0 || 0==memcmp(&pCsr[nHdr], sqlite3_column_blob(pStmt, i), n))
|
| + ){
|
| + break;
|
| + }
|
| + bChanged = 1;
|
| + }
|
| + }
|
| +
|
| + /* If at least one field has been modified, this is not a no-op. */
|
| + if( bChanged ) bNoop = 0;
|
| +
|
| + /* Add a field to the old.* record. This is omitted if this modules is
|
| + ** currently generating a patchset. */
|
| + if( bPatchset==0 ){
|
| + if( bChanged || abPK[i] ){
|
| + sessionAppendBlob(pBuf, pCsr, nAdvance, &rc);
|
| + }else{
|
| + sessionAppendByte(pBuf, 0, &rc);
|
| + }
|
| + }
|
| +
|
| + /* Add a field to the new.* record. Or the only record if currently
|
| + ** generating a patchset. */
|
| + if( bChanged || (bPatchset && abPK[i]) ){
|
| + sessionAppendCol(&buf2, pStmt, i, &rc);
|
| + }else{
|
| + sessionAppendByte(&buf2, 0, &rc);
|
| + }
|
| +
|
| + pCsr += nAdvance;
|
| + }
|
| +
|
| + if( bNoop ){
|
| + pBuf->nBuf = nRewind;
|
| + }else{
|
| + sessionAppendBlob(pBuf, buf2.aBuf, buf2.nBuf, &rc);
|
| + }
|
| + sqlite3_free(buf2.aBuf);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Append a DELETE change to the buffer passed as the first argument. Use
|
| +** the changeset format if argument bPatchset is zero, or the patchset
|
| +** format otherwise.
|
| +*/
|
| +static int sessionAppendDelete(
|
| + SessionBuffer *pBuf, /* Buffer to append to */
|
| + int bPatchset, /* True for "patchset", 0 for "changeset" */
|
| + SessionChange *p, /* Object containing old values */
|
| + int nCol, /* Number of columns in table */
|
| + u8 *abPK /* Boolean array - true for PK columns */
|
| +){
|
| + int rc = SQLITE_OK;
|
| +
|
| + sessionAppendByte(pBuf, SQLITE_DELETE, &rc);
|
| + sessionAppendByte(pBuf, p->bIndirect, &rc);
|
| +
|
| + if( bPatchset==0 ){
|
| + sessionAppendBlob(pBuf, p->aRecord, p->nRecord, &rc);
|
| + }else{
|
| + int i;
|
| + u8 *a = p->aRecord;
|
| + for(i=0; i<nCol; i++){
|
| + u8 *pStart = a;
|
| + int eType = *a++;
|
| +
|
| + switch( eType ){
|
| + case 0:
|
| + case SQLITE_NULL:
|
| + assert( abPK[i]==0 );
|
| + break;
|
| +
|
| + case SQLITE_FLOAT:
|
| + case SQLITE_INTEGER:
|
| + a += 8;
|
| + break;
|
| +
|
| + default: {
|
| + int n;
|
| + a += sessionVarintGet(a, &n);
|
| + a += n;
|
| + break;
|
| + }
|
| + }
|
| + if( abPK[i] ){
|
| + sessionAppendBlob(pBuf, pStart, (int)(a-pStart), &rc);
|
| + }
|
| + }
|
| + assert( (a - p->aRecord)==p->nRecord );
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Formulate and prepare a SELECT statement to retrieve a row from table
|
| +** zTab in database zDb based on its primary key. i.e.
|
| +**
|
| +** SELECT * FROM zDb.zTab WHERE pk1 = ? AND pk2 = ? AND ...
|
| +*/
|
| +static int sessionSelectStmt(
|
| + sqlite3 *db, /* Database handle */
|
| + const char *zDb, /* Database name */
|
| + const char *zTab, /* Table name */
|
| + int nCol, /* Number of columns in table */
|
| + const char **azCol, /* Names of table columns */
|
| + u8 *abPK, /* PRIMARY KEY array */
|
| + sqlite3_stmt **ppStmt /* OUT: Prepared SELECT statement */
|
| +){
|
| + int rc = SQLITE_OK;
|
| + int i;
|
| + const char *zSep = "";
|
| + SessionBuffer buf = {0, 0, 0};
|
| +
|
| + sessionAppendStr(&buf, "SELECT * FROM ", &rc);
|
| + sessionAppendIdent(&buf, zDb, &rc);
|
| + sessionAppendStr(&buf, ".", &rc);
|
| + sessionAppendIdent(&buf, zTab, &rc);
|
| + sessionAppendStr(&buf, " WHERE ", &rc);
|
| + for(i=0; i<nCol; i++){
|
| + if( abPK[i] ){
|
| + sessionAppendStr(&buf, zSep, &rc);
|
| + sessionAppendIdent(&buf, azCol[i], &rc);
|
| + sessionAppendStr(&buf, " = ?", &rc);
|
| + sessionAppendInteger(&buf, i+1, &rc);
|
| + zSep = " AND ";
|
| + }
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_prepare_v2(db, (char *)buf.aBuf, buf.nBuf, ppStmt, 0);
|
| + }
|
| + sqlite3_free(buf.aBuf);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Bind the PRIMARY KEY values from the change passed in argument pChange
|
| +** to the SELECT statement passed as the first argument. The SELECT statement
|
| +** is as prepared by function sessionSelectStmt().
|
| +**
|
| +** Return SQLITE_OK if all PK values are successfully bound, or an SQLite
|
| +** error code (e.g. SQLITE_NOMEM) otherwise.
|
| +*/
|
| +static int sessionSelectBind(
|
| + sqlite3_stmt *pSelect, /* SELECT from sessionSelectStmt() */
|
| + int nCol, /* Number of columns in table */
|
| + u8 *abPK, /* PRIMARY KEY array */
|
| + SessionChange *pChange /* Change structure */
|
| +){
|
| + int i;
|
| + int rc = SQLITE_OK;
|
| + u8 *a = pChange->aRecord;
|
| +
|
| + for(i=0; i<nCol && rc==SQLITE_OK; i++){
|
| + int eType = *a++;
|
| +
|
| + switch( eType ){
|
| + case 0:
|
| + case SQLITE_NULL:
|
| + assert( abPK[i]==0 );
|
| + break;
|
| +
|
| + case SQLITE_INTEGER: {
|
| + if( abPK[i] ){
|
| + i64 iVal = sessionGetI64(a);
|
| + rc = sqlite3_bind_int64(pSelect, i+1, iVal);
|
| + }
|
| + a += 8;
|
| + break;
|
| + }
|
| +
|
| + case SQLITE_FLOAT: {
|
| + if( abPK[i] ){
|
| + double rVal;
|
| + i64 iVal = sessionGetI64(a);
|
| + memcpy(&rVal, &iVal, 8);
|
| + rc = sqlite3_bind_double(pSelect, i+1, rVal);
|
| + }
|
| + a += 8;
|
| + break;
|
| + }
|
| +
|
| + case SQLITE_TEXT: {
|
| + int n;
|
| + a += sessionVarintGet(a, &n);
|
| + if( abPK[i] ){
|
| + rc = sqlite3_bind_text(pSelect, i+1, (char *)a, n, SQLITE_TRANSIENT);
|
| + }
|
| + a += n;
|
| + break;
|
| + }
|
| +
|
| + default: {
|
| + int n;
|
| + assert( eType==SQLITE_BLOB );
|
| + a += sessionVarintGet(a, &n);
|
| + if( abPK[i] ){
|
| + rc = sqlite3_bind_blob(pSelect, i+1, a, n, SQLITE_TRANSIENT);
|
| + }
|
| + a += n;
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This function is a no-op if *pRc is set to other than SQLITE_OK when it
|
| +** is called. Otherwise, append a serialized table header (part of the binary
|
| +** changeset format) to buffer *pBuf. If an error occurs, set *pRc to an
|
| +** SQLite error code before returning.
|
| +*/
|
| +static void sessionAppendTableHdr(
|
| + SessionBuffer *pBuf, /* Append header to this buffer */
|
| + int bPatchset, /* Use the patchset format if true */
|
| + SessionTable *pTab, /* Table object to append header for */
|
| + int *pRc /* IN/OUT: Error code */
|
| +){
|
| + /* Write a table header */
|
| + sessionAppendByte(pBuf, (bPatchset ? 'P' : 'T'), pRc);
|
| + sessionAppendVarint(pBuf, pTab->nCol, pRc);
|
| + sessionAppendBlob(pBuf, pTab->abPK, pTab->nCol, pRc);
|
| + sessionAppendBlob(pBuf, (u8 *)pTab->zName, (int)strlen(pTab->zName)+1, pRc);
|
| +}
|
| +
|
| +/*
|
| +** Generate either a changeset (if argument bPatchset is zero) or a patchset
|
| +** (if it is non-zero) based on the current contents of the session object
|
| +** passed as the first argument.
|
| +**
|
| +** If no error occurs, SQLITE_OK is returned and the new changeset/patchset
|
| +** stored in output variables *pnChangeset and *ppChangeset. Or, if an error
|
| +** occurs, an SQLite error code is returned and both output variables set
|
| +** to 0.
|
| +*/
|
| +static int sessionGenerateChangeset(
|
| + sqlite3_session *pSession, /* Session object */
|
| + int bPatchset, /* True for patchset, false for changeset */
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut, /* First argument for xOutput */
|
| + int *pnChangeset, /* OUT: Size of buffer at *ppChangeset */
|
| + void **ppChangeset /* OUT: Buffer containing changeset */
|
| +){
|
| + sqlite3 *db = pSession->db; /* Source database handle */
|
| + SessionTable *pTab; /* Used to iterate through attached tables */
|
| + SessionBuffer buf = {0,0,0}; /* Buffer in which to accumlate changeset */
|
| + int rc; /* Return code */
|
| +
|
| + assert( xOutput==0 || (pnChangeset==0 && ppChangeset==0 ) );
|
| +
|
| + /* Zero the output variables in case an error occurs. If this session
|
| + ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
|
| + ** this call will be a no-op. */
|
| + if( xOutput==0 ){
|
| + *pnChangeset = 0;
|
| + *ppChangeset = 0;
|
| + }
|
| +
|
| + if( pSession->rc ) return pSession->rc;
|
| + rc = sqlite3_exec(pSession->db, "SAVEPOINT changeset", 0, 0, 0);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(db));
|
| +
|
| + for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
|
| + if( pTab->nEntry ){
|
| + const char *zName = pTab->zName;
|
| + int nCol; /* Number of columns in table */
|
| + u8 *abPK; /* Primary key array */
|
| + const char **azCol = 0; /* Table columns */
|
| + int i; /* Used to iterate through hash buckets */
|
| + sqlite3_stmt *pSel = 0; /* SELECT statement to query table pTab */
|
| + int nRewind = buf.nBuf; /* Initial size of write buffer */
|
| + int nNoop; /* Size of buffer after writing tbl header */
|
| +
|
| + /* Check the table schema is still Ok. */
|
| + rc = sessionTableInfo(db, pSession->zDb, zName, &nCol, 0, &azCol, &abPK);
|
| + if( !rc && (pTab->nCol!=nCol || memcmp(abPK, pTab->abPK, nCol)) ){
|
| + rc = SQLITE_SCHEMA;
|
| + }
|
| +
|
| + /* Write a table header */
|
| + sessionAppendTableHdr(&buf, bPatchset, pTab, &rc);
|
| +
|
| + /* Build and compile a statement to execute: */
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionSelectStmt(
|
| + db, pSession->zDb, zName, nCol, azCol, abPK, &pSel);
|
| + }
|
| +
|
| + nNoop = buf.nBuf;
|
| + for(i=0; i<pTab->nChange && rc==SQLITE_OK; i++){
|
| + SessionChange *p; /* Used to iterate through changes */
|
| +
|
| + for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){
|
| + rc = sessionSelectBind(pSel, nCol, abPK, p);
|
| + if( rc!=SQLITE_OK ) continue;
|
| + if( sqlite3_step(pSel)==SQLITE_ROW ){
|
| + if( p->op==SQLITE_INSERT ){
|
| + int iCol;
|
| + sessionAppendByte(&buf, SQLITE_INSERT, &rc);
|
| + sessionAppendByte(&buf, p->bIndirect, &rc);
|
| + for(iCol=0; iCol<nCol; iCol++){
|
| + sessionAppendCol(&buf, pSel, iCol, &rc);
|
| + }
|
| + }else{
|
| + rc = sessionAppendUpdate(&buf, bPatchset, pSel, p, abPK);
|
| + }
|
| + }else if( p->op!=SQLITE_INSERT ){
|
| + rc = sessionAppendDelete(&buf, bPatchset, p, nCol, abPK);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_reset(pSel);
|
| + }
|
| +
|
| + /* If the buffer is now larger than SESSIONS_STRM_CHUNK_SIZE, pass
|
| + ** its contents to the xOutput() callback. */
|
| + if( xOutput
|
| + && rc==SQLITE_OK
|
| + && buf.nBuf>nNoop
|
| + && buf.nBuf>SESSIONS_STRM_CHUNK_SIZE
|
| + ){
|
| + rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
|
| + nNoop = -1;
|
| + buf.nBuf = 0;
|
| + }
|
| +
|
| + }
|
| + }
|
| +
|
| + sqlite3_finalize(pSel);
|
| + if( buf.nBuf==nNoop ){
|
| + buf.nBuf = nRewind;
|
| + }
|
| + sqlite3_free((char*)azCol); /* cast works around VC++ bug */
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + if( xOutput==0 ){
|
| + *pnChangeset = buf.nBuf;
|
| + *ppChangeset = buf.aBuf;
|
| + buf.aBuf = 0;
|
| + }else if( buf.nBuf>0 ){
|
| + rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
|
| + }
|
| + }
|
| +
|
| + sqlite3_free(buf.aBuf);
|
| + sqlite3_exec(db, "RELEASE changeset", 0, 0, 0);
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(db));
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Obtain a changeset object containing all changes recorded by the
|
| +** session object passed as the first argument.
|
| +**
|
| +** It is the responsibility of the caller to eventually free the buffer
|
| +** using sqlite3_free().
|
| +*/
|
| +SQLITE_API int sqlite3session_changeset(
|
| + sqlite3_session *pSession, /* Session object */
|
| + int *pnChangeset, /* OUT: Size of buffer at *ppChangeset */
|
| + void **ppChangeset /* OUT: Buffer containing changeset */
|
| +){
|
| + return sessionGenerateChangeset(pSession, 0, 0, 0, pnChangeset, ppChangeset);
|
| +}
|
| +
|
| +/*
|
| +** Streaming version of sqlite3session_changeset().
|
| +*/
|
| +SQLITE_API int sqlite3session_changeset_strm(
|
| + sqlite3_session *pSession,
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut
|
| +){
|
| + return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0);
|
| +}
|
| +
|
| +/*
|
| +** Streaming version of sqlite3session_patchset().
|
| +*/
|
| +SQLITE_API int sqlite3session_patchset_strm(
|
| + sqlite3_session *pSession,
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut
|
| +){
|
| + return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0);
|
| +}
|
| +
|
| +/*
|
| +** Obtain a patchset object containing all changes recorded by the
|
| +** session object passed as the first argument.
|
| +**
|
| +** It is the responsibility of the caller to eventually free the buffer
|
| +** using sqlite3_free().
|
| +*/
|
| +SQLITE_API int sqlite3session_patchset(
|
| + sqlite3_session *pSession, /* Session object */
|
| + int *pnPatchset, /* OUT: Size of buffer at *ppChangeset */
|
| + void **ppPatchset /* OUT: Buffer containing changeset */
|
| +){
|
| + return sessionGenerateChangeset(pSession, 1, 0, 0, pnPatchset, ppPatchset);
|
| +}
|
| +
|
| +/*
|
| +** Enable or disable the session object passed as the first argument.
|
| +*/
|
| +SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable){
|
| + int ret;
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
|
| + if( bEnable>=0 ){
|
| + pSession->bEnable = bEnable;
|
| + }
|
| + ret = pSession->bEnable;
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
|
| + return ret;
|
| +}
|
| +
|
| +/*
|
| +** Enable or disable the session object passed as the first argument.
|
| +*/
|
| +SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect){
|
| + int ret;
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
|
| + if( bIndirect>=0 ){
|
| + pSession->bIndirect = bIndirect;
|
| + }
|
| + ret = pSession->bIndirect;
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
|
| + return ret;
|
| +}
|
| +
|
| +/*
|
| +** Return true if there have been no changes to monitored tables recorded
|
| +** by the session object passed as the only argument.
|
| +*/
|
| +SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession){
|
| + int ret = 0;
|
| + SessionTable *pTab;
|
| +
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(pSession->db));
|
| + for(pTab=pSession->pTable; pTab && ret==0; pTab=pTab->pNext){
|
| + ret = (pTab->nEntry>0);
|
| + }
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(pSession->db));
|
| +
|
| + return (ret==0);
|
| +}
|
| +
|
| +/*
|
| +** Do the work for either sqlite3changeset_start() or start_strm().
|
| +*/
|
| +static int sessionChangesetStart(
|
| + sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
|
| + int (*xInput)(void *pIn, void *pData, int *pnData),
|
| + void *pIn,
|
| + int nChangeset, /* Size of buffer pChangeset in bytes */
|
| + void *pChangeset /* Pointer to buffer containing changeset */
|
| +){
|
| + sqlite3_changeset_iter *pRet; /* Iterator to return */
|
| + int nByte; /* Number of bytes to allocate for iterator */
|
| +
|
| + assert( xInput==0 || (pChangeset==0 && nChangeset==0) );
|
| +
|
| + /* Zero the output variable in case an error occurs. */
|
| + *pp = 0;
|
| +
|
| + /* Allocate and initialize the iterator structure. */
|
| + nByte = sizeof(sqlite3_changeset_iter);
|
| + pRet = (sqlite3_changeset_iter *)sqlite3_malloc(nByte);
|
| + if( !pRet ) return SQLITE_NOMEM;
|
| + memset(pRet, 0, sizeof(sqlite3_changeset_iter));
|
| + pRet->in.aData = (u8 *)pChangeset;
|
| + pRet->in.nData = nChangeset;
|
| + pRet->in.xInput = xInput;
|
| + pRet->in.pIn = pIn;
|
| + pRet->in.bEof = (xInput ? 0 : 1);
|
| +
|
| + /* Populate the output variable and return success. */
|
| + *pp = pRet;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Create an iterator used to iterate through the contents of a changeset.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_start(
|
| + sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
|
| + int nChangeset, /* Size of buffer pChangeset in bytes */
|
| + void *pChangeset /* Pointer to buffer containing changeset */
|
| +){
|
| + return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset);
|
| +}
|
| +
|
| +/*
|
| +** Streaming version of sqlite3changeset_start().
|
| +*/
|
| +SQLITE_API int sqlite3changeset_start_strm(
|
| + sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
|
| + int (*xInput)(void *pIn, void *pData, int *pnData),
|
| + void *pIn
|
| +){
|
| + return sessionChangesetStart(pp, xInput, pIn, 0, 0);
|
| +}
|
| +
|
| +/*
|
| +** If the SessionInput object passed as the only argument is a streaming
|
| +** object and the buffer is full, discard some data to free up space.
|
| +*/
|
| +static void sessionDiscardData(SessionInput *pIn){
|
| + if( pIn->bEof && pIn->xInput && pIn->iNext>=SESSIONS_STRM_CHUNK_SIZE ){
|
| + int nMove = pIn->buf.nBuf - pIn->iNext;
|
| + assert( nMove>=0 );
|
| + if( nMove>0 ){
|
| + memmove(pIn->buf.aBuf, &pIn->buf.aBuf[pIn->iNext], nMove);
|
| + }
|
| + pIn->buf.nBuf -= pIn->iNext;
|
| + pIn->iNext = 0;
|
| + pIn->nData = pIn->buf.nBuf;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Ensure that there are at least nByte bytes available in the buffer. Or,
|
| +** if there are not nByte bytes remaining in the input, that all available
|
| +** data is in the buffer.
|
| +**
|
| +** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise.
|
| +*/
|
| +static int sessionInputBuffer(SessionInput *pIn, int nByte){
|
| + int rc = SQLITE_OK;
|
| + if( pIn->xInput ){
|
| + while( !pIn->bEof && (pIn->iNext+nByte)>=pIn->nData && rc==SQLITE_OK ){
|
| + int nNew = SESSIONS_STRM_CHUNK_SIZE;
|
| +
|
| + if( pIn->bNoDiscard==0 ) sessionDiscardData(pIn);
|
| + if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
|
| + rc = pIn->xInput(pIn->pIn, &pIn->buf.aBuf[pIn->buf.nBuf], &nNew);
|
| + if( nNew==0 ){
|
| + pIn->bEof = 1;
|
| + }else{
|
| + pIn->buf.nBuf += nNew;
|
| + }
|
| + }
|
| +
|
| + pIn->aData = pIn->buf.aBuf;
|
| + pIn->nData = pIn->buf.nBuf;
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** When this function is called, *ppRec points to the start of a record
|
| +** that contains nCol values. This function advances the pointer *ppRec
|
| +** until it points to the byte immediately following that record.
|
| +*/
|
| +static void sessionSkipRecord(
|
| + u8 **ppRec, /* IN/OUT: Record pointer */
|
| + int nCol /* Number of values in record */
|
| +){
|
| + u8 *aRec = *ppRec;
|
| + int i;
|
| + for(i=0; i<nCol; i++){
|
| + int eType = *aRec++;
|
| + if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
|
| + int nByte;
|
| + aRec += sessionVarintGet((u8*)aRec, &nByte);
|
| + aRec += nByte;
|
| + }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + aRec += 8;
|
| + }
|
| + }
|
| +
|
| + *ppRec = aRec;
|
| +}
|
| +
|
| +/*
|
| +** This function sets the value of the sqlite3_value object passed as the
|
| +** first argument to a copy of the string or blob held in the aData[]
|
| +** buffer. SQLITE_OK is returned if successful, or SQLITE_NOMEM if an OOM
|
| +** error occurs.
|
| +*/
|
| +static int sessionValueSetStr(
|
| + sqlite3_value *pVal, /* Set the value of this object */
|
| + u8 *aData, /* Buffer containing string or blob data */
|
| + int nData, /* Size of buffer aData[] in bytes */
|
| + u8 enc /* String encoding (0 for blobs) */
|
| +){
|
| + /* In theory this code could just pass SQLITE_TRANSIENT as the final
|
| + ** argument to sqlite3ValueSetStr() and have the copy created
|
| + ** automatically. But doing so makes it difficult to detect any OOM
|
| + ** error. Hence the code to create the copy externally. */
|
| + u8 *aCopy = sqlite3_malloc(nData+1);
|
| + if( aCopy==0 ) return SQLITE_NOMEM;
|
| + memcpy(aCopy, aData, nData);
|
| + sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Deserialize a single record from a buffer in memory. See "RECORD FORMAT"
|
| +** for details.
|
| +**
|
| +** When this function is called, *paChange points to the start of the record
|
| +** to deserialize. Assuming no error occurs, *paChange is set to point to
|
| +** one byte after the end of the same record before this function returns.
|
| +** If the argument abPK is NULL, then the record contains nCol values. Or,
|
| +** if abPK is other than NULL, then the record contains only the PK fields
|
| +** (in other words, it is a patchset DELETE record).
|
| +**
|
| +** If successful, each element of the apOut[] array (allocated by the caller)
|
| +** is set to point to an sqlite3_value object containing the value read
|
| +** from the corresponding position in the record. If that value is not
|
| +** included in the record (i.e. because the record is part of an UPDATE change
|
| +** and the field was not modified), the corresponding element of apOut[] is
|
| +** set to NULL.
|
| +**
|
| +** It is the responsibility of the caller to free all sqlite_value structures
|
| +** using sqlite3_free().
|
| +**
|
| +** If an error occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned.
|
| +** The apOut[] array may have been partially populated in this case.
|
| +*/
|
| +static int sessionReadRecord(
|
| + SessionInput *pIn, /* Input data */
|
| + int nCol, /* Number of values in record */
|
| + u8 *abPK, /* Array of primary key flags, or NULL */
|
| + sqlite3_value **apOut /* Write values to this array */
|
| +){
|
| + int i; /* Used to iterate through columns */
|
| + int rc = SQLITE_OK;
|
| +
|
| + for(i=0; i<nCol && rc==SQLITE_OK; i++){
|
| + int eType = 0; /* Type of value (SQLITE_NULL, TEXT etc.) */
|
| + if( abPK && abPK[i]==0 ) continue;
|
| + rc = sessionInputBuffer(pIn, 9);
|
| + if( rc==SQLITE_OK ){
|
| + eType = pIn->aData[pIn->iNext++];
|
| + }
|
| +
|
| + assert( apOut[i]==0 );
|
| + if( eType ){
|
| + apOut[i] = sqlite3ValueNew(0);
|
| + if( !apOut[i] ) rc = SQLITE_NOMEM;
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + u8 *aVal = &pIn->aData[pIn->iNext];
|
| + if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
|
| + int nByte;
|
| + pIn->iNext += sessionVarintGet(aVal, &nByte);
|
| + rc = sessionInputBuffer(pIn, nByte);
|
| + if( rc==SQLITE_OK ){
|
| + u8 enc = (eType==SQLITE_TEXT ? SQLITE_UTF8 : 0);
|
| + rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc);
|
| + }
|
| + pIn->iNext += nByte;
|
| + }
|
| + if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + sqlite3_int64 v = sessionGetI64(aVal);
|
| + if( eType==SQLITE_INTEGER ){
|
| + sqlite3VdbeMemSetInt64(apOut[i], v);
|
| + }else{
|
| + double d;
|
| + memcpy(&d, &v, 8);
|
| + sqlite3VdbeMemSetDouble(apOut[i], d);
|
| + }
|
| + pIn->iNext += 8;
|
| + }
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** The input pointer currently points to the second byte of a table-header.
|
| +** Specifically, to the following:
|
| +**
|
| +** + number of columns in table (varint)
|
| +** + array of PK flags (1 byte per column),
|
| +** + table name (nul terminated).
|
| +**
|
| +** This function ensures that all of the above is present in the input
|
| +** buffer (i.e. that it can be accessed without any calls to xInput()).
|
| +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
|
| +** The input pointer is not moved.
|
| +*/
|
| +static int sessionChangesetBufferTblhdr(SessionInput *pIn, int *pnByte){
|
| + int rc = SQLITE_OK;
|
| + int nCol = 0;
|
| + int nRead = 0;
|
| +
|
| + rc = sessionInputBuffer(pIn, 9);
|
| + if( rc==SQLITE_OK ){
|
| + nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
|
| + rc = sessionInputBuffer(pIn, nRead+nCol+100);
|
| + nRead += nCol;
|
| + }
|
| +
|
| + while( rc==SQLITE_OK ){
|
| + while( (pIn->iNext + nRead)<pIn->nData && pIn->aData[pIn->iNext + nRead] ){
|
| + nRead++;
|
| + }
|
| + if( (pIn->iNext + nRead)<pIn->nData ) break;
|
| + rc = sessionInputBuffer(pIn, nRead + 100);
|
| + }
|
| + *pnByte = nRead+1;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** The input pointer currently points to the first byte of the first field
|
| +** of a record consisting of nCol columns. This function ensures the entire
|
| +** record is buffered. It does not move the input pointer.
|
| +**
|
| +** If successful, SQLITE_OK is returned and *pnByte is set to the size of
|
| +** the record in bytes. Otherwise, an SQLite error code is returned. The
|
| +** final value of *pnByte is undefined in this case.
|
| +*/
|
| +static int sessionChangesetBufferRecord(
|
| + SessionInput *pIn, /* Input data */
|
| + int nCol, /* Number of columns in record */
|
| + int *pnByte /* OUT: Size of record in bytes */
|
| +){
|
| + int rc = SQLITE_OK;
|
| + int nByte = 0;
|
| + int i;
|
| + for(i=0; rc==SQLITE_OK && i<nCol; i++){
|
| + int eType;
|
| + rc = sessionInputBuffer(pIn, nByte + 10);
|
| + if( rc==SQLITE_OK ){
|
| + eType = pIn->aData[pIn->iNext + nByte++];
|
| + if( eType==SQLITE_TEXT || eType==SQLITE_BLOB ){
|
| + int n;
|
| + nByte += sessionVarintGet(&pIn->aData[pIn->iNext+nByte], &n);
|
| + nByte += n;
|
| + rc = sessionInputBuffer(pIn, nByte);
|
| + }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
|
| + nByte += 8;
|
| + }
|
| + }
|
| + }
|
| + *pnByte = nByte;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** The input pointer currently points to the second byte of a table-header.
|
| +** Specifically, to the following:
|
| +**
|
| +** + number of columns in table (varint)
|
| +** + array of PK flags (1 byte per column),
|
| +** + table name (nul terminated).
|
| +**
|
| +** This function decodes the table-header and populates the p->nCol,
|
| +** p->zTab and p->abPK[] variables accordingly. The p->apValue[] array is
|
| +** also allocated or resized according to the new value of p->nCol. The
|
| +** input pointer is left pointing to the byte following the table header.
|
| +**
|
| +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code
|
| +** is returned and the final values of the various fields enumerated above
|
| +** are undefined.
|
| +*/
|
| +static int sessionChangesetReadTblhdr(sqlite3_changeset_iter *p){
|
| + int rc;
|
| + int nCopy;
|
| + assert( p->rc==SQLITE_OK );
|
| +
|
| + rc = sessionChangesetBufferTblhdr(&p->in, &nCopy);
|
| + if( rc==SQLITE_OK ){
|
| + int nByte;
|
| + int nVarint;
|
| + nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
|
| + nCopy -= nVarint;
|
| + p->in.iNext += nVarint;
|
| + nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
|
| + p->tblhdr.nBuf = 0;
|
| + sessionBufferGrow(&p->tblhdr, nByte, &rc);
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + int iPK = sizeof(sqlite3_value*)*p->nCol*2;
|
| + memset(p->tblhdr.aBuf, 0, iPK);
|
| + memcpy(&p->tblhdr.aBuf[iPK], &p->in.aData[p->in.iNext], nCopy);
|
| + p->in.iNext += nCopy;
|
| + }
|
| +
|
| + p->apValue = (sqlite3_value**)p->tblhdr.aBuf;
|
| + p->abPK = (u8*)&p->apValue[p->nCol*2];
|
| + p->zTab = (char*)&p->abPK[p->nCol];
|
| + return (p->rc = rc);
|
| +}
|
| +
|
| +/*
|
| +** Advance the changeset iterator to the next change.
|
| +**
|
| +** If both paRec and pnRec are NULL, then this function works like the public
|
| +** API sqlite3changeset_next(). If SQLITE_ROW is returned, then the
|
| +** sqlite3changeset_new() and old() APIs may be used to query for values.
|
| +**
|
| +** Otherwise, if paRec and pnRec are not NULL, then a pointer to the change
|
| +** record is written to *paRec before returning and the number of bytes in
|
| +** the record to *pnRec.
|
| +**
|
| +** Either way, this function returns SQLITE_ROW if the iterator is
|
| +** successfully advanced to the next change in the changeset, an SQLite
|
| +** error code if an error occurs, or SQLITE_DONE if there are no further
|
| +** changes in the changeset.
|
| +*/
|
| +static int sessionChangesetNext(
|
| + sqlite3_changeset_iter *p, /* Changeset iterator */
|
| + u8 **paRec, /* If non-NULL, store record pointer here */
|
| + int *pnRec /* If non-NULL, store size of record here */
|
| +){
|
| + int i;
|
| + u8 op;
|
| +
|
| + assert( (paRec==0 && pnRec==0) || (paRec && pnRec) );
|
| +
|
| + /* If the iterator is in the error-state, return immediately. */
|
| + if( p->rc!=SQLITE_OK ) return p->rc;
|
| +
|
| + /* Free the current contents of p->apValue[], if any. */
|
| + if( p->apValue ){
|
| + for(i=0; i<p->nCol*2; i++){
|
| + sqlite3ValueFree(p->apValue[i]);
|
| + }
|
| + memset(p->apValue, 0, sizeof(sqlite3_value*)*p->nCol*2);
|
| + }
|
| +
|
| + /* Make sure the buffer contains at least 10 bytes of input data, or all
|
| + ** remaining data if there are less than 10 bytes available. This is
|
| + ** sufficient either for the 'T' or 'P' byte and the varint that follows
|
| + ** it, or for the two single byte values otherwise. */
|
| + p->rc = sessionInputBuffer(&p->in, 2);
|
| + if( p->rc!=SQLITE_OK ) return p->rc;
|
| +
|
| + /* If the iterator is already at the end of the changeset, return DONE. */
|
| + if( p->in.iNext>=p->in.nData ){
|
| + return SQLITE_DONE;
|
| + }
|
| +
|
| + sessionDiscardData(&p->in);
|
| + p->in.iCurrent = p->in.iNext;
|
| +
|
| + op = p->in.aData[p->in.iNext++];
|
| + if( op=='T' || op=='P' ){
|
| + p->bPatchset = (op=='P');
|
| + if( sessionChangesetReadTblhdr(p) ) return p->rc;
|
| + if( (p->rc = sessionInputBuffer(&p->in, 2)) ) return p->rc;
|
| + p->in.iCurrent = p->in.iNext;
|
| + op = p->in.aData[p->in.iNext++];
|
| + }
|
| +
|
| + p->op = op;
|
| + p->bIndirect = p->in.aData[p->in.iNext++];
|
| + if( p->op!=SQLITE_UPDATE && p->op!=SQLITE_DELETE && p->op!=SQLITE_INSERT ){
|
| + return (p->rc = SQLITE_CORRUPT_BKPT);
|
| + }
|
| +
|
| + if( paRec ){
|
| + int nVal; /* Number of values to buffer */
|
| + if( p->bPatchset==0 && op==SQLITE_UPDATE ){
|
| + nVal = p->nCol * 2;
|
| + }else if( p->bPatchset && op==SQLITE_DELETE ){
|
| + nVal = 0;
|
| + for(i=0; i<p->nCol; i++) if( p->abPK[i] ) nVal++;
|
| + }else{
|
| + nVal = p->nCol;
|
| + }
|
| + p->rc = sessionChangesetBufferRecord(&p->in, nVal, pnRec);
|
| + if( p->rc!=SQLITE_OK ) return p->rc;
|
| + *paRec = &p->in.aData[p->in.iNext];
|
| + p->in.iNext += *pnRec;
|
| + }else{
|
| +
|
| + /* If this is an UPDATE or DELETE, read the old.* record. */
|
| + if( p->op!=SQLITE_INSERT && (p->bPatchset==0 || p->op==SQLITE_DELETE) ){
|
| + u8 *abPK = p->bPatchset ? p->abPK : 0;
|
| + p->rc = sessionReadRecord(&p->in, p->nCol, abPK, p->apValue);
|
| + if( p->rc!=SQLITE_OK ) return p->rc;
|
| + }
|
| +
|
| + /* If this is an INSERT or UPDATE, read the new.* record. */
|
| + if( p->op!=SQLITE_DELETE ){
|
| + p->rc = sessionReadRecord(&p->in, p->nCol, 0, &p->apValue[p->nCol]);
|
| + if( p->rc!=SQLITE_OK ) return p->rc;
|
| + }
|
| +
|
| + if( p->bPatchset && p->op==SQLITE_UPDATE ){
|
| + /* If this is an UPDATE that is part of a patchset, then all PK and
|
| + ** modified fields are present in the new.* record. The old.* record
|
| + ** is currently completely empty. This block shifts the PK fields from
|
| + ** new.* to old.*, to accommodate the code that reads these arrays. */
|
| + for(i=0; i<p->nCol; i++){
|
| + assert( p->apValue[i]==0 );
|
| + assert( p->abPK[i]==0 || p->apValue[i+p->nCol] );
|
| + if( p->abPK[i] ){
|
| + p->apValue[i] = p->apValue[i+p->nCol];
|
| + p->apValue[i+p->nCol] = 0;
|
| + }
|
| + }
|
| + }
|
| + }
|
| +
|
| + return SQLITE_ROW;
|
| +}
|
| +
|
| +/*
|
| +** Advance an iterator created by sqlite3changeset_start() to the next
|
| +** change in the changeset. This function may return SQLITE_ROW, SQLITE_DONE
|
| +** or SQLITE_CORRUPT.
|
| +**
|
| +** This function may not be called on iterators passed to a conflict handler
|
| +** callback by changeset_apply().
|
| +*/
|
| +SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *p){
|
| + return sessionChangesetNext(p, 0, 0);
|
| +}
|
| +
|
| +/*
|
| +** The following function extracts information on the current change
|
| +** from a changeset iterator. It may only be called after changeset_next()
|
| +** has returned SQLITE_ROW.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_op(
|
| + sqlite3_changeset_iter *pIter, /* Iterator handle */
|
| + const char **pzTab, /* OUT: Pointer to table name */
|
| + int *pnCol, /* OUT: Number of columns in table */
|
| + int *pOp, /* OUT: SQLITE_INSERT, DELETE or UPDATE */
|
| + int *pbIndirect /* OUT: True if change is indirect */
|
| +){
|
| + *pOp = pIter->op;
|
| + *pnCol = pIter->nCol;
|
| + *pzTab = pIter->zTab;
|
| + if( pbIndirect ) *pbIndirect = pIter->bIndirect;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Return information regarding the PRIMARY KEY and number of columns in
|
| +** the database table affected by the change that pIter currently points
|
| +** to. This function may only be called after changeset_next() returns
|
| +** SQLITE_ROW.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_pk(
|
| + sqlite3_changeset_iter *pIter, /* Iterator object */
|
| + unsigned char **pabPK, /* OUT: Array of boolean - true for PK cols */
|
| + int *pnCol /* OUT: Number of entries in output array */
|
| +){
|
| + *pabPK = pIter->abPK;
|
| + if( pnCol ) *pnCol = pIter->nCol;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** This function may only be called while the iterator is pointing to an
|
| +** SQLITE_UPDATE or SQLITE_DELETE change (see sqlite3changeset_op()).
|
| +** Otherwise, SQLITE_MISUSE is returned.
|
| +**
|
| +** It sets *ppValue to point to an sqlite3_value structure containing the
|
| +** iVal'th value in the old.* record. Or, if that particular value is not
|
| +** included in the record (because the change is an UPDATE and the field
|
| +** was not modified and is not a PK column), set *ppValue to NULL.
|
| +**
|
| +** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
|
| +** not modified. Otherwise, SQLITE_OK.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_old(
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + int iVal, /* Index of old.* value to retrieve */
|
| + sqlite3_value **ppValue /* OUT: Old value (or NULL pointer) */
|
| +){
|
| + if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_DELETE ){
|
| + return SQLITE_MISUSE;
|
| + }
|
| + if( iVal<0 || iVal>=pIter->nCol ){
|
| + return SQLITE_RANGE;
|
| + }
|
| + *ppValue = pIter->apValue[iVal];
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** This function may only be called while the iterator is pointing to an
|
| +** SQLITE_UPDATE or SQLITE_INSERT change (see sqlite3changeset_op()).
|
| +** Otherwise, SQLITE_MISUSE is returned.
|
| +**
|
| +** It sets *ppValue to point to an sqlite3_value structure containing the
|
| +** iVal'th value in the new.* record. Or, if that particular value is not
|
| +** included in the record (because the change is an UPDATE and the field
|
| +** was not modified), set *ppValue to NULL.
|
| +**
|
| +** If value iVal is out-of-range, SQLITE_RANGE is returned and *ppValue is
|
| +** not modified. Otherwise, SQLITE_OK.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_new(
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + int iVal, /* Index of new.* value to retrieve */
|
| + sqlite3_value **ppValue /* OUT: New value (or NULL pointer) */
|
| +){
|
| + if( pIter->op!=SQLITE_UPDATE && pIter->op!=SQLITE_INSERT ){
|
| + return SQLITE_MISUSE;
|
| + }
|
| + if( iVal<0 || iVal>=pIter->nCol ){
|
| + return SQLITE_RANGE;
|
| + }
|
| + *ppValue = pIter->apValue[pIter->nCol+iVal];
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** The following two macros are used internally. They are similar to the
|
| +** sqlite3changeset_new() and sqlite3changeset_old() functions, except that
|
| +** they omit all error checking and return a pointer to the requested value.
|
| +*/
|
| +#define sessionChangesetNew(pIter, iVal) (pIter)->apValue[(pIter)->nCol+(iVal)]
|
| +#define sessionChangesetOld(pIter, iVal) (pIter)->apValue[(iVal)]
|
| +
|
| +/*
|
| +** This function may only be called with a changeset iterator that has been
|
| +** passed to an SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT
|
| +** conflict-handler function. Otherwise, SQLITE_MISUSE is returned.
|
| +**
|
| +** If successful, *ppValue is set to point to an sqlite3_value structure
|
| +** containing the iVal'th value of the conflicting record.
|
| +**
|
| +** If value iVal is out-of-range or some other error occurs, an SQLite error
|
| +** code is returned. Otherwise, SQLITE_OK.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_conflict(
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + int iVal, /* Index of conflict record value to fetch */
|
| + sqlite3_value **ppValue /* OUT: Value from conflicting row */
|
| +){
|
| + if( !pIter->pConflict ){
|
| + return SQLITE_MISUSE;
|
| + }
|
| + if( iVal<0 || iVal>=pIter->nCol ){
|
| + return SQLITE_RANGE;
|
| + }
|
| + *ppValue = sqlite3_column_value(pIter->pConflict, iVal);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** This function may only be called with an iterator passed to an
|
| +** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case
|
| +** it sets the output variable to the total number of known foreign key
|
| +** violations in the destination database and returns SQLITE_OK.
|
| +**
|
| +** In all other cases this function returns SQLITE_MISUSE.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_fk_conflicts(
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + int *pnOut /* OUT: Number of FK violations */
|
| +){
|
| + if( pIter->pConflict || pIter->apValue ){
|
| + return SQLITE_MISUSE;
|
| + }
|
| + *pnOut = pIter->nCol;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Finalize an iterator allocated with sqlite3changeset_start().
|
| +**
|
| +** This function may not be called on iterators passed to a conflict handler
|
| +** callback by changeset_apply().
|
| +*/
|
| +SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *p){
|
| + int rc = SQLITE_OK;
|
| + if( p ){
|
| + int i; /* Used to iterate through p->apValue[] */
|
| + rc = p->rc;
|
| + if( p->apValue ){
|
| + for(i=0; i<p->nCol*2; i++) sqlite3ValueFree(p->apValue[i]);
|
| + }
|
| + sqlite3_free(p->tblhdr.aBuf);
|
| + sqlite3_free(p->in.buf.aBuf);
|
| + sqlite3_free(p);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +static int sessionChangesetInvert(
|
| + SessionInput *pInput, /* Input changeset */
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut,
|
| + int *pnInverted, /* OUT: Number of bytes in output changeset */
|
| + void **ppInverted /* OUT: Inverse of pChangeset */
|
| +){
|
| + int rc = SQLITE_OK; /* Return value */
|
| + SessionBuffer sOut; /* Output buffer */
|
| + int nCol = 0; /* Number of cols in current table */
|
| + u8 *abPK = 0; /* PK array for current table */
|
| + sqlite3_value **apVal = 0; /* Space for values for UPDATE inversion */
|
| + SessionBuffer sPK = {0, 0, 0}; /* PK array for current table */
|
| +
|
| + /* Initialize the output buffer */
|
| + memset(&sOut, 0, sizeof(SessionBuffer));
|
| +
|
| + /* Zero the output variables in case an error occurs. */
|
| + if( ppInverted ){
|
| + *ppInverted = 0;
|
| + *pnInverted = 0;
|
| + }
|
| +
|
| + while( 1 ){
|
| + u8 eType;
|
| +
|
| + /* Test for EOF. */
|
| + if( (rc = sessionInputBuffer(pInput, 2)) ) goto finished_invert;
|
| + if( pInput->iNext>=pInput->nData ) break;
|
| + eType = pInput->aData[pInput->iNext];
|
| +
|
| + switch( eType ){
|
| + case 'T': {
|
| + /* A 'table' record consists of:
|
| + **
|
| + ** * A constant 'T' character,
|
| + ** * Number of columns in said table (a varint),
|
| + ** * An array of nCol bytes (sPK),
|
| + ** * A nul-terminated table name.
|
| + */
|
| + int nByte;
|
| + int nVar;
|
| + pInput->iNext++;
|
| + if( (rc = sessionChangesetBufferTblhdr(pInput, &nByte)) ){
|
| + goto finished_invert;
|
| + }
|
| + nVar = sessionVarintGet(&pInput->aData[pInput->iNext], &nCol);
|
| + sPK.nBuf = 0;
|
| + sessionAppendBlob(&sPK, &pInput->aData[pInput->iNext+nVar], nCol, &rc);
|
| + sessionAppendByte(&sOut, eType, &rc);
|
| + sessionAppendBlob(&sOut, &pInput->aData[pInput->iNext], nByte, &rc);
|
| + if( rc ) goto finished_invert;
|
| +
|
| + pInput->iNext += nByte;
|
| + sqlite3_free(apVal);
|
| + apVal = 0;
|
| + abPK = sPK.aBuf;
|
| + break;
|
| + }
|
| +
|
| + case SQLITE_INSERT:
|
| + case SQLITE_DELETE: {
|
| + int nByte;
|
| + int bIndirect = pInput->aData[pInput->iNext+1];
|
| + int eType2 = (eType==SQLITE_DELETE ? SQLITE_INSERT : SQLITE_DELETE);
|
| + pInput->iNext += 2;
|
| + assert( rc==SQLITE_OK );
|
| + rc = sessionChangesetBufferRecord(pInput, nCol, &nByte);
|
| + sessionAppendByte(&sOut, eType2, &rc);
|
| + sessionAppendByte(&sOut, bIndirect, &rc);
|
| + sessionAppendBlob(&sOut, &pInput->aData[pInput->iNext], nByte, &rc);
|
| + pInput->iNext += nByte;
|
| + if( rc ) goto finished_invert;
|
| + break;
|
| + }
|
| +
|
| + case SQLITE_UPDATE: {
|
| + int iCol;
|
| +
|
| + if( 0==apVal ){
|
| + apVal = (sqlite3_value **)sqlite3_malloc(sizeof(apVal[0])*nCol*2);
|
| + if( 0==apVal ){
|
| + rc = SQLITE_NOMEM;
|
| + goto finished_invert;
|
| + }
|
| + memset(apVal, 0, sizeof(apVal[0])*nCol*2);
|
| + }
|
| +
|
| + /* Write the header for the new UPDATE change. Same as the original. */
|
| + sessionAppendByte(&sOut, eType, &rc);
|
| + sessionAppendByte(&sOut, pInput->aData[pInput->iNext+1], &rc);
|
| +
|
| + /* Read the old.* and new.* records for the update change. */
|
| + pInput->iNext += 2;
|
| + rc = sessionReadRecord(pInput, nCol, 0, &apVal[0]);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionReadRecord(pInput, nCol, 0, &apVal[nCol]);
|
| + }
|
| +
|
| + /* Write the new old.* record. Consists of the PK columns from the
|
| + ** original old.* record, and the other values from the original
|
| + ** new.* record. */
|
| + for(iCol=0; iCol<nCol; iCol++){
|
| + sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
|
| + sessionAppendValue(&sOut, pVal, &rc);
|
| + }
|
| +
|
| + /* Write the new new.* record. Consists of a copy of all values
|
| + ** from the original old.* record, except for the PK columns, which
|
| + ** are set to "undefined". */
|
| + for(iCol=0; iCol<nCol; iCol++){
|
| + sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
|
| + sessionAppendValue(&sOut, pVal, &rc);
|
| + }
|
| +
|
| + for(iCol=0; iCol<nCol*2; iCol++){
|
| + sqlite3ValueFree(apVal[iCol]);
|
| + }
|
| + memset(apVal, 0, sizeof(apVal[0])*nCol*2);
|
| + if( rc!=SQLITE_OK ){
|
| + goto finished_invert;
|
| + }
|
| +
|
| + break;
|
| + }
|
| +
|
| + default:
|
| + rc = SQLITE_CORRUPT_BKPT;
|
| + goto finished_invert;
|
| + }
|
| +
|
| + assert( rc==SQLITE_OK );
|
| + if( xOutput && sOut.nBuf>=SESSIONS_STRM_CHUNK_SIZE ){
|
| + rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
|
| + sOut.nBuf = 0;
|
| + if( rc!=SQLITE_OK ) goto finished_invert;
|
| + }
|
| + }
|
| +
|
| + assert( rc==SQLITE_OK );
|
| + if( pnInverted ){
|
| + *pnInverted = sOut.nBuf;
|
| + *ppInverted = sOut.aBuf;
|
| + sOut.aBuf = 0;
|
| + }else if( sOut.nBuf>0 ){
|
| + rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
|
| + }
|
| +
|
| + finished_invert:
|
| + sqlite3_free(sOut.aBuf);
|
| + sqlite3_free(apVal);
|
| + sqlite3_free(sPK.aBuf);
|
| + return rc;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Invert a changeset object.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_invert(
|
| + int nChangeset, /* Number of bytes in input */
|
| + const void *pChangeset, /* Input changeset */
|
| + int *pnInverted, /* OUT: Number of bytes in output changeset */
|
| + void **ppInverted /* OUT: Inverse of pChangeset */
|
| +){
|
| + SessionInput sInput;
|
| +
|
| + /* Set up the input stream */
|
| + memset(&sInput, 0, sizeof(SessionInput));
|
| + sInput.nData = nChangeset;
|
| + sInput.aData = (u8*)pChangeset;
|
| +
|
| + return sessionChangesetInvert(&sInput, 0, 0, pnInverted, ppInverted);
|
| +}
|
| +
|
| +/*
|
| +** Streaming version of sqlite3changeset_invert().
|
| +*/
|
| +SQLITE_API int sqlite3changeset_invert_strm(
|
| + int (*xInput)(void *pIn, void *pData, int *pnData),
|
| + void *pIn,
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut
|
| +){
|
| + SessionInput sInput;
|
| + int rc;
|
| +
|
| + /* Set up the input stream */
|
| + memset(&sInput, 0, sizeof(SessionInput));
|
| + sInput.xInput = xInput;
|
| + sInput.pIn = pIn;
|
| +
|
| + rc = sessionChangesetInvert(&sInput, xOutput, pOut, 0, 0);
|
| + sqlite3_free(sInput.buf.aBuf);
|
| + return rc;
|
| +}
|
| +
|
| +typedef struct SessionApplyCtx SessionApplyCtx;
|
| +struct SessionApplyCtx {
|
| + sqlite3 *db;
|
| + sqlite3_stmt *pDelete; /* DELETE statement */
|
| + sqlite3_stmt *pUpdate; /* UPDATE statement */
|
| + sqlite3_stmt *pInsert; /* INSERT statement */
|
| + sqlite3_stmt *pSelect; /* SELECT statement */
|
| + int nCol; /* Size of azCol[] and abPK[] arrays */
|
| + const char **azCol; /* Array of column names */
|
| + u8 *abPK; /* Boolean array - true if column is in PK */
|
| +
|
| + int bDeferConstraints; /* True to defer constraints */
|
| + SessionBuffer constraints; /* Deferred constraints are stored here */
|
| +};
|
| +
|
| +/*
|
| +** Formulate a statement to DELETE a row from database db. Assuming a table
|
| +** structure like this:
|
| +**
|
| +** CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
|
| +**
|
| +** The DELETE statement looks like this:
|
| +**
|
| +** DELETE FROM x WHERE a = :1 AND c = :3 AND (:5 OR b IS :2 AND d IS :4)
|
| +**
|
| +** Variable :5 (nCol+1) is a boolean. It should be set to 0 if we require
|
| +** matching b and d values, or 1 otherwise. The second case comes up if the
|
| +** conflict handler is invoked with NOTFOUND and returns CHANGESET_REPLACE.
|
| +**
|
| +** If successful, SQLITE_OK is returned and SessionApplyCtx.pDelete is left
|
| +** pointing to the prepared version of the SQL statement.
|
| +*/
|
| +static int sessionDeleteRow(
|
| + sqlite3 *db, /* Database handle */
|
| + const char *zTab, /* Table name */
|
| + SessionApplyCtx *p /* Session changeset-apply context */
|
| +){
|
| + int i;
|
| + const char *zSep = "";
|
| + int rc = SQLITE_OK;
|
| + SessionBuffer buf = {0, 0, 0};
|
| + int nPk = 0;
|
| +
|
| + sessionAppendStr(&buf, "DELETE FROM ", &rc);
|
| + sessionAppendIdent(&buf, zTab, &rc);
|
| + sessionAppendStr(&buf, " WHERE ", &rc);
|
| +
|
| + for(i=0; i<p->nCol; i++){
|
| + if( p->abPK[i] ){
|
| + nPk++;
|
| + sessionAppendStr(&buf, zSep, &rc);
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + sessionAppendStr(&buf, " = ?", &rc);
|
| + sessionAppendInteger(&buf, i+1, &rc);
|
| + zSep = " AND ";
|
| + }
|
| + }
|
| +
|
| + if( nPk<p->nCol ){
|
| + sessionAppendStr(&buf, " AND (?", &rc);
|
| + sessionAppendInteger(&buf, p->nCol+1, &rc);
|
| + sessionAppendStr(&buf, " OR ", &rc);
|
| +
|
| + zSep = "";
|
| + for(i=0; i<p->nCol; i++){
|
| + if( !p->abPK[i] ){
|
| + sessionAppendStr(&buf, zSep, &rc);
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + sessionAppendStr(&buf, " IS ?", &rc);
|
| + sessionAppendInteger(&buf, i+1, &rc);
|
| + zSep = "AND ";
|
| + }
|
| + }
|
| + sessionAppendStr(&buf, ")", &rc);
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_prepare_v2(db, (char *)buf.aBuf, buf.nBuf, &p->pDelete, 0);
|
| + }
|
| + sqlite3_free(buf.aBuf);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Formulate and prepare a statement to UPDATE a row from database db.
|
| +** Assuming a table structure like this:
|
| +**
|
| +** CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
|
| +**
|
| +** The UPDATE statement looks like this:
|
| +**
|
| +** UPDATE x SET
|
| +** a = CASE WHEN ?2 THEN ?3 ELSE a END,
|
| +** b = CASE WHEN ?5 THEN ?6 ELSE b END,
|
| +** c = CASE WHEN ?8 THEN ?9 ELSE c END,
|
| +** d = CASE WHEN ?11 THEN ?12 ELSE d END
|
| +** WHERE a = ?1 AND c = ?7 AND (?13 OR
|
| +** (?5==0 OR b IS ?4) AND (?11==0 OR d IS ?10) AND
|
| +** )
|
| +**
|
| +** For each column in the table, there are three variables to bind:
|
| +**
|
| +** ?(i*3+1) The old.* value of the column, if any.
|
| +** ?(i*3+2) A boolean flag indicating that the value is being modified.
|
| +** ?(i*3+3) The new.* value of the column, if any.
|
| +**
|
| +** Also, a boolean flag that, if set to true, causes the statement to update
|
| +** a row even if the non-PK values do not match. This is required if the
|
| +** conflict-handler is invoked with CHANGESET_DATA and returns
|
| +** CHANGESET_REPLACE. This is variable "?(nCol*3+1)".
|
| +**
|
| +** If successful, SQLITE_OK is returned and SessionApplyCtx.pUpdate is left
|
| +** pointing to the prepared version of the SQL statement.
|
| +*/
|
| +static int sessionUpdateRow(
|
| + sqlite3 *db, /* Database handle */
|
| + const char *zTab, /* Table name */
|
| + SessionApplyCtx *p /* Session changeset-apply context */
|
| +){
|
| + int rc = SQLITE_OK;
|
| + int i;
|
| + const char *zSep = "";
|
| + SessionBuffer buf = {0, 0, 0};
|
| +
|
| + /* Append "UPDATE tbl SET " */
|
| + sessionAppendStr(&buf, "UPDATE ", &rc);
|
| + sessionAppendIdent(&buf, zTab, &rc);
|
| + sessionAppendStr(&buf, " SET ", &rc);
|
| +
|
| + /* Append the assignments */
|
| + for(i=0; i<p->nCol; i++){
|
| + sessionAppendStr(&buf, zSep, &rc);
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + sessionAppendStr(&buf, " = CASE WHEN ?", &rc);
|
| + sessionAppendInteger(&buf, i*3+2, &rc);
|
| + sessionAppendStr(&buf, " THEN ?", &rc);
|
| + sessionAppendInteger(&buf, i*3+3, &rc);
|
| + sessionAppendStr(&buf, " ELSE ", &rc);
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + sessionAppendStr(&buf, " END", &rc);
|
| + zSep = ", ";
|
| + }
|
| +
|
| + /* Append the PK part of the WHERE clause */
|
| + sessionAppendStr(&buf, " WHERE ", &rc);
|
| + for(i=0; i<p->nCol; i++){
|
| + if( p->abPK[i] ){
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + sessionAppendStr(&buf, " = ?", &rc);
|
| + sessionAppendInteger(&buf, i*3+1, &rc);
|
| + sessionAppendStr(&buf, " AND ", &rc);
|
| + }
|
| + }
|
| +
|
| + /* Append the non-PK part of the WHERE clause */
|
| + sessionAppendStr(&buf, " (?", &rc);
|
| + sessionAppendInteger(&buf, p->nCol*3+1, &rc);
|
| + sessionAppendStr(&buf, " OR 1", &rc);
|
| + for(i=0; i<p->nCol; i++){
|
| + if( !p->abPK[i] ){
|
| + sessionAppendStr(&buf, " AND (?", &rc);
|
| + sessionAppendInteger(&buf, i*3+2, &rc);
|
| + sessionAppendStr(&buf, "=0 OR ", &rc);
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + sessionAppendStr(&buf, " IS ?", &rc);
|
| + sessionAppendInteger(&buf, i*3+1, &rc);
|
| + sessionAppendStr(&buf, ")", &rc);
|
| + }
|
| + }
|
| + sessionAppendStr(&buf, ")", &rc);
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_prepare_v2(db, (char *)buf.aBuf, buf.nBuf, &p->pUpdate, 0);
|
| + }
|
| + sqlite3_free(buf.aBuf);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Formulate and prepare an SQL statement to query table zTab by primary
|
| +** key. Assuming the following table structure:
|
| +**
|
| +** CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
|
| +**
|
| +** The SELECT statement looks like this:
|
| +**
|
| +** SELECT * FROM x WHERE a = ?1 AND c = ?3
|
| +**
|
| +** If successful, SQLITE_OK is returned and SessionApplyCtx.pSelect is left
|
| +** pointing to the prepared version of the SQL statement.
|
| +*/
|
| +static int sessionSelectRow(
|
| + sqlite3 *db, /* Database handle */
|
| + const char *zTab, /* Table name */
|
| + SessionApplyCtx *p /* Session changeset-apply context */
|
| +){
|
| + return sessionSelectStmt(
|
| + db, "main", zTab, p->nCol, p->azCol, p->abPK, &p->pSelect);
|
| +}
|
| +
|
| +/*
|
| +** Formulate and prepare an INSERT statement to add a record to table zTab.
|
| +** For example:
|
| +**
|
| +** INSERT INTO main."zTab" VALUES(?1, ?2, ?3 ...);
|
| +**
|
| +** If successful, SQLITE_OK is returned and SessionApplyCtx.pInsert is left
|
| +** pointing to the prepared version of the SQL statement.
|
| +*/
|
| +static int sessionInsertRow(
|
| + sqlite3 *db, /* Database handle */
|
| + const char *zTab, /* Table name */
|
| + SessionApplyCtx *p /* Session changeset-apply context */
|
| +){
|
| + int rc = SQLITE_OK;
|
| + int i;
|
| + SessionBuffer buf = {0, 0, 0};
|
| +
|
| + sessionAppendStr(&buf, "INSERT INTO main.", &rc);
|
| + sessionAppendIdent(&buf, zTab, &rc);
|
| + sessionAppendStr(&buf, "(", &rc);
|
| + for(i=0; i<p->nCol; i++){
|
| + if( i!=0 ) sessionAppendStr(&buf, ", ", &rc);
|
| + sessionAppendIdent(&buf, p->azCol[i], &rc);
|
| + }
|
| +
|
| + sessionAppendStr(&buf, ") VALUES(?", &rc);
|
| + for(i=1; i<p->nCol; i++){
|
| + sessionAppendStr(&buf, ", ?", &rc);
|
| + }
|
| + sessionAppendStr(&buf, ")", &rc);
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_prepare_v2(db, (char *)buf.aBuf, buf.nBuf, &p->pInsert, 0);
|
| + }
|
| + sqlite3_free(buf.aBuf);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** A wrapper around sqlite3_bind_value() that detects an extra problem.
|
| +** See comments in the body of this function for details.
|
| +*/
|
| +static int sessionBindValue(
|
| + sqlite3_stmt *pStmt, /* Statement to bind value to */
|
| + int i, /* Parameter number to bind to */
|
| + sqlite3_value *pVal /* Value to bind */
|
| +){
|
| + int eType = sqlite3_value_type(pVal);
|
| + /* COVERAGE: The (pVal->z==0) branch is never true using current versions
|
| + ** of SQLite. If a malloc fails in an sqlite3_value_xxx() function, either
|
| + ** the (pVal->z) variable remains as it was or the type of the value is
|
| + ** set to SQLITE_NULL. */
|
| + if( (eType==SQLITE_TEXT || eType==SQLITE_BLOB) && pVal->z==0 ){
|
| + /* This condition occurs when an earlier OOM in a call to
|
| + ** sqlite3_value_text() or sqlite3_value_blob() (perhaps from within
|
| + ** a conflict-handler) has zeroed the pVal->z pointer. Return NOMEM. */
|
| + return SQLITE_NOMEM;
|
| + }
|
| + return sqlite3_bind_value(pStmt, i, pVal);
|
| +}
|
| +
|
| +/*
|
| +** Iterator pIter must point to an SQLITE_INSERT entry. This function
|
| +** transfers new.* values from the current iterator entry to statement
|
| +** pStmt. The table being inserted into has nCol columns.
|
| +**
|
| +** New.* value $i from the iterator is bound to variable ($i+1) of
|
| +** statement pStmt. If parameter abPK is NULL, all values from 0 to (nCol-1)
|
| +** are transfered to the statement. Otherwise, if abPK is not NULL, it points
|
| +** to an array nCol elements in size. In this case only those values for
|
| +** which abPK[$i] is true are read from the iterator and bound to the
|
| +** statement.
|
| +**
|
| +** An SQLite error code is returned if an error occurs. Otherwise, SQLITE_OK.
|
| +*/
|
| +static int sessionBindRow(
|
| + sqlite3_changeset_iter *pIter, /* Iterator to read values from */
|
| + int(*xValue)(sqlite3_changeset_iter *, int, sqlite3_value **),
|
| + int nCol, /* Number of columns */
|
| + u8 *abPK, /* If not NULL, bind only if true */
|
| + sqlite3_stmt *pStmt /* Bind values to this statement */
|
| +){
|
| + int i;
|
| + int rc = SQLITE_OK;
|
| +
|
| + /* Neither sqlite3changeset_old or sqlite3changeset_new can fail if the
|
| + ** argument iterator points to a suitable entry. Make sure that xValue
|
| + ** is one of these to guarantee that it is safe to ignore the return
|
| + ** in the code below. */
|
| + assert( xValue==sqlite3changeset_old || xValue==sqlite3changeset_new );
|
| +
|
| + for(i=0; rc==SQLITE_OK && i<nCol; i++){
|
| + if( !abPK || abPK[i] ){
|
| + sqlite3_value *pVal;
|
| + (void)xValue(pIter, i, &pVal);
|
| + rc = sessionBindValue(pStmt, i+1, pVal);
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** SQL statement pSelect is as generated by the sessionSelectRow() function.
|
| +** This function binds the primary key values from the change that changeset
|
| +** iterator pIter points to to the SELECT and attempts to seek to the table
|
| +** entry. If a row is found, the SELECT statement left pointing at the row
|
| +** and SQLITE_ROW is returned. Otherwise, if no row is found and no error
|
| +** has occured, the statement is reset and SQLITE_OK is returned. If an
|
| +** error occurs, the statement is reset and an SQLite error code is returned.
|
| +**
|
| +** If this function returns SQLITE_ROW, the caller must eventually reset()
|
| +** statement pSelect. If any other value is returned, the statement does
|
| +** not require a reset().
|
| +**
|
| +** If the iterator currently points to an INSERT record, bind values from the
|
| +** new.* record to the SELECT statement. Or, if it points to a DELETE or
|
| +** UPDATE, bind values from the old.* record.
|
| +*/
|
| +static int sessionSeekToRow(
|
| + sqlite3 *db, /* Database handle */
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + u8 *abPK, /* Primary key flags array */
|
| + sqlite3_stmt *pSelect /* SELECT statement from sessionSelectRow() */
|
| +){
|
| + int rc; /* Return code */
|
| + int nCol; /* Number of columns in table */
|
| + int op; /* Changset operation (SQLITE_UPDATE etc.) */
|
| + const char *zDummy; /* Unused */
|
| +
|
| + sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
|
| + rc = sessionBindRow(pIter,
|
| + op==SQLITE_INSERT ? sqlite3changeset_new : sqlite3changeset_old,
|
| + nCol, abPK, pSelect
|
| + );
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_step(pSelect);
|
| + if( rc!=SQLITE_ROW ) rc = sqlite3_reset(pSelect);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Invoke the conflict handler for the change that the changeset iterator
|
| +** currently points to.
|
| +**
|
| +** Argument eType must be either CHANGESET_DATA or CHANGESET_CONFLICT.
|
| +** If argument pbReplace is NULL, then the type of conflict handler invoked
|
| +** depends solely on eType, as follows:
|
| +**
|
| +** eType value Value passed to xConflict
|
| +** -------------------------------------------------
|
| +** CHANGESET_DATA CHANGESET_NOTFOUND
|
| +** CHANGESET_CONFLICT CHANGESET_CONSTRAINT
|
| +**
|
| +** Or, if pbReplace is not NULL, then an attempt is made to find an existing
|
| +** record with the same primary key as the record about to be deleted, updated
|
| +** or inserted. If such a record can be found, it is available to the conflict
|
| +** handler as the "conflicting" record. In this case the type of conflict
|
| +** handler invoked is as follows:
|
| +**
|
| +** eType value PK Record found? Value passed to xConflict
|
| +** ----------------------------------------------------------------
|
| +** CHANGESET_DATA Yes CHANGESET_DATA
|
| +** CHANGESET_DATA No CHANGESET_NOTFOUND
|
| +** CHANGESET_CONFLICT Yes CHANGESET_CONFLICT
|
| +** CHANGESET_CONFLICT No CHANGESET_CONSTRAINT
|
| +**
|
| +** If pbReplace is not NULL, and a record with a matching PK is found, and
|
| +** the conflict handler function returns SQLITE_CHANGESET_REPLACE, *pbReplace
|
| +** is set to non-zero before returning SQLITE_OK.
|
| +**
|
| +** If the conflict handler returns SQLITE_CHANGESET_ABORT, SQLITE_ABORT is
|
| +** returned. Or, if the conflict handler returns an invalid value,
|
| +** SQLITE_MISUSE. If the conflict handler returns SQLITE_CHANGESET_OMIT,
|
| +** this function returns SQLITE_OK.
|
| +*/
|
| +static int sessionConflictHandler(
|
| + int eType, /* Either CHANGESET_DATA or CONFLICT */
|
| + SessionApplyCtx *p, /* changeset_apply() context */
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + int(*xConflict)(void *, int, sqlite3_changeset_iter*),
|
| + void *pCtx, /* First argument for conflict handler */
|
| + int *pbReplace /* OUT: Set to true if PK row is found */
|
| +){
|
| + int res = 0; /* Value returned by conflict handler */
|
| + int rc;
|
| + int nCol;
|
| + int op;
|
| + const char *zDummy;
|
| +
|
| + sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
|
| +
|
| + assert( eType==SQLITE_CHANGESET_CONFLICT || eType==SQLITE_CHANGESET_DATA );
|
| + assert( SQLITE_CHANGESET_CONFLICT+1==SQLITE_CHANGESET_CONSTRAINT );
|
| + assert( SQLITE_CHANGESET_DATA+1==SQLITE_CHANGESET_NOTFOUND );
|
| +
|
| + /* Bind the new.* PRIMARY KEY values to the SELECT statement. */
|
| + if( pbReplace ){
|
| + rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);
|
| + }else{
|
| + rc = SQLITE_OK;
|
| + }
|
| +
|
| + if( rc==SQLITE_ROW ){
|
| + /* There exists another row with the new.* primary key. */
|
| + pIter->pConflict = p->pSelect;
|
| + res = xConflict(pCtx, eType, pIter);
|
| + pIter->pConflict = 0;
|
| + rc = sqlite3_reset(p->pSelect);
|
| + }else if( rc==SQLITE_OK ){
|
| + if( p->bDeferConstraints && eType==SQLITE_CHANGESET_CONFLICT ){
|
| + /* Instead of invoking the conflict handler, append the change blob
|
| + ** to the SessionApplyCtx.constraints buffer. */
|
| + u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
|
| + int nBlob = pIter->in.iNext - pIter->in.iCurrent;
|
| + sessionAppendBlob(&p->constraints, aBlob, nBlob, &rc);
|
| + res = SQLITE_CHANGESET_OMIT;
|
| + }else{
|
| + /* No other row with the new.* primary key. */
|
| + res = xConflict(pCtx, eType+1, pIter);
|
| + if( res==SQLITE_CHANGESET_REPLACE ) rc = SQLITE_MISUSE;
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + switch( res ){
|
| + case SQLITE_CHANGESET_REPLACE:
|
| + assert( pbReplace );
|
| + *pbReplace = 1;
|
| + break;
|
| +
|
| + case SQLITE_CHANGESET_OMIT:
|
| + break;
|
| +
|
| + case SQLITE_CHANGESET_ABORT:
|
| + rc = SQLITE_ABORT;
|
| + break;
|
| +
|
| + default:
|
| + rc = SQLITE_MISUSE;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Attempt to apply the change that the iterator passed as the first argument
|
| +** currently points to to the database. If a conflict is encountered, invoke
|
| +** the conflict handler callback.
|
| +**
|
| +** If argument pbRetry is NULL, then ignore any CHANGESET_DATA conflict. If
|
| +** one is encountered, update or delete the row with the matching primary key
|
| +** instead. Or, if pbRetry is not NULL and a CHANGESET_DATA conflict occurs,
|
| +** invoke the conflict handler. If it returns CHANGESET_REPLACE, set *pbRetry
|
| +** to true before returning. In this case the caller will invoke this function
|
| +** again, this time with pbRetry set to NULL.
|
| +**
|
| +** If argument pbReplace is NULL and a CHANGESET_CONFLICT conflict is
|
| +** encountered invoke the conflict handler with CHANGESET_CONSTRAINT instead.
|
| +** Or, if pbReplace is not NULL, invoke it with CHANGESET_CONFLICT. If such
|
| +** an invocation returns SQLITE_CHANGESET_REPLACE, set *pbReplace to true
|
| +** before retrying. In this case the caller attempts to remove the conflicting
|
| +** row before invoking this function again, this time with pbReplace set
|
| +** to NULL.
|
| +**
|
| +** If any conflict handler returns SQLITE_CHANGESET_ABORT, this function
|
| +** returns SQLITE_ABORT. Otherwise, if no error occurs, SQLITE_OK is
|
| +** returned.
|
| +*/
|
| +static int sessionApplyOneOp(
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator */
|
| + SessionApplyCtx *p, /* changeset_apply() context */
|
| + int(*xConflict)(void *, int, sqlite3_changeset_iter *),
|
| + void *pCtx, /* First argument for the conflict handler */
|
| + int *pbReplace, /* OUT: True to remove PK row and retry */
|
| + int *pbRetry /* OUT: True to retry. */
|
| +){
|
| + const char *zDummy;
|
| + int op;
|
| + int nCol;
|
| + int rc = SQLITE_OK;
|
| +
|
| + assert( p->pDelete && p->pUpdate && p->pInsert && p->pSelect );
|
| + assert( p->azCol && p->abPK );
|
| + assert( !pbReplace || *pbReplace==0 );
|
| +
|
| + sqlite3changeset_op(pIter, &zDummy, &nCol, &op, 0);
|
| +
|
| + if( op==SQLITE_DELETE ){
|
| +
|
| + /* Bind values to the DELETE statement. If conflict handling is required,
|
| + ** bind values for all columns and set bound variable (nCol+1) to true.
|
| + ** Or, if conflict handling is not required, bind just the PK column
|
| + ** values and, if it exists, set (nCol+1) to false. Conflict handling
|
| + ** is not required if:
|
| + **
|
| + ** * this is a patchset, or
|
| + ** * (pbRetry==0), or
|
| + ** * all columns of the table are PK columns (in this case there is
|
| + ** no (nCol+1) variable to bind to).
|
| + */
|
| + u8 *abPK = (pIter->bPatchset ? p->abPK : 0);
|
| + rc = sessionBindRow(pIter, sqlite3changeset_old, nCol, abPK, p->pDelete);
|
| + if( rc==SQLITE_OK && sqlite3_bind_parameter_count(p->pDelete)>nCol ){
|
| + rc = sqlite3_bind_int(p->pDelete, nCol+1, (pbRetry==0 || abPK));
|
| + }
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + sqlite3_step(p->pDelete);
|
| + rc = sqlite3_reset(p->pDelete);
|
| + if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
|
| + rc = sessionConflictHandler(
|
| + SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
|
| + );
|
| + }else if( (rc&0xff)==SQLITE_CONSTRAINT ){
|
| + rc = sessionConflictHandler(
|
| + SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
|
| + );
|
| + }
|
| +
|
| + }else if( op==SQLITE_UPDATE ){
|
| + int i;
|
| +
|
| + /* Bind values to the UPDATE statement. */
|
| + for(i=0; rc==SQLITE_OK && i<nCol; i++){
|
| + sqlite3_value *pOld = sessionChangesetOld(pIter, i);
|
| + sqlite3_value *pNew = sessionChangesetNew(pIter, i);
|
| +
|
| + sqlite3_bind_int(p->pUpdate, i*3+2, !!pNew);
|
| + if( pOld ){
|
| + rc = sessionBindValue(p->pUpdate, i*3+1, pOld);
|
| + }
|
| + if( rc==SQLITE_OK && pNew ){
|
| + rc = sessionBindValue(p->pUpdate, i*3+3, pNew);
|
| + }
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + sqlite3_bind_int(p->pUpdate, nCol*3+1, pbRetry==0 || pIter->bPatchset);
|
| + }
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + /* Attempt the UPDATE. In the case of a NOTFOUND or DATA conflict,
|
| + ** the result will be SQLITE_OK with 0 rows modified. */
|
| + sqlite3_step(p->pUpdate);
|
| + rc = sqlite3_reset(p->pUpdate);
|
| +
|
| + if( rc==SQLITE_OK && sqlite3_changes(p->db)==0 ){
|
| + /* A NOTFOUND or DATA error. Search the table to see if it contains
|
| + ** a row with a matching primary key. If so, this is a DATA conflict.
|
| + ** Otherwise, if there is no primary key match, it is a NOTFOUND. */
|
| +
|
| + rc = sessionConflictHandler(
|
| + SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
|
| + );
|
| +
|
| + }else if( (rc&0xff)==SQLITE_CONSTRAINT ){
|
| + /* This is always a CONSTRAINT conflict. */
|
| + rc = sessionConflictHandler(
|
| + SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
|
| + );
|
| + }
|
| +
|
| + }else{
|
| + assert( op==SQLITE_INSERT );
|
| + rc = sessionBindRow(pIter, sqlite3changeset_new, nCol, 0, p->pInsert);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + sqlite3_step(p->pInsert);
|
| + rc = sqlite3_reset(p->pInsert);
|
| + if( (rc&0xff)==SQLITE_CONSTRAINT ){
|
| + rc = sessionConflictHandler(
|
| + SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
|
| + );
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Attempt to apply the change that the iterator passed as the first argument
|
| +** currently points to to the database. If a conflict is encountered, invoke
|
| +** the conflict handler callback.
|
| +**
|
| +** The difference between this function and sessionApplyOne() is that this
|
| +** function handles the case where the conflict-handler is invoked and
|
| +** returns SQLITE_CHANGESET_REPLACE - indicating that the change should be
|
| +** retried in some manner.
|
| +*/
|
| +static int sessionApplyOneWithRetry(
|
| + sqlite3 *db, /* Apply change to "main" db of this handle */
|
| + sqlite3_changeset_iter *pIter, /* Changeset iterator to read change from */
|
| + SessionApplyCtx *pApply, /* Apply context */
|
| + int(*xConflict)(void*, int, sqlite3_changeset_iter*),
|
| + void *pCtx /* First argument passed to xConflict */
|
| +){
|
| + int bReplace = 0;
|
| + int bRetry = 0;
|
| + int rc;
|
| +
|
| + rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
|
| + assert( rc==SQLITE_OK || (bRetry==0 && bReplace==0) );
|
| +
|
| + /* If the bRetry flag is set, the change has not been applied due to an
|
| + ** SQLITE_CHANGESET_DATA problem (i.e. this is an UPDATE or DELETE and
|
| + ** a row with the correct PK is present in the db, but one or more other
|
| + ** fields do not contain the expected values) and the conflict handler
|
| + ** returned SQLITE_CHANGESET_REPLACE. In this case retry the operation,
|
| + ** but pass NULL as the final argument so that sessionApplyOneOp() ignores
|
| + ** the SQLITE_CHANGESET_DATA problem. */
|
| + if( bRetry ){
|
| + assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
|
| + rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
|
| + }
|
| +
|
| + /* If the bReplace flag is set, the change is an INSERT that has not
|
| + ** been performed because the database already contains a row with the
|
| + ** specified primary key and the conflict handler returned
|
| + ** SQLITE_CHANGESET_REPLACE. In this case remove the conflicting row
|
| + ** before reattempting the INSERT. */
|
| + else if( bReplace ){
|
| + assert( pIter->op==SQLITE_INSERT );
|
| + rc = sqlite3_exec(db, "SAVEPOINT replace_op", 0, 0, 0);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionBindRow(pIter,
|
| + sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
|
| + sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + sqlite3_step(pApply->pDelete);
|
| + rc = sqlite3_reset(pApply->pDelete);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_exec(db, "RELEASE replace_op", 0, 0, 0);
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Retry the changes accumulated in the pApply->constraints buffer.
|
| +*/
|
| +static int sessionRetryConstraints(
|
| + sqlite3 *db,
|
| + int bPatchset,
|
| + const char *zTab,
|
| + SessionApplyCtx *pApply,
|
| + int(*xConflict)(void*, int, sqlite3_changeset_iter*),
|
| + void *pCtx /* First argument passed to xConflict */
|
| +){
|
| + int rc = SQLITE_OK;
|
| +
|
| + while( pApply->constraints.nBuf ){
|
| + sqlite3_changeset_iter *pIter2 = 0;
|
| + SessionBuffer cons = pApply->constraints;
|
| + memset(&pApply->constraints, 0, sizeof(SessionBuffer));
|
| +
|
| + rc = sessionChangesetStart(&pIter2, 0, 0, cons.nBuf, cons.aBuf);
|
| + if( rc==SQLITE_OK ){
|
| + int nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
|
| + int rc2;
|
| + pIter2->bPatchset = bPatchset;
|
| + pIter2->zTab = (char*)zTab;
|
| + pIter2->nCol = pApply->nCol;
|
| + pIter2->abPK = pApply->abPK;
|
| + sessionBufferGrow(&pIter2->tblhdr, nByte, &rc);
|
| + pIter2->apValue = (sqlite3_value**)pIter2->tblhdr.aBuf;
|
| + if( rc==SQLITE_OK ) memset(pIter2->apValue, 0, nByte);
|
| +
|
| + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter2) ){
|
| + rc = sessionApplyOneWithRetry(db, pIter2, pApply, xConflict, pCtx);
|
| + }
|
| +
|
| + rc2 = sqlite3changeset_finalize(pIter2);
|
| + if( rc==SQLITE_OK ) rc = rc2;
|
| + }
|
| + assert( pApply->bDeferConstraints || pApply->constraints.nBuf==0 );
|
| +
|
| + sqlite3_free(cons.aBuf);
|
| + if( rc!=SQLITE_OK ) break;
|
| + if( pApply->constraints.nBuf>=cons.nBuf ){
|
| + /* No progress was made on the last round. */
|
| + pApply->bDeferConstraints = 0;
|
| + }
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Argument pIter is a changeset iterator that has been initialized, but
|
| +** not yet passed to sqlite3changeset_next(). This function applies the
|
| +** changeset to the main database attached to handle "db". The supplied
|
| +** conflict handler callback is invoked to resolve any conflicts encountered
|
| +** while applying the change.
|
| +*/
|
| +static int sessionChangesetApply(
|
| + sqlite3 *db, /* Apply change to "main" db of this handle */
|
| + sqlite3_changeset_iter *pIter, /* Changeset to apply */
|
| + int(*xFilter)(
|
| + void *pCtx, /* Copy of sixth arg to _apply() */
|
| + const char *zTab /* Table name */
|
| + ),
|
| + int(*xConflict)(
|
| + void *pCtx, /* Copy of fifth arg to _apply() */
|
| + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */
|
| + sqlite3_changeset_iter *p /* Handle describing change and conflict */
|
| + ),
|
| + void *pCtx /* First argument passed to xConflict */
|
| +){
|
| + int schemaMismatch = 0;
|
| + int rc; /* Return code */
|
| + const char *zTab = 0; /* Name of current table */
|
| + int nTab = 0; /* Result of sqlite3Strlen30(zTab) */
|
| + SessionApplyCtx sApply; /* changeset_apply() context object */
|
| + int bPatchset;
|
| +
|
| + assert( xConflict!=0 );
|
| +
|
| + pIter->in.bNoDiscard = 1;
|
| + memset(&sApply, 0, sizeof(sApply));
|
| + sqlite3_mutex_enter(sqlite3_db_mutex(db));
|
| + rc = sqlite3_exec(db, "SAVEPOINT changeset_apply", 0, 0, 0);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_exec(db, "PRAGMA defer_foreign_keys = 1", 0, 0, 0);
|
| + }
|
| + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
|
| + int nCol;
|
| + int op;
|
| + const char *zNew;
|
| +
|
| + sqlite3changeset_op(pIter, &zNew, &nCol, &op, 0);
|
| +
|
| + if( zTab==0 || sqlite3_strnicmp(zNew, zTab, nTab+1) ){
|
| + u8 *abPK;
|
| +
|
| + rc = sessionRetryConstraints(
|
| + db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
|
| + );
|
| + if( rc!=SQLITE_OK ) break;
|
| +
|
| + sqlite3_free((char*)sApply.azCol); /* cast works around VC++ bug */
|
| + sqlite3_finalize(sApply.pDelete);
|
| + sqlite3_finalize(sApply.pUpdate);
|
| + sqlite3_finalize(sApply.pInsert);
|
| + sqlite3_finalize(sApply.pSelect);
|
| + memset(&sApply, 0, sizeof(sApply));
|
| + sApply.db = db;
|
| + sApply.bDeferConstraints = 1;
|
| +
|
| + /* If an xFilter() callback was specified, invoke it now. If the
|
| + ** xFilter callback returns zero, skip this table. If it returns
|
| + ** non-zero, proceed. */
|
| + schemaMismatch = (xFilter && (0==xFilter(pCtx, zNew)));
|
| + if( schemaMismatch ){
|
| + zTab = sqlite3_mprintf("%s", zNew);
|
| + if( zTab==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + break;
|
| + }
|
| + nTab = (int)strlen(zTab);
|
| + sApply.azCol = (const char **)zTab;
|
| + }else{
|
| + int nMinCol = 0;
|
| + int i;
|
| +
|
| + sqlite3changeset_pk(pIter, &abPK, 0);
|
| + rc = sessionTableInfo(
|
| + db, "main", zNew, &sApply.nCol, &zTab, &sApply.azCol, &sApply.abPK
|
| + );
|
| + if( rc!=SQLITE_OK ) break;
|
| + for(i=0; i<sApply.nCol; i++){
|
| + if( sApply.abPK[i] ) nMinCol = i+1;
|
| + }
|
| +
|
| + if( sApply.nCol==0 ){
|
| + schemaMismatch = 1;
|
| + sqlite3_log(SQLITE_SCHEMA,
|
| + "sqlite3changeset_apply(): no such table: %s", zTab
|
| + );
|
| + }
|
| + else if( sApply.nCol<nCol ){
|
| + schemaMismatch = 1;
|
| + sqlite3_log(SQLITE_SCHEMA,
|
| + "sqlite3changeset_apply(): table %s has %d columns, "
|
| + "expected %d or more",
|
| + zTab, sApply.nCol, nCol
|
| + );
|
| + }
|
| + else if( nCol<nMinCol || memcmp(sApply.abPK, abPK, nCol)!=0 ){
|
| + schemaMismatch = 1;
|
| + sqlite3_log(SQLITE_SCHEMA, "sqlite3changeset_apply(): "
|
| + "primary key mismatch for table %s", zTab
|
| + );
|
| + }
|
| + else{
|
| + sApply.nCol = nCol;
|
| + if((rc = sessionSelectRow(db, zTab, &sApply))
|
| + || (rc = sessionUpdateRow(db, zTab, &sApply))
|
| + || (rc = sessionDeleteRow(db, zTab, &sApply))
|
| + || (rc = sessionInsertRow(db, zTab, &sApply))
|
| + ){
|
| + break;
|
| + }
|
| + }
|
| + nTab = sqlite3Strlen30(zTab);
|
| + }
|
| + }
|
| +
|
| + /* If there is a schema mismatch on the current table, proceed to the
|
| + ** next change. A log message has already been issued. */
|
| + if( schemaMismatch ) continue;
|
| +
|
| + rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
|
| + }
|
| +
|
| + bPatchset = pIter->bPatchset;
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changeset_finalize(pIter);
|
| + }else{
|
| + sqlite3changeset_finalize(pIter);
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionRetryConstraints(db, bPatchset, zTab, &sApply, xConflict, pCtx);
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + int nFk, notUsed;
|
| + sqlite3_db_status(db, SQLITE_DBSTATUS_DEFERRED_FKS, &nFk, ¬Used, 0);
|
| + if( nFk!=0 ){
|
| + int res = SQLITE_CHANGESET_ABORT;
|
| + sqlite3_changeset_iter sIter;
|
| + memset(&sIter, 0, sizeof(sIter));
|
| + sIter.nCol = nFk;
|
| + res = xConflict(pCtx, SQLITE_CHANGESET_FOREIGN_KEY, &sIter);
|
| + if( res!=SQLITE_CHANGESET_OMIT ){
|
| + rc = SQLITE_CONSTRAINT;
|
| + }
|
| + }
|
| + }
|
| + sqlite3_exec(db, "PRAGMA defer_foreign_keys = 0", 0, 0, 0);
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0);
|
| + }else{
|
| + sqlite3_exec(db, "ROLLBACK TO changeset_apply", 0, 0, 0);
|
| + sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0);
|
| + }
|
| +
|
| + sqlite3_finalize(sApply.pInsert);
|
| + sqlite3_finalize(sApply.pDelete);
|
| + sqlite3_finalize(sApply.pUpdate);
|
| + sqlite3_finalize(sApply.pSelect);
|
| + sqlite3_free((char*)sApply.azCol); /* cast works around VC++ bug */
|
| + sqlite3_free((char*)sApply.constraints.aBuf);
|
| + sqlite3_mutex_leave(sqlite3_db_mutex(db));
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Apply the changeset passed via pChangeset/nChangeset to the main database
|
| +** attached to handle "db". Invoke the supplied conflict handler callback
|
| +** to resolve any conflicts encountered while applying the change.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_apply(
|
| + sqlite3 *db, /* Apply change to "main" db of this handle */
|
| + int nChangeset, /* Size of changeset in bytes */
|
| + void *pChangeset, /* Changeset blob */
|
| + int(*xFilter)(
|
| + void *pCtx, /* Copy of sixth arg to _apply() */
|
| + const char *zTab /* Table name */
|
| + ),
|
| + int(*xConflict)(
|
| + void *pCtx, /* Copy of fifth arg to _apply() */
|
| + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */
|
| + sqlite3_changeset_iter *p /* Handle describing change and conflict */
|
| + ),
|
| + void *pCtx /* First argument passed to xConflict */
|
| +){
|
| + sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
|
| + int rc = sqlite3changeset_start(&pIter, nChangeset, pChangeset);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionChangesetApply(db, pIter, xFilter, xConflict, pCtx);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Apply the changeset passed via xInput/pIn to the main database
|
| +** attached to handle "db". Invoke the supplied conflict handler callback
|
| +** to resolve any conflicts encountered while applying the change.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_apply_strm(
|
| + sqlite3 *db, /* Apply change to "main" db of this handle */
|
| + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
|
| + void *pIn, /* First arg for xInput */
|
| + int(*xFilter)(
|
| + void *pCtx, /* Copy of sixth arg to _apply() */
|
| + const char *zTab /* Table name */
|
| + ),
|
| + int(*xConflict)(
|
| + void *pCtx, /* Copy of sixth arg to _apply() */
|
| + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */
|
| + sqlite3_changeset_iter *p /* Handle describing change and conflict */
|
| + ),
|
| + void *pCtx /* First argument passed to xConflict */
|
| +){
|
| + sqlite3_changeset_iter *pIter; /* Iterator to skip through changeset */
|
| + int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionChangesetApply(db, pIter, xFilter, xConflict, pCtx);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** sqlite3_changegroup handle.
|
| +*/
|
| +struct sqlite3_changegroup {
|
| + int rc; /* Error code */
|
| + int bPatch; /* True to accumulate patchsets */
|
| + SessionTable *pList; /* List of tables in current patch */
|
| +};
|
| +
|
| +/*
|
| +** This function is called to merge two changes to the same row together as
|
| +** part of an sqlite3changeset_concat() operation. A new change object is
|
| +** allocated and a pointer to it stored in *ppNew.
|
| +*/
|
| +static int sessionChangeMerge(
|
| + SessionTable *pTab, /* Table structure */
|
| + int bPatchset, /* True for patchsets */
|
| + SessionChange *pExist, /* Existing change */
|
| + int op2, /* Second change operation */
|
| + int bIndirect, /* True if second change is indirect */
|
| + u8 *aRec, /* Second change record */
|
| + int nRec, /* Number of bytes in aRec */
|
| + SessionChange **ppNew /* OUT: Merged change */
|
| +){
|
| + SessionChange *pNew = 0;
|
| +
|
| + if( !pExist ){
|
| + pNew = (SessionChange *)sqlite3_malloc(sizeof(SessionChange) + nRec);
|
| + if( !pNew ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| + memset(pNew, 0, sizeof(SessionChange));
|
| + pNew->op = op2;
|
| + pNew->bIndirect = bIndirect;
|
| + pNew->nRecord = nRec;
|
| + pNew->aRecord = (u8*)&pNew[1];
|
| + memcpy(pNew->aRecord, aRec, nRec);
|
| + }else{
|
| + int op1 = pExist->op;
|
| +
|
| + /*
|
| + ** op1=INSERT, op2=INSERT -> Unsupported. Discard op2.
|
| + ** op1=INSERT, op2=UPDATE -> INSERT.
|
| + ** op1=INSERT, op2=DELETE -> (none)
|
| + **
|
| + ** op1=UPDATE, op2=INSERT -> Unsupported. Discard op2.
|
| + ** op1=UPDATE, op2=UPDATE -> UPDATE.
|
| + ** op1=UPDATE, op2=DELETE -> DELETE.
|
| + **
|
| + ** op1=DELETE, op2=INSERT -> UPDATE.
|
| + ** op1=DELETE, op2=UPDATE -> Unsupported. Discard op2.
|
| + ** op1=DELETE, op2=DELETE -> Unsupported. Discard op2.
|
| + */
|
| + if( (op1==SQLITE_INSERT && op2==SQLITE_INSERT)
|
| + || (op1==SQLITE_UPDATE && op2==SQLITE_INSERT)
|
| + || (op1==SQLITE_DELETE && op2==SQLITE_UPDATE)
|
| + || (op1==SQLITE_DELETE && op2==SQLITE_DELETE)
|
| + ){
|
| + pNew = pExist;
|
| + }else if( op1==SQLITE_INSERT && op2==SQLITE_DELETE ){
|
| + sqlite3_free(pExist);
|
| + assert( pNew==0 );
|
| + }else{
|
| + u8 *aExist = pExist->aRecord;
|
| + int nByte;
|
| + u8 *aCsr;
|
| +
|
| + /* Allocate a new SessionChange object. Ensure that the aRecord[]
|
| + ** buffer of the new object is large enough to hold any record that
|
| + ** may be generated by combining the input records. */
|
| + nByte = sizeof(SessionChange) + pExist->nRecord + nRec;
|
| + pNew = (SessionChange *)sqlite3_malloc(nByte);
|
| + if( !pNew ){
|
| + sqlite3_free(pExist);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + memset(pNew, 0, sizeof(SessionChange));
|
| + pNew->bIndirect = (bIndirect && pExist->bIndirect);
|
| + aCsr = pNew->aRecord = (u8 *)&pNew[1];
|
| +
|
| + if( op1==SQLITE_INSERT ){ /* INSERT + UPDATE */
|
| + u8 *a1 = aRec;
|
| + assert( op2==SQLITE_UPDATE );
|
| + pNew->op = SQLITE_INSERT;
|
| + if( bPatchset==0 ) sessionSkipRecord(&a1, pTab->nCol);
|
| + sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1);
|
| + }else if( op1==SQLITE_DELETE ){ /* DELETE + INSERT */
|
| + assert( op2==SQLITE_INSERT );
|
| + pNew->op = SQLITE_UPDATE;
|
| + if( bPatchset ){
|
| + memcpy(aCsr, aRec, nRec);
|
| + aCsr += nRec;
|
| + }else{
|
| + if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aExist, 0,aRec,0) ){
|
| + sqlite3_free(pNew);
|
| + pNew = 0;
|
| + }
|
| + }
|
| + }else if( op2==SQLITE_UPDATE ){ /* UPDATE + UPDATE */
|
| + u8 *a1 = aExist;
|
| + u8 *a2 = aRec;
|
| + assert( op1==SQLITE_UPDATE );
|
| + if( bPatchset==0 ){
|
| + sessionSkipRecord(&a1, pTab->nCol);
|
| + sessionSkipRecord(&a2, pTab->nCol);
|
| + }
|
| + pNew->op = SQLITE_UPDATE;
|
| + if( 0==sessionMergeUpdate(&aCsr, pTab, bPatchset, aRec, aExist,a1,a2) ){
|
| + sqlite3_free(pNew);
|
| + pNew = 0;
|
| + }
|
| + }else{ /* UPDATE + DELETE */
|
| + assert( op1==SQLITE_UPDATE && op2==SQLITE_DELETE );
|
| + pNew->op = SQLITE_DELETE;
|
| + if( bPatchset ){
|
| + memcpy(aCsr, aRec, nRec);
|
| + aCsr += nRec;
|
| + }else{
|
| + sessionMergeRecord(&aCsr, pTab->nCol, aRec, aExist);
|
| + }
|
| + }
|
| +
|
| + if( pNew ){
|
| + pNew->nRecord = (int)(aCsr - pNew->aRecord);
|
| + }
|
| + sqlite3_free(pExist);
|
| + }
|
| + }
|
| +
|
| + *ppNew = pNew;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Add all changes in the changeset traversed by the iterator passed as
|
| +** the first argument to the changegroup hash tables.
|
| +*/
|
| +static int sessionChangesetToHash(
|
| + sqlite3_changeset_iter *pIter, /* Iterator to read from */
|
| + sqlite3_changegroup *pGrp /* Changegroup object to add changeset to */
|
| +){
|
| + u8 *aRec;
|
| + int nRec;
|
| + int rc = SQLITE_OK;
|
| + SessionTable *pTab = 0;
|
| +
|
| +
|
| + while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec) ){
|
| + const char *zNew;
|
| + int nCol;
|
| + int op;
|
| + int iHash;
|
| + int bIndirect;
|
| + SessionChange *pChange;
|
| + SessionChange *pExist = 0;
|
| + SessionChange **pp;
|
| +
|
| + if( pGrp->pList==0 ){
|
| + pGrp->bPatch = pIter->bPatchset;
|
| + }else if( pIter->bPatchset!=pGrp->bPatch ){
|
| + rc = SQLITE_ERROR;
|
| + break;
|
| + }
|
| +
|
| + sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect);
|
| + if( !pTab || sqlite3_stricmp(zNew, pTab->zName) ){
|
| + /* Search the list for a matching table */
|
| + int nNew = (int)strlen(zNew);
|
| + u8 *abPK;
|
| +
|
| + sqlite3changeset_pk(pIter, &abPK, 0);
|
| + for(pTab = pGrp->pList; pTab; pTab=pTab->pNext){
|
| + if( 0==sqlite3_strnicmp(pTab->zName, zNew, nNew+1) ) break;
|
| + }
|
| + if( !pTab ){
|
| + SessionTable **ppTab;
|
| +
|
| + pTab = sqlite3_malloc(sizeof(SessionTable) + nCol + nNew+1);
|
| + if( !pTab ){
|
| + rc = SQLITE_NOMEM;
|
| + break;
|
| + }
|
| + memset(pTab, 0, sizeof(SessionTable));
|
| + pTab->nCol = nCol;
|
| + pTab->abPK = (u8*)&pTab[1];
|
| + memcpy(pTab->abPK, abPK, nCol);
|
| + pTab->zName = (char*)&pTab->abPK[nCol];
|
| + memcpy(pTab->zName, zNew, nNew+1);
|
| +
|
| + /* The new object must be linked on to the end of the list, not
|
| + ** simply added to the start of it. This is to ensure that the
|
| + ** tables within the output of sqlite3changegroup_output() are in
|
| + ** the right order. */
|
| + for(ppTab=&pGrp->pList; *ppTab; ppTab=&(*ppTab)->pNext);
|
| + *ppTab = pTab;
|
| + }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){
|
| + rc = SQLITE_SCHEMA;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + if( sessionGrowHash(pIter->bPatchset, pTab) ){
|
| + rc = SQLITE_NOMEM;
|
| + break;
|
| + }
|
| + iHash = sessionChangeHash(
|
| + pTab, (pIter->bPatchset && op==SQLITE_DELETE), aRec, pTab->nChange
|
| + );
|
| +
|
| + /* Search for existing entry. If found, remove it from the hash table.
|
| + ** Code below may link it back in.
|
| + */
|
| + for(pp=&pTab->apChange[iHash]; *pp; pp=&(*pp)->pNext){
|
| + int bPkOnly1 = 0;
|
| + int bPkOnly2 = 0;
|
| + if( pIter->bPatchset ){
|
| + bPkOnly1 = (*pp)->op==SQLITE_DELETE;
|
| + bPkOnly2 = op==SQLITE_DELETE;
|
| + }
|
| + if( sessionChangeEqual(pTab, bPkOnly1, (*pp)->aRecord, bPkOnly2, aRec) ){
|
| + pExist = *pp;
|
| + *pp = (*pp)->pNext;
|
| + pTab->nEntry--;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + rc = sessionChangeMerge(pTab,
|
| + pIter->bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange
|
| + );
|
| + if( rc ) break;
|
| + if( pChange ){
|
| + pChange->pNext = pTab->apChange[iHash];
|
| + pTab->apChange[iHash] = pChange;
|
| + pTab->nEntry++;
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ) rc = pIter->rc;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Serialize a changeset (or patchset) based on all changesets (or patchsets)
|
| +** added to the changegroup object passed as the first argument.
|
| +**
|
| +** If xOutput is not NULL, then the changeset/patchset is returned to the
|
| +** user via one or more calls to xOutput, as with the other streaming
|
| +** interfaces.
|
| +**
|
| +** Or, if xOutput is NULL, then (*ppOut) is populated with a pointer to a
|
| +** buffer containing the output changeset before this function returns. In
|
| +** this case (*pnOut) is set to the size of the output buffer in bytes. It
|
| +** is the responsibility of the caller to free the output buffer using
|
| +** sqlite3_free() when it is no longer required.
|
| +**
|
| +** If successful, SQLITE_OK is returned. Or, if an error occurs, an SQLite
|
| +** error code. If an error occurs and xOutput is NULL, (*ppOut) and (*pnOut)
|
| +** are both set to 0 before returning.
|
| +*/
|
| +static int sessionChangegroupOutput(
|
| + sqlite3_changegroup *pGrp,
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut,
|
| + int *pnOut,
|
| + void **ppOut
|
| +){
|
| + int rc = SQLITE_OK;
|
| + SessionBuffer buf = {0, 0, 0};
|
| + SessionTable *pTab;
|
| + assert( xOutput==0 || (ppOut==0 && pnOut==0) );
|
| +
|
| + /* Create the serialized output changeset based on the contents of the
|
| + ** hash tables attached to the SessionTable objects in list p->pList.
|
| + */
|
| + for(pTab=pGrp->pList; rc==SQLITE_OK && pTab; pTab=pTab->pNext){
|
| + int i;
|
| + if( pTab->nEntry==0 ) continue;
|
| +
|
| + sessionAppendTableHdr(&buf, pGrp->bPatch, pTab, &rc);
|
| + for(i=0; i<pTab->nChange; i++){
|
| + SessionChange *p;
|
| + for(p=pTab->apChange[i]; p; p=p->pNext){
|
| + sessionAppendByte(&buf, p->op, &rc);
|
| + sessionAppendByte(&buf, p->bIndirect, &rc);
|
| + sessionAppendBlob(&buf, p->aRecord, p->nRecord, &rc);
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK && xOutput && buf.nBuf>=SESSIONS_STRM_CHUNK_SIZE ){
|
| + rc = xOutput(pOut, buf.aBuf, buf.nBuf);
|
| + buf.nBuf = 0;
|
| + }
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + if( xOutput ){
|
| + if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf);
|
| + }else{
|
| + *ppOut = buf.aBuf;
|
| + *pnOut = buf.nBuf;
|
| + buf.aBuf = 0;
|
| + }
|
| + }
|
| + sqlite3_free(buf.aBuf);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Allocate a new, empty, sqlite3_changegroup.
|
| +*/
|
| +SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp){
|
| + int rc = SQLITE_OK; /* Return code */
|
| + sqlite3_changegroup *p; /* New object */
|
| + p = (sqlite3_changegroup*)sqlite3_malloc(sizeof(sqlite3_changegroup));
|
| + if( p==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + }else{
|
| + memset(p, 0, sizeof(sqlite3_changegroup));
|
| + }
|
| + *pp = p;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Add the changeset currently stored in buffer pData, size nData bytes,
|
| +** to changeset-group p.
|
| +*/
|
| +SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup *pGrp, int nData, void *pData){
|
| + sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
|
| + int rc; /* Return code */
|
| +
|
| + rc = sqlite3changeset_start(&pIter, nData, pData);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionChangesetToHash(pIter, pGrp);
|
| + }
|
| + sqlite3changeset_finalize(pIter);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Obtain a buffer containing a changeset representing the concatenation
|
| +** of all changesets added to the group so far.
|
| +*/
|
| +SQLITE_API int sqlite3changegroup_output(
|
| + sqlite3_changegroup *pGrp,
|
| + int *pnData,
|
| + void **ppData
|
| +){
|
| + return sessionChangegroupOutput(pGrp, 0, 0, pnData, ppData);
|
| +}
|
| +
|
| +/*
|
| +** Streaming versions of changegroup_add().
|
| +*/
|
| +SQLITE_API int sqlite3changegroup_add_strm(
|
| + sqlite3_changegroup *pGrp,
|
| + int (*xInput)(void *pIn, void *pData, int *pnData),
|
| + void *pIn
|
| +){
|
| + sqlite3_changeset_iter *pIter; /* Iterator opened on pData/nData */
|
| + int rc; /* Return code */
|
| +
|
| + rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sessionChangesetToHash(pIter, pGrp);
|
| + }
|
| + sqlite3changeset_finalize(pIter);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Streaming versions of changegroup_output().
|
| +*/
|
| +SQLITE_API int sqlite3changegroup_output_strm(
|
| + sqlite3_changegroup *pGrp,
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut
|
| +){
|
| + return sessionChangegroupOutput(pGrp, xOutput, pOut, 0, 0);
|
| +}
|
| +
|
| +/*
|
| +** Delete a changegroup object.
|
| +*/
|
| +SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup *pGrp){
|
| + if( pGrp ){
|
| + sessionDeleteTable(pGrp->pList);
|
| + sqlite3_free(pGrp);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Combine two changesets together.
|
| +*/
|
| +SQLITE_API int sqlite3changeset_concat(
|
| + int nLeft, /* Number of bytes in lhs input */
|
| + void *pLeft, /* Lhs input changeset */
|
| + int nRight /* Number of bytes in rhs input */,
|
| + void *pRight, /* Rhs input changeset */
|
| + int *pnOut, /* OUT: Number of bytes in output changeset */
|
| + void **ppOut /* OUT: changeset (left <concat> right) */
|
| +){
|
| + sqlite3_changegroup *pGrp;
|
| + int rc;
|
| +
|
| + rc = sqlite3changegroup_new(&pGrp);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changegroup_add(pGrp, nLeft, pLeft);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changegroup_add(pGrp, nRight, pRight);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changegroup_output(pGrp, pnOut, ppOut);
|
| + }
|
| + sqlite3changegroup_delete(pGrp);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Streaming version of sqlite3changeset_concat().
|
| +*/
|
| +SQLITE_API int sqlite3changeset_concat_strm(
|
| + int (*xInputA)(void *pIn, void *pData, int *pnData),
|
| + void *pInA,
|
| + int (*xInputB)(void *pIn, void *pData, int *pnData),
|
| + void *pInB,
|
| + int (*xOutput)(void *pOut, const void *pData, int nData),
|
| + void *pOut
|
| +){
|
| + sqlite3_changegroup *pGrp;
|
| + int rc;
|
| +
|
| + rc = sqlite3changegroup_new(&pGrp);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changegroup_add_strm(pGrp, xInputA, pInA);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changegroup_add_strm(pGrp, xInputB, pInB);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3changegroup_output_strm(pGrp, xOutput, pOut);
|
| + }
|
| + sqlite3changegroup_delete(pGrp);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +#endif /* SQLITE_ENABLE_SESSION && SQLITE_ENABLE_PREUPDATE_HOOK */
|
| +
|
| +/************** End of sqlite3session.c **************************************/
|
| +/************** Begin file json1.c *******************************************/
|
| +/*
|
| +** 2015-08-12
|
| +**
|
| +** The author disclaims copyright to this source code. In place of
|
| +** a legal notice, here is a blessing:
|
| +**
|
| +** May you do good and not evil.
|
| +** May you find forgiveness for yourself and forgive others.
|
| +** May you share freely, never taking more than you give.
|
| +**
|
| +******************************************************************************
|
| +**
|
| +** This SQLite extension implements JSON functions. The interface is
|
| +** modeled after MySQL JSON functions:
|
| +**
|
| +** https://dev.mysql.com/doc/refman/5.7/en/json.html
|
| +**
|
| +** For the time being, all JSON is stored as pure text. (We might add
|
| +** a JSONB type in the future which stores a binary encoding of JSON in
|
| +** a BLOB, but there is no support for JSONB in the current implementation.
|
| +** This implementation parses JSON text at 250 MB/s, so it is hard to see
|
| +** how JSONB might improve on that.)
|
| +*/
|
| +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1)
|
| +#if !defined(SQLITEINT_H)
|
| +/* #include "sqlite3ext.h" */
|
| +#endif
|
| +SQLITE_EXTENSION_INIT1
|
| +/* #include <assert.h> */
|
| +/* #include <string.h> */
|
| +/* #include <stdlib.h> */
|
| +/* #include <stdarg.h> */
|
| +
|
| +/* Mark a function parameter as unused, to suppress nuisance compiler
|
| +** warnings. */
|
| +#ifndef UNUSED_PARAM
|
| +# define UNUSED_PARAM(X) (void)(X)
|
| +#endif
|
| +
|
| +#ifndef LARGEST_INT64
|
| +# define LARGEST_INT64 (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32))
|
| +# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64)
|
| +#endif
|
| +
|
| +/*
|
| +** Versions of isspace(), isalnum() and isdigit() to which it is safe
|
| +** to pass signed char values.
|
| +*/
|
| +#ifdef sqlite3Isdigit
|
| + /* Use the SQLite core versions if this routine is part of the
|
| + ** SQLite amalgamation */
|
| +# define safe_isdigit(x) sqlite3Isdigit(x)
|
| +# define safe_isalnum(x) sqlite3Isalnum(x)
|
| +# define safe_isxdigit(x) sqlite3Isxdigit(x)
|
| +#else
|
| + /* Use the standard library for separate compilation */
|
| +#include <ctype.h> /* amalgamator: keep */
|
| +# define safe_isdigit(x) isdigit((unsigned char)(x))
|
| +# define safe_isalnum(x) isalnum((unsigned char)(x))
|
| +# define safe_isxdigit(x) isxdigit((unsigned char)(x))
|
| +#endif
|
| +
|
| +/*
|
| +** Growing our own isspace() routine this way is twice as fast as
|
| +** the library isspace() function, resulting in a 7% overall performance
|
| +** increase for the parser. (Ubuntu14.10 gcc 4.8.4 x64 with -Os).
|
| +*/
|
| +static const char jsonIsSpace[] = {
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
| +};
|
| +#define safe_isspace(x) (jsonIsSpace[(unsigned char)x])
|
| +
|
| +#ifndef SQLITE_AMALGAMATION
|
| + /* Unsigned integer types. These are already defined in the sqliteInt.h,
|
| + ** but the definitions need to be repeated for separate compilation. */
|
| + typedef sqlite3_uint64 u64;
|
| + typedef unsigned int u32;
|
| + typedef unsigned char u8;
|
| +#endif
|
| +
|
| +/* Objects */
|
| +typedef struct JsonString JsonString;
|
| +typedef struct JsonNode JsonNode;
|
| +typedef struct JsonParse JsonParse;
|
| +
|
| +/* An instance of this object represents a JSON string
|
| +** under construction. Really, this is a generic string accumulator
|
| +** that can be and is used to create strings other than JSON.
|
| +*/
|
| +struct JsonString {
|
| + sqlite3_context *pCtx; /* Function context - put error messages here */
|
| + char *zBuf; /* Append JSON content here */
|
| + u64 nAlloc; /* Bytes of storage available in zBuf[] */
|
| + u64 nUsed; /* Bytes of zBuf[] currently used */
|
| + u8 bStatic; /* True if zBuf is static space */
|
| + u8 bErr; /* True if an error has been encountered */
|
| + char zSpace[100]; /* Initial static space */
|
| +};
|
| +
|
| +/* JSON type values
|
| +*/
|
| +#define JSON_NULL 0
|
| +#define JSON_TRUE 1
|
| +#define JSON_FALSE 2
|
| +#define JSON_INT 3
|
| +#define JSON_REAL 4
|
| +#define JSON_STRING 5
|
| +#define JSON_ARRAY 6
|
| +#define JSON_OBJECT 7
|
| +
|
| +/* The "subtype" set for JSON values */
|
| +#define JSON_SUBTYPE 74 /* Ascii for "J" */
|
| +
|
| +/*
|
| +** Names of the various JSON types:
|
| +*/
|
| +static const char * const jsonType[] = {
|
| + "null", "true", "false", "integer", "real", "text", "array", "object"
|
| +};
|
| +
|
| +/* Bit values for the JsonNode.jnFlag field
|
| +*/
|
| +#define JNODE_RAW 0x01 /* Content is raw, not JSON encoded */
|
| +#define JNODE_ESCAPE 0x02 /* Content is text with \ escapes */
|
| +#define JNODE_REMOVE 0x04 /* Do not output */
|
| +#define JNODE_REPLACE 0x08 /* Replace with JsonNode.iVal */
|
| +#define JNODE_APPEND 0x10 /* More ARRAY/OBJECT entries at u.iAppend */
|
| +#define JNODE_LABEL 0x20 /* Is a label of an object */
|
| +
|
| +
|
| +/* A single node of parsed JSON
|
| +*/
|
| +struct JsonNode {
|
| + u8 eType; /* One of the JSON_ type values */
|
| + u8 jnFlags; /* JNODE flags */
|
| + u8 iVal; /* Replacement value when JNODE_REPLACE */
|
| + u32 n; /* Bytes of content, or number of sub-nodes */
|
| + union {
|
| + const char *zJContent; /* Content for INT, REAL, and STRING */
|
| + u32 iAppend; /* More terms for ARRAY and OBJECT */
|
| + u32 iKey; /* Key for ARRAY objects in json_tree() */
|
| + } u;
|
| +};
|
| +
|
| +/* A completely parsed JSON string
|
| +*/
|
| +struct JsonParse {
|
| + u32 nNode; /* Number of slots of aNode[] used */
|
| + u32 nAlloc; /* Number of slots of aNode[] allocated */
|
| + JsonNode *aNode; /* Array of nodes containing the parse */
|
| + const char *zJson; /* Original JSON string */
|
| + u32 *aUp; /* Index of parent of each node */
|
| + u8 oom; /* Set to true if out of memory */
|
| + u8 nErr; /* Number of errors seen */
|
| +};
|
| +
|
| +/**************************************************************************
|
| +** Utility routines for dealing with JsonString objects
|
| +**************************************************************************/
|
| +
|
| +/* Set the JsonString object to an empty string
|
| +*/
|
| +static void jsonZero(JsonString *p){
|
| + p->zBuf = p->zSpace;
|
| + p->nAlloc = sizeof(p->zSpace);
|
| + p->nUsed = 0;
|
| + p->bStatic = 1;
|
| +}
|
| +
|
| +/* Initialize the JsonString object
|
| +*/
|
| +static void jsonInit(JsonString *p, sqlite3_context *pCtx){
|
| + p->pCtx = pCtx;
|
| + p->bErr = 0;
|
| + jsonZero(p);
|
| +}
|
| +
|
| +
|
| +/* Free all allocated memory and reset the JsonString object back to its
|
| +** initial state.
|
| +*/
|
| +static void jsonReset(JsonString *p){
|
| + if( !p->bStatic ) sqlite3_free(p->zBuf);
|
| + jsonZero(p);
|
| +}
|
| +
|
| +
|
| +/* Report an out-of-memory (OOM) condition
|
| +*/
|
| +static void jsonOom(JsonString *p){
|
| + p->bErr = 1;
|
| + sqlite3_result_error_nomem(p->pCtx);
|
| + jsonReset(p);
|
| +}
|
| +
|
| +/* Enlarge pJson->zBuf so that it can hold at least N more bytes.
|
| +** Return zero on success. Return non-zero on an OOM error
|
| +*/
|
| +static int jsonGrow(JsonString *p, u32 N){
|
| + u64 nTotal = N<p->nAlloc ? p->nAlloc*2 : p->nAlloc+N+10;
|
| + char *zNew;
|
| + if( p->bStatic ){
|
| + if( p->bErr ) return 1;
|
| + zNew = sqlite3_malloc64(nTotal);
|
| + if( zNew==0 ){
|
| + jsonOom(p);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + memcpy(zNew, p->zBuf, (size_t)p->nUsed);
|
| + p->zBuf = zNew;
|
| + p->bStatic = 0;
|
| + }else{
|
| + zNew = sqlite3_realloc64(p->zBuf, nTotal);
|
| + if( zNew==0 ){
|
| + jsonOom(p);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + p->zBuf = zNew;
|
| + }
|
| + p->nAlloc = nTotal;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* Append N bytes from zIn onto the end of the JsonString string.
|
| +*/
|
| +static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){
|
| + if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return;
|
| + memcpy(p->zBuf+p->nUsed, zIn, N);
|
| + p->nUsed += N;
|
| +}
|
| +
|
| +/* Append formatted text (not to exceed N bytes) to the JsonString.
|
| +*/
|
| +static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){
|
| + va_list ap;
|
| + if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return;
|
| + va_start(ap, zFormat);
|
| + sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap);
|
| + va_end(ap);
|
| + p->nUsed += (int)strlen(p->zBuf+p->nUsed);
|
| +}
|
| +
|
| +/* Append a single character
|
| +*/
|
| +static void jsonAppendChar(JsonString *p, char c){
|
| + if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return;
|
| + p->zBuf[p->nUsed++] = c;
|
| +}
|
| +
|
| +/* Append a comma separator to the output buffer, if the previous
|
| +** character is not '[' or '{'.
|
| +*/
|
| +static void jsonAppendSeparator(JsonString *p){
|
| + char c;
|
| + if( p->nUsed==0 ) return;
|
| + c = p->zBuf[p->nUsed-1];
|
| + if( c!='[' && c!='{' ) jsonAppendChar(p, ',');
|
| +}
|
| +
|
| +/* Append the N-byte string in zIn to the end of the JsonString string
|
| +** under construction. Enclose the string in "..." and escape
|
| +** any double-quotes or backslash characters contained within the
|
| +** string.
|
| +*/
|
| +static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
|
| + u32 i;
|
| + if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return;
|
| + p->zBuf[p->nUsed++] = '"';
|
| + for(i=0; i<N; i++){
|
| + unsigned char c = ((unsigned const char*)zIn)[i];
|
| + if( c=='"' || c=='\\' ){
|
| + json_simple_escape:
|
| + if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return;
|
| + p->zBuf[p->nUsed++] = '\\';
|
| + }else if( c<=0x1f ){
|
| + static const char aSpecial[] = {
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
|
| + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
| + };
|
| + assert( sizeof(aSpecial)==32 );
|
| + assert( aSpecial['\b']=='b' );
|
| + assert( aSpecial['\f']=='f' );
|
| + assert( aSpecial['\n']=='n' );
|
| + assert( aSpecial['\r']=='r' );
|
| + assert( aSpecial['\t']=='t' );
|
| + if( aSpecial[c] ){
|
| + c = aSpecial[c];
|
| + goto json_simple_escape;
|
| + }
|
| + if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return;
|
| + p->zBuf[p->nUsed++] = '\\';
|
| + p->zBuf[p->nUsed++] = 'u';
|
| + p->zBuf[p->nUsed++] = '0';
|
| + p->zBuf[p->nUsed++] = '0';
|
| + p->zBuf[p->nUsed++] = '0' + (c>>4);
|
| + c = "0123456789abcdef"[c&0xf];
|
| + }
|
| + p->zBuf[p->nUsed++] = c;
|
| + }
|
| + p->zBuf[p->nUsed++] = '"';
|
| + assert( p->nUsed<p->nAlloc );
|
| +}
|
| +
|
| +/*
|
| +** Append a function parameter value to the JSON string under
|
| +** construction.
|
| +*/
|
| +static void jsonAppendValue(
|
| + JsonString *p, /* Append to this JSON string */
|
| + sqlite3_value *pValue /* Value to append */
|
| +){
|
| + switch( sqlite3_value_type(pValue) ){
|
| + case SQLITE_NULL: {
|
| + jsonAppendRaw(p, "null", 4);
|
| + break;
|
| + }
|
| + case SQLITE_INTEGER:
|
| + case SQLITE_FLOAT: {
|
| + const char *z = (const char*)sqlite3_value_text(pValue);
|
| + u32 n = (u32)sqlite3_value_bytes(pValue);
|
| + jsonAppendRaw(p, z, n);
|
| + break;
|
| + }
|
| + case SQLITE_TEXT: {
|
| + const char *z = (const char*)sqlite3_value_text(pValue);
|
| + u32 n = (u32)sqlite3_value_bytes(pValue);
|
| + if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){
|
| + jsonAppendRaw(p, z, n);
|
| + }else{
|
| + jsonAppendString(p, z, n);
|
| + }
|
| + break;
|
| + }
|
| + default: {
|
| + if( p->bErr==0 ){
|
| + sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
|
| + p->bErr = 2;
|
| + jsonReset(p);
|
| + }
|
| + break;
|
| + }
|
| + }
|
| +}
|
| +
|
| +
|
| +/* Make the JSON in p the result of the SQL function.
|
| +*/
|
| +static void jsonResult(JsonString *p){
|
| + if( p->bErr==0 ){
|
| + sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
|
| + p->bStatic ? SQLITE_TRANSIENT : sqlite3_free,
|
| + SQLITE_UTF8);
|
| + jsonZero(p);
|
| + }
|
| + assert( p->bStatic );
|
| +}
|
| +
|
| +/**************************************************************************
|
| +** Utility routines for dealing with JsonNode and JsonParse objects
|
| +**************************************************************************/
|
| +
|
| +/*
|
| +** Return the number of consecutive JsonNode slots need to represent
|
| +** the parsed JSON at pNode. The minimum answer is 1. For ARRAY and
|
| +** OBJECT types, the number might be larger.
|
| +**
|
| +** Appended elements are not counted. The value returned is the number
|
| +** by which the JsonNode counter should increment in order to go to the
|
| +** next peer value.
|
| +*/
|
| +static u32 jsonNodeSize(JsonNode *pNode){
|
| + return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1;
|
| +}
|
| +
|
| +/*
|
| +** Reclaim all memory allocated by a JsonParse object. But do not
|
| +** delete the JsonParse object itself.
|
| +*/
|
| +static void jsonParseReset(JsonParse *pParse){
|
| + sqlite3_free(pParse->aNode);
|
| + pParse->aNode = 0;
|
| + pParse->nNode = 0;
|
| + pParse->nAlloc = 0;
|
| + sqlite3_free(pParse->aUp);
|
| + pParse->aUp = 0;
|
| +}
|
| +
|
| +/*
|
| +** Convert the JsonNode pNode into a pure JSON string and
|
| +** append to pOut. Subsubstructure is also included. Return
|
| +** the number of JsonNode objects that are encoded.
|
| +*/
|
| +static void jsonRenderNode(
|
| + JsonNode *pNode, /* The node to render */
|
| + JsonString *pOut, /* Write JSON here */
|
| + sqlite3_value **aReplace /* Replacement values */
|
| +){
|
| + switch( pNode->eType ){
|
| + default: {
|
| + assert( pNode->eType==JSON_NULL );
|
| + jsonAppendRaw(pOut, "null", 4);
|
| + break;
|
| + }
|
| + case JSON_TRUE: {
|
| + jsonAppendRaw(pOut, "true", 4);
|
| + break;
|
| + }
|
| + case JSON_FALSE: {
|
| + jsonAppendRaw(pOut, "false", 5);
|
| + break;
|
| + }
|
| + case JSON_STRING: {
|
| + if( pNode->jnFlags & JNODE_RAW ){
|
| + jsonAppendString(pOut, pNode->u.zJContent, pNode->n);
|
| + break;
|
| + }
|
| + /* Fall through into the next case */
|
| + }
|
| + case JSON_REAL:
|
| + case JSON_INT: {
|
| + jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n);
|
| + break;
|
| + }
|
| + case JSON_ARRAY: {
|
| + u32 j = 1;
|
| + jsonAppendChar(pOut, '[');
|
| + for(;;){
|
| + while( j<=pNode->n ){
|
| + if( pNode[j].jnFlags & (JNODE_REMOVE|JNODE_REPLACE) ){
|
| + if( pNode[j].jnFlags & JNODE_REPLACE ){
|
| + jsonAppendSeparator(pOut);
|
| + jsonAppendValue(pOut, aReplace[pNode[j].iVal]);
|
| + }
|
| + }else{
|
| + jsonAppendSeparator(pOut);
|
| + jsonRenderNode(&pNode[j], pOut, aReplace);
|
| + }
|
| + j += jsonNodeSize(&pNode[j]);
|
| + }
|
| + if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
|
| + pNode = &pNode[pNode->u.iAppend];
|
| + j = 1;
|
| + }
|
| + jsonAppendChar(pOut, ']');
|
| + break;
|
| + }
|
| + case JSON_OBJECT: {
|
| + u32 j = 1;
|
| + jsonAppendChar(pOut, '{');
|
| + for(;;){
|
| + while( j<=pNode->n ){
|
| + if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){
|
| + jsonAppendSeparator(pOut);
|
| + jsonRenderNode(&pNode[j], pOut, aReplace);
|
| + jsonAppendChar(pOut, ':');
|
| + if( pNode[j+1].jnFlags & JNODE_REPLACE ){
|
| + jsonAppendValue(pOut, aReplace[pNode[j+1].iVal]);
|
| + }else{
|
| + jsonRenderNode(&pNode[j+1], pOut, aReplace);
|
| + }
|
| + }
|
| + j += 1 + jsonNodeSize(&pNode[j+1]);
|
| + }
|
| + if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
|
| + pNode = &pNode[pNode->u.iAppend];
|
| + j = 1;
|
| + }
|
| + jsonAppendChar(pOut, '}');
|
| + break;
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Return a JsonNode and all its descendents as a JSON string.
|
| +*/
|
| +static void jsonReturnJson(
|
| + JsonNode *pNode, /* Node to return */
|
| + sqlite3_context *pCtx, /* Return value for this function */
|
| + sqlite3_value **aReplace /* Array of replacement values */
|
| +){
|
| + JsonString s;
|
| + jsonInit(&s, pCtx);
|
| + jsonRenderNode(pNode, &s, aReplace);
|
| + jsonResult(&s);
|
| + sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
|
| +}
|
| +
|
| +/*
|
| +** Make the JsonNode the return value of the function.
|
| +*/
|
| +static void jsonReturn(
|
| + JsonNode *pNode, /* Node to return */
|
| + sqlite3_context *pCtx, /* Return value for this function */
|
| + sqlite3_value **aReplace /* Array of replacement values */
|
| +){
|
| + switch( pNode->eType ){
|
| + default: {
|
| + assert( pNode->eType==JSON_NULL );
|
| + sqlite3_result_null(pCtx);
|
| + break;
|
| + }
|
| + case JSON_TRUE: {
|
| + sqlite3_result_int(pCtx, 1);
|
| + break;
|
| + }
|
| + case JSON_FALSE: {
|
| + sqlite3_result_int(pCtx, 0);
|
| + break;
|
| + }
|
| + case JSON_INT: {
|
| + sqlite3_int64 i = 0;
|
| + const char *z = pNode->u.zJContent;
|
| + if( z[0]=='-' ){ z++; }
|
| + while( z[0]>='0' && z[0]<='9' ){
|
| + unsigned v = *(z++) - '0';
|
| + if( i>=LARGEST_INT64/10 ){
|
| + if( i>LARGEST_INT64/10 ) goto int_as_real;
|
| + if( z[0]>='0' && z[0]<='9' ) goto int_as_real;
|
| + if( v==9 ) goto int_as_real;
|
| + if( v==8 ){
|
| + if( pNode->u.zJContent[0]=='-' ){
|
| + sqlite3_result_int64(pCtx, SMALLEST_INT64);
|
| + goto int_done;
|
| + }else{
|
| + goto int_as_real;
|
| + }
|
| + }
|
| + }
|
| + i = i*10 + v;
|
| + }
|
| + if( pNode->u.zJContent[0]=='-' ){ i = -i; }
|
| + sqlite3_result_int64(pCtx, i);
|
| + int_done:
|
| + break;
|
| + int_as_real: /* fall through to real */;
|
| + }
|
| + case JSON_REAL: {
|
| + double r;
|
| +#ifdef SQLITE_AMALGAMATION
|
| + const char *z = pNode->u.zJContent;
|
| + sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8);
|
| +#else
|
| + r = strtod(pNode->u.zJContent, 0);
|
| +#endif
|
| + sqlite3_result_double(pCtx, r);
|
| + break;
|
| + }
|
| + case JSON_STRING: {
|
| +#if 0 /* Never happens because JNODE_RAW is only set by json_set(),
|
| + ** json_insert() and json_replace() and those routines do not
|
| + ** call jsonReturn() */
|
| + if( pNode->jnFlags & JNODE_RAW ){
|
| + sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
|
| + SQLITE_TRANSIENT);
|
| + }else
|
| +#endif
|
| + assert( (pNode->jnFlags & JNODE_RAW)==0 );
|
| + if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){
|
| + /* JSON formatted without any backslash-escapes */
|
| + sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
|
| + SQLITE_TRANSIENT);
|
| + }else{
|
| + /* Translate JSON formatted string into raw text */
|
| + u32 i;
|
| + u32 n = pNode->n;
|
| + const char *z = pNode->u.zJContent;
|
| + char *zOut;
|
| + u32 j;
|
| + zOut = sqlite3_malloc( n+1 );
|
| + if( zOut==0 ){
|
| + sqlite3_result_error_nomem(pCtx);
|
| + break;
|
| + }
|
| + for(i=1, j=0; i<n-1; i++){
|
| + char c = z[i];
|
| + if( c!='\\' ){
|
| + zOut[j++] = c;
|
| + }else{
|
| + c = z[++i];
|
| + if( c=='u' ){
|
| + u32 v = 0, k;
|
| + for(k=0; k<4; i++, k++){
|
| + assert( i<n-2 );
|
| + c = z[i+1];
|
| + assert( safe_isxdigit(c) );
|
| + if( c<='9' ) v = v*16 + c - '0';
|
| + else if( c<='F' ) v = v*16 + c - 'A' + 10;
|
| + else v = v*16 + c - 'a' + 10;
|
| + }
|
| + if( v==0 ) break;
|
| + if( v<=0x7f ){
|
| + zOut[j++] = (char)v;
|
| + }else if( v<=0x7ff ){
|
| + zOut[j++] = (char)(0xc0 | (v>>6));
|
| + zOut[j++] = 0x80 | (v&0x3f);
|
| + }else{
|
| + zOut[j++] = (char)(0xe0 | (v>>12));
|
| + zOut[j++] = 0x80 | ((v>>6)&0x3f);
|
| + zOut[j++] = 0x80 | (v&0x3f);
|
| + }
|
| + }else{
|
| + if( c=='b' ){
|
| + c = '\b';
|
| + }else if( c=='f' ){
|
| + c = '\f';
|
| + }else if( c=='n' ){
|
| + c = '\n';
|
| + }else if( c=='r' ){
|
| + c = '\r';
|
| + }else if( c=='t' ){
|
| + c = '\t';
|
| + }
|
| + zOut[j++] = c;
|
| + }
|
| + }
|
| + }
|
| + zOut[j] = 0;
|
| + sqlite3_result_text(pCtx, zOut, j, sqlite3_free);
|
| + }
|
| + break;
|
| + }
|
| + case JSON_ARRAY:
|
| + case JSON_OBJECT: {
|
| + jsonReturnJson(pNode, pCtx, aReplace);
|
| + break;
|
| + }
|
| + }
|
| +}
|
| +
|
| +/* Forward reference */
|
| +static int jsonParseAddNode(JsonParse*,u32,u32,const char*);
|
| +
|
| +/*
|
| +** A macro to hint to the compiler that a function should not be
|
| +** inlined.
|
| +*/
|
| +#if defined(__GNUC__)
|
| +# define JSON_NOINLINE __attribute__((noinline))
|
| +#elif defined(_MSC_VER) && _MSC_VER>=1310
|
| +# define JSON_NOINLINE __declspec(noinline)
|
| +#else
|
| +# define JSON_NOINLINE
|
| +#endif
|
| +
|
| +
|
| +static JSON_NOINLINE int jsonParseAddNodeExpand(
|
| + JsonParse *pParse, /* Append the node to this object */
|
| + u32 eType, /* Node type */
|
| + u32 n, /* Content size or sub-node count */
|
| + const char *zContent /* Content */
|
| +){
|
| + u32 nNew;
|
| + JsonNode *pNew;
|
| + assert( pParse->nNode>=pParse->nAlloc );
|
| + if( pParse->oom ) return -1;
|
| + nNew = pParse->nAlloc*2 + 10;
|
| + pNew = sqlite3_realloc(pParse->aNode, sizeof(JsonNode)*nNew);
|
| + if( pNew==0 ){
|
| + pParse->oom = 1;
|
| + return -1;
|
| + }
|
| + pParse->nAlloc = nNew;
|
| + pParse->aNode = pNew;
|
| + assert( pParse->nNode<pParse->nAlloc );
|
| + return jsonParseAddNode(pParse, eType, n, zContent);
|
| +}
|
| +
|
| +/*
|
| +** Create a new JsonNode instance based on the arguments and append that
|
| +** instance to the JsonParse. Return the index in pParse->aNode[] of the
|
| +** new node, or -1 if a memory allocation fails.
|
| +*/
|
| +static int jsonParseAddNode(
|
| + JsonParse *pParse, /* Append the node to this object */
|
| + u32 eType, /* Node type */
|
| + u32 n, /* Content size or sub-node count */
|
| + const char *zContent /* Content */
|
| +){
|
| + JsonNode *p;
|
| + if( pParse->nNode>=pParse->nAlloc ){
|
| + return jsonParseAddNodeExpand(pParse, eType, n, zContent);
|
| + }
|
| + p = &pParse->aNode[pParse->nNode];
|
| + p->eType = (u8)eType;
|
| + p->jnFlags = 0;
|
| + p->iVal = 0;
|
| + p->n = n;
|
| + p->u.zJContent = zContent;
|
| + return pParse->nNode++;
|
| +}
|
| +
|
| +/*
|
| +** Return true if z[] begins with 4 (or more) hexadecimal digits
|
| +*/
|
| +static int jsonIs4Hex(const char *z){
|
| + int i;
|
| + for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0;
|
| + return 1;
|
| +}
|
| +
|
| +/*
|
| +** Parse a single JSON value which begins at pParse->zJson[i]. Return the
|
| +** index of the first character past the end of the value parsed.
|
| +**
|
| +** Return negative for a syntax error. Special cases: return -2 if the
|
| +** first non-whitespace character is '}' and return -3 if the first
|
| +** non-whitespace character is ']'.
|
| +*/
|
| +static int jsonParseValue(JsonParse *pParse, u32 i){
|
| + char c;
|
| + u32 j;
|
| + int iThis;
|
| + int x;
|
| + JsonNode *pNode;
|
| + while( safe_isspace(pParse->zJson[i]) ){ i++; }
|
| + if( (c = pParse->zJson[i])=='{' ){
|
| + /* Parse object */
|
| + iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0);
|
| + if( iThis<0 ) return -1;
|
| + for(j=i+1;;j++){
|
| + while( safe_isspace(pParse->zJson[j]) ){ j++; }
|
| + x = jsonParseValue(pParse, j);
|
| + if( x<0 ){
|
| + if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1;
|
| + return -1;
|
| + }
|
| + if( pParse->oom ) return -1;
|
| + pNode = &pParse->aNode[pParse->nNode-1];
|
| + if( pNode->eType!=JSON_STRING ) return -1;
|
| + pNode->jnFlags |= JNODE_LABEL;
|
| + j = x;
|
| + while( safe_isspace(pParse->zJson[j]) ){ j++; }
|
| + if( pParse->zJson[j]!=':' ) return -1;
|
| + j++;
|
| + x = jsonParseValue(pParse, j);
|
| + if( x<0 ) return -1;
|
| + j = x;
|
| + while( safe_isspace(pParse->zJson[j]) ){ j++; }
|
| + c = pParse->zJson[j];
|
| + if( c==',' ) continue;
|
| + if( c!='}' ) return -1;
|
| + break;
|
| + }
|
| + pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1;
|
| + return j+1;
|
| + }else if( c=='[' ){
|
| + /* Parse array */
|
| + iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
|
| + if( iThis<0 ) return -1;
|
| + for(j=i+1;;j++){
|
| + while( safe_isspace(pParse->zJson[j]) ){ j++; }
|
| + x = jsonParseValue(pParse, j);
|
| + if( x<0 ){
|
| + if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1;
|
| + return -1;
|
| + }
|
| + j = x;
|
| + while( safe_isspace(pParse->zJson[j]) ){ j++; }
|
| + c = pParse->zJson[j];
|
| + if( c==',' ) continue;
|
| + if( c!=']' ) return -1;
|
| + break;
|
| + }
|
| + pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1;
|
| + return j+1;
|
| + }else if( c=='"' ){
|
| + /* Parse string */
|
| + u8 jnFlags = 0;
|
| + j = i+1;
|
| + for(;;){
|
| + c = pParse->zJson[j];
|
| + if( c==0 ) return -1;
|
| + if( c=='\\' ){
|
| + c = pParse->zJson[++j];
|
| + if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f'
|
| + || c=='n' || c=='r' || c=='t'
|
| + || (c=='u' && jsonIs4Hex(pParse->zJson+j+1)) ){
|
| + jnFlags = JNODE_ESCAPE;
|
| + }else{
|
| + return -1;
|
| + }
|
| + }else if( c=='"' ){
|
| + break;
|
| + }
|
| + j++;
|
| + }
|
| + jsonParseAddNode(pParse, JSON_STRING, j+1-i, &pParse->zJson[i]);
|
| + if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags;
|
| + return j+1;
|
| + }else if( c=='n'
|
| + && strncmp(pParse->zJson+i,"null",4)==0
|
| + && !safe_isalnum(pParse->zJson[i+4]) ){
|
| + jsonParseAddNode(pParse, JSON_NULL, 0, 0);
|
| + return i+4;
|
| + }else if( c=='t'
|
| + && strncmp(pParse->zJson+i,"true",4)==0
|
| + && !safe_isalnum(pParse->zJson[i+4]) ){
|
| + jsonParseAddNode(pParse, JSON_TRUE, 0, 0);
|
| + return i+4;
|
| + }else if( c=='f'
|
| + && strncmp(pParse->zJson+i,"false",5)==0
|
| + && !safe_isalnum(pParse->zJson[i+5]) ){
|
| + jsonParseAddNode(pParse, JSON_FALSE, 0, 0);
|
| + return i+5;
|
| + }else if( c=='-' || (c>='0' && c<='9') ){
|
| + /* Parse number */
|
| + u8 seenDP = 0;
|
| + u8 seenE = 0;
|
| + j = i+1;
|
| + for(;; j++){
|
| + c = pParse->zJson[j];
|
| + if( c>='0' && c<='9' ) continue;
|
| + if( c=='.' ){
|
| + if( pParse->zJson[j-1]=='-' ) return -1;
|
| + if( seenDP ) return -1;
|
| + seenDP = 1;
|
| + continue;
|
| + }
|
| + if( c=='e' || c=='E' ){
|
| + if( pParse->zJson[j-1]<'0' ) return -1;
|
| + if( seenE ) return -1;
|
| + seenDP = seenE = 1;
|
| + c = pParse->zJson[j+1];
|
| + if( c=='+' || c=='-' ){
|
| + j++;
|
| + c = pParse->zJson[j+1];
|
| + }
|
| + if( c<'0' || c>'9' ) return -1;
|
| + continue;
|
| + }
|
| + break;
|
| + }
|
| + if( pParse->zJson[j-1]<'0' ) return -1;
|
| + jsonParseAddNode(pParse, seenDP ? JSON_REAL : JSON_INT,
|
| + j - i, &pParse->zJson[i]);
|
| + return j;
|
| + }else if( c=='}' ){
|
| + return -2; /* End of {...} */
|
| + }else if( c==']' ){
|
| + return -3; /* End of [...] */
|
| + }else if( c==0 ){
|
| + return 0; /* End of file */
|
| + }else{
|
| + return -1; /* Syntax error */
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Parse a complete JSON string. Return 0 on success or non-zero if there
|
| +** are any errors. If an error occurs, free all memory associated with
|
| +** pParse.
|
| +**
|
| +** pParse is uninitialized when this routine is called.
|
| +*/
|
| +static int jsonParse(
|
| + JsonParse *pParse, /* Initialize and fill this JsonParse object */
|
| + sqlite3_context *pCtx, /* Report errors here */
|
| + const char *zJson /* Input JSON text to be parsed */
|
| +){
|
| + int i;
|
| + memset(pParse, 0, sizeof(*pParse));
|
| + if( zJson==0 ) return 1;
|
| + pParse->zJson = zJson;
|
| + i = jsonParseValue(pParse, 0);
|
| + if( pParse->oom ) i = -1;
|
| + if( i>0 ){
|
| + while( safe_isspace(zJson[i]) ) i++;
|
| + if( zJson[i] ) i = -1;
|
| + }
|
| + if( i<=0 ){
|
| + if( pCtx!=0 ){
|
| + if( pParse->oom ){
|
| + sqlite3_result_error_nomem(pCtx);
|
| + }else{
|
| + sqlite3_result_error(pCtx, "malformed JSON", -1);
|
| + }
|
| + }
|
| + jsonParseReset(pParse);
|
| + return 1;
|
| + }
|
| + return 0;
|
| +}
|
| +
|
| +/* Mark node i of pParse as being a child of iParent. Call recursively
|
| +** to fill in all the descendants of node i.
|
| +*/
|
| +static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){
|
| + JsonNode *pNode = &pParse->aNode[i];
|
| + u32 j;
|
| + pParse->aUp[i] = iParent;
|
| + switch( pNode->eType ){
|
| + case JSON_ARRAY: {
|
| + for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){
|
| + jsonParseFillInParentage(pParse, i+j, i);
|
| + }
|
| + break;
|
| + }
|
| + case JSON_OBJECT: {
|
| + for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){
|
| + pParse->aUp[i+j] = i;
|
| + jsonParseFillInParentage(pParse, i+j+1, i);
|
| + }
|
| + break;
|
| + }
|
| + default: {
|
| + break;
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Compute the parentage of all nodes in a completed parse.
|
| +*/
|
| +static int jsonParseFindParents(JsonParse *pParse){
|
| + u32 *aUp;
|
| + assert( pParse->aUp==0 );
|
| + aUp = pParse->aUp = sqlite3_malloc( sizeof(u32)*pParse->nNode );
|
| + if( aUp==0 ){
|
| + pParse->oom = 1;
|
| + return SQLITE_NOMEM;
|
| + }
|
| + jsonParseFillInParentage(pParse, 0, 0);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Compare the OBJECT label at pNode against zKey,nKey. Return true on
|
| +** a match.
|
| +*/
|
| +static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){
|
| + if( pNode->jnFlags & JNODE_RAW ){
|
| + if( pNode->n!=nKey ) return 0;
|
| + return strncmp(pNode->u.zJContent, zKey, nKey)==0;
|
| + }else{
|
| + if( pNode->n!=nKey+2 ) return 0;
|
| + return strncmp(pNode->u.zJContent+1, zKey, nKey)==0;
|
| + }
|
| +}
|
| +
|
| +/* forward declaration */
|
| +static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**);
|
| +
|
| +/*
|
| +** Search along zPath to find the node specified. Return a pointer
|
| +** to that node, or NULL if zPath is malformed or if there is no such
|
| +** node.
|
| +**
|
| +** If pApnd!=0, then try to append new nodes to complete zPath if it is
|
| +** possible to do so and if no existing node corresponds to zPath. If
|
| +** new nodes are appended *pApnd is set to 1.
|
| +*/
|
| +static JsonNode *jsonLookupStep(
|
| + JsonParse *pParse, /* The JSON to search */
|
| + u32 iRoot, /* Begin the search at this node */
|
| + const char *zPath, /* The path to search */
|
| + int *pApnd, /* Append nodes to complete path if not NULL */
|
| + const char **pzErr /* Make *pzErr point to any syntax error in zPath */
|
| +){
|
| + u32 i, j, nKey;
|
| + const char *zKey;
|
| + JsonNode *pRoot = &pParse->aNode[iRoot];
|
| + if( zPath[0]==0 ) return pRoot;
|
| + if( zPath[0]=='.' ){
|
| + if( pRoot->eType!=JSON_OBJECT ) return 0;
|
| + zPath++;
|
| + if( zPath[0]=='"' ){
|
| + zKey = zPath + 1;
|
| + for(i=1; zPath[i] && zPath[i]!='"'; i++){}
|
| + nKey = i-1;
|
| + if( zPath[i] ){
|
| + i++;
|
| + }else{
|
| + *pzErr = zPath;
|
| + return 0;
|
| + }
|
| + }else{
|
| + zKey = zPath;
|
| + for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){}
|
| + nKey = i;
|
| + }
|
| + if( nKey==0 ){
|
| + *pzErr = zPath;
|
| + return 0;
|
| + }
|
| + j = 1;
|
| + for(;;){
|
| + while( j<=pRoot->n ){
|
| + if( jsonLabelCompare(pRoot+j, zKey, nKey) ){
|
| + return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr);
|
| + }
|
| + j++;
|
| + j += jsonNodeSize(&pRoot[j]);
|
| + }
|
| + if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
|
| + iRoot += pRoot->u.iAppend;
|
| + pRoot = &pParse->aNode[iRoot];
|
| + j = 1;
|
| + }
|
| + if( pApnd ){
|
| + u32 iStart, iLabel;
|
| + JsonNode *pNode;
|
| + iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0);
|
| + iLabel = jsonParseAddNode(pParse, JSON_STRING, i, zPath);
|
| + zPath += i;
|
| + pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
|
| + if( pParse->oom ) return 0;
|
| + if( pNode ){
|
| + pRoot = &pParse->aNode[iRoot];
|
| + pRoot->u.iAppend = iStart - iRoot;
|
| + pRoot->jnFlags |= JNODE_APPEND;
|
| + pParse->aNode[iLabel].jnFlags |= JNODE_RAW;
|
| + }
|
| + return pNode;
|
| + }
|
| + }else if( zPath[0]=='[' && safe_isdigit(zPath[1]) ){
|
| + if( pRoot->eType!=JSON_ARRAY ) return 0;
|
| + i = 0;
|
| + j = 1;
|
| + while( safe_isdigit(zPath[j]) ){
|
| + i = i*10 + zPath[j] - '0';
|
| + j++;
|
| + }
|
| + if( zPath[j]!=']' ){
|
| + *pzErr = zPath;
|
| + return 0;
|
| + }
|
| + zPath += j + 1;
|
| + j = 1;
|
| + for(;;){
|
| + while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){
|
| + if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--;
|
| + j += jsonNodeSize(&pRoot[j]);
|
| + }
|
| + if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
|
| + iRoot += pRoot->u.iAppend;
|
| + pRoot = &pParse->aNode[iRoot];
|
| + j = 1;
|
| + }
|
| + if( j<=pRoot->n ){
|
| + return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr);
|
| + }
|
| + if( i==0 && pApnd ){
|
| + u32 iStart;
|
| + JsonNode *pNode;
|
| + iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0);
|
| + pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
|
| + if( pParse->oom ) return 0;
|
| + if( pNode ){
|
| + pRoot = &pParse->aNode[iRoot];
|
| + pRoot->u.iAppend = iStart - iRoot;
|
| + pRoot->jnFlags |= JNODE_APPEND;
|
| + }
|
| + return pNode;
|
| + }
|
| + }else{
|
| + *pzErr = zPath;
|
| + }
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Append content to pParse that will complete zPath. Return a pointer
|
| +** to the inserted node, or return NULL if the append fails.
|
| +*/
|
| +static JsonNode *jsonLookupAppend(
|
| + JsonParse *pParse, /* Append content to the JSON parse */
|
| + const char *zPath, /* Description of content to append */
|
| + int *pApnd, /* Set this flag to 1 */
|
| + const char **pzErr /* Make this point to any syntax error */
|
| +){
|
| + *pApnd = 1;
|
| + if( zPath[0]==0 ){
|
| + jsonParseAddNode(pParse, JSON_NULL, 0, 0);
|
| + return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1];
|
| + }
|
| + if( zPath[0]=='.' ){
|
| + jsonParseAddNode(pParse, JSON_OBJECT, 0, 0);
|
| + }else if( strncmp(zPath,"[0]",3)==0 ){
|
| + jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
|
| + }else{
|
| + return 0;
|
| + }
|
| + if( pParse->oom ) return 0;
|
| + return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr);
|
| +}
|
| +
|
| +/*
|
| +** Return the text of a syntax error message on a JSON path. Space is
|
| +** obtained from sqlite3_malloc().
|
| +*/
|
| +static char *jsonPathSyntaxError(const char *zErr){
|
| + return sqlite3_mprintf("JSON path error near '%q'", zErr);
|
| +}
|
| +
|
| +/*
|
| +** Do a node lookup using zPath. Return a pointer to the node on success.
|
| +** Return NULL if not found or if there is an error.
|
| +**
|
| +** On an error, write an error message into pCtx and increment the
|
| +** pParse->nErr counter.
|
| +**
|
| +** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if
|
| +** nodes are appended.
|
| +*/
|
| +static JsonNode *jsonLookup(
|
| + JsonParse *pParse, /* The JSON to search */
|
| + const char *zPath, /* The path to search */
|
| + int *pApnd, /* Append nodes to complete path if not NULL */
|
| + sqlite3_context *pCtx /* Report errors here, if not NULL */
|
| +){
|
| + const char *zErr = 0;
|
| + JsonNode *pNode = 0;
|
| + char *zMsg;
|
| +
|
| + if( zPath==0 ) return 0;
|
| + if( zPath[0]!='$' ){
|
| + zErr = zPath;
|
| + goto lookup_err;
|
| + }
|
| + zPath++;
|
| + pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr);
|
| + if( zErr==0 ) return pNode;
|
| +
|
| +lookup_err:
|
| + pParse->nErr++;
|
| + assert( zErr!=0 && pCtx!=0 );
|
| + zMsg = jsonPathSyntaxError(zErr);
|
| + if( zMsg ){
|
| + sqlite3_result_error(pCtx, zMsg, -1);
|
| + sqlite3_free(zMsg);
|
| + }else{
|
| + sqlite3_result_error_nomem(pCtx);
|
| + }
|
| + return 0;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Report the wrong number of arguments for json_insert(), json_replace()
|
| +** or json_set().
|
| +*/
|
| +static void jsonWrongNumArgs(
|
| + sqlite3_context *pCtx,
|
| + const char *zFuncName
|
| +){
|
| + char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments",
|
| + zFuncName);
|
| + sqlite3_result_error(pCtx, zMsg, -1);
|
| + sqlite3_free(zMsg);
|
| +}
|
| +
|
| +
|
| +/****************************************************************************
|
| +** SQL functions used for testing and debugging
|
| +****************************************************************************/
|
| +
|
| +#ifdef SQLITE_DEBUG
|
| +/*
|
| +** The json_parse(JSON) function returns a string which describes
|
| +** a parse of the JSON provided. Or it returns NULL if JSON is not
|
| +** well-formed.
|
| +*/
|
| +static void jsonParseFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonString s; /* Output string - not real JSON */
|
| + JsonParse x; /* The parse */
|
| + u32 i;
|
| +
|
| + assert( argc==1 );
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + jsonParseFindParents(&x);
|
| + jsonInit(&s, ctx);
|
| + for(i=0; i<x.nNode; i++){
|
| + const char *zType;
|
| + if( x.aNode[i].jnFlags & JNODE_LABEL ){
|
| + assert( x.aNode[i].eType==JSON_STRING );
|
| + zType = "label";
|
| + }else{
|
| + zType = jsonType[x.aNode[i].eType];
|
| + }
|
| + jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d",
|
| + i, zType, x.aNode[i].n, x.aUp[i]);
|
| + if( x.aNode[i].u.zJContent!=0 ){
|
| + jsonAppendRaw(&s, " ", 1);
|
| + jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n);
|
| + }
|
| + jsonAppendRaw(&s, "\n", 1);
|
| + }
|
| + jsonParseReset(&x);
|
| + jsonResult(&s);
|
| +}
|
| +
|
| +/*
|
| +** The json_test1(JSON) function return true (1) if the input is JSON
|
| +** text generated by another json function. It returns (0) if the input
|
| +** is not known to be JSON.
|
| +*/
|
| +static void jsonTest1Func(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + UNUSED_PARAM(argc);
|
| + sqlite3_result_int(ctx, sqlite3_value_subtype(argv[0])==JSON_SUBTYPE);
|
| +}
|
| +#endif /* SQLITE_DEBUG */
|
| +
|
| +/****************************************************************************
|
| +** Scalar SQL function implementations
|
| +****************************************************************************/
|
| +
|
| +/*
|
| +** Implementation of the json_QUOTE(VALUE) function. Return a JSON value
|
| +** corresponding to the SQL value input. Mostly this means putting
|
| +** double-quotes around strings and returning the unquoted string "null"
|
| +** when given a NULL input.
|
| +*/
|
| +static void jsonQuoteFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonString jx;
|
| + UNUSED_PARAM(argc);
|
| +
|
| + jsonInit(&jx, ctx);
|
| + jsonAppendValue(&jx, argv[0]);
|
| + jsonResult(&jx);
|
| + sqlite3_result_subtype(ctx, JSON_SUBTYPE);
|
| +}
|
| +
|
| +/*
|
| +** Implementation of the json_array(VALUE,...) function. Return a JSON
|
| +** array that contains all values given in arguments. Or if any argument
|
| +** is a BLOB, throw an error.
|
| +*/
|
| +static void jsonArrayFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + int i;
|
| + JsonString jx;
|
| +
|
| + jsonInit(&jx, ctx);
|
| + jsonAppendChar(&jx, '[');
|
| + for(i=0; i<argc; i++){
|
| + jsonAppendSeparator(&jx);
|
| + jsonAppendValue(&jx, argv[i]);
|
| + }
|
| + jsonAppendChar(&jx, ']');
|
| + jsonResult(&jx);
|
| + sqlite3_result_subtype(ctx, JSON_SUBTYPE);
|
| +}
|
| +
|
| +
|
| +/*
|
| +** json_array_length(JSON)
|
| +** json_array_length(JSON, PATH)
|
| +**
|
| +** Return the number of elements in the top-level JSON array.
|
| +** Return 0 if the input is not a well-formed JSON array.
|
| +*/
|
| +static void jsonArrayLengthFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + sqlite3_int64 n = 0;
|
| + u32 i;
|
| + JsonNode *pNode;
|
| +
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + assert( x.nNode );
|
| + if( argc==2 ){
|
| + const char *zPath = (const char*)sqlite3_value_text(argv[1]);
|
| + pNode = jsonLookup(&x, zPath, 0, ctx);
|
| + }else{
|
| + pNode = x.aNode;
|
| + }
|
| + if( pNode==0 ){
|
| + x.nErr = 1;
|
| + }else if( pNode->eType==JSON_ARRAY ){
|
| + assert( (pNode->jnFlags & JNODE_APPEND)==0 );
|
| + for(i=1; i<=pNode->n; n++){
|
| + i += jsonNodeSize(&pNode[i]);
|
| + }
|
| + }
|
| + if( x.nErr==0 ) sqlite3_result_int64(ctx, n);
|
| + jsonParseReset(&x);
|
| +}
|
| +
|
| +/*
|
| +** json_extract(JSON, PATH, ...)
|
| +**
|
| +** Return the element described by PATH. Return NULL if there is no
|
| +** PATH element. If there are multiple PATHs, then return a JSON array
|
| +** with the result from each path. Throw an error if the JSON or any PATH
|
| +** is malformed.
|
| +*/
|
| +static void jsonExtractFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + JsonNode *pNode;
|
| + const char *zPath;
|
| + JsonString jx;
|
| + int i;
|
| +
|
| + if( argc<2 ) return;
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + jsonInit(&jx, ctx);
|
| + jsonAppendChar(&jx, '[');
|
| + for(i=1; i<argc; i++){
|
| + zPath = (const char*)sqlite3_value_text(argv[i]);
|
| + pNode = jsonLookup(&x, zPath, 0, ctx);
|
| + if( x.nErr ) break;
|
| + if( argc>2 ){
|
| + jsonAppendSeparator(&jx);
|
| + if( pNode ){
|
| + jsonRenderNode(pNode, &jx, 0);
|
| + }else{
|
| + jsonAppendRaw(&jx, "null", 4);
|
| + }
|
| + }else if( pNode ){
|
| + jsonReturn(pNode, ctx, 0);
|
| + }
|
| + }
|
| + if( argc>2 && i==argc ){
|
| + jsonAppendChar(&jx, ']');
|
| + jsonResult(&jx);
|
| + sqlite3_result_subtype(ctx, JSON_SUBTYPE);
|
| + }
|
| + jsonReset(&jx);
|
| + jsonParseReset(&x);
|
| +}
|
| +
|
| +/*
|
| +** Implementation of the json_object(NAME,VALUE,...) function. Return a JSON
|
| +** object that contains all name/value given in arguments. Or if any name
|
| +** is not a string or if any value is a BLOB, throw an error.
|
| +*/
|
| +static void jsonObjectFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + int i;
|
| + JsonString jx;
|
| + const char *z;
|
| + u32 n;
|
| +
|
| + if( argc&1 ){
|
| + sqlite3_result_error(ctx, "json_object() requires an even number "
|
| + "of arguments", -1);
|
| + return;
|
| + }
|
| + jsonInit(&jx, ctx);
|
| + jsonAppendChar(&jx, '{');
|
| + for(i=0; i<argc; i+=2){
|
| + if( sqlite3_value_type(argv[i])!=SQLITE_TEXT ){
|
| + sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1);
|
| + jsonReset(&jx);
|
| + return;
|
| + }
|
| + jsonAppendSeparator(&jx);
|
| + z = (const char*)sqlite3_value_text(argv[i]);
|
| + n = (u32)sqlite3_value_bytes(argv[i]);
|
| + jsonAppendString(&jx, z, n);
|
| + jsonAppendChar(&jx, ':');
|
| + jsonAppendValue(&jx, argv[i+1]);
|
| + }
|
| + jsonAppendChar(&jx, '}');
|
| + jsonResult(&jx);
|
| + sqlite3_result_subtype(ctx, JSON_SUBTYPE);
|
| +}
|
| +
|
| +
|
| +/*
|
| +** json_remove(JSON, PATH, ...)
|
| +**
|
| +** Remove the named elements from JSON and return the result. malformed
|
| +** JSON or PATH arguments result in an error.
|
| +*/
|
| +static void jsonRemoveFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + JsonNode *pNode;
|
| + const char *zPath;
|
| + u32 i;
|
| +
|
| + if( argc<1 ) return;
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + assert( x.nNode );
|
| + for(i=1; i<(u32)argc; i++){
|
| + zPath = (const char*)sqlite3_value_text(argv[i]);
|
| + if( zPath==0 ) goto remove_done;
|
| + pNode = jsonLookup(&x, zPath, 0, ctx);
|
| + if( x.nErr ) goto remove_done;
|
| + if( pNode ) pNode->jnFlags |= JNODE_REMOVE;
|
| + }
|
| + if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){
|
| + jsonReturnJson(x.aNode, ctx, 0);
|
| + }
|
| +remove_done:
|
| + jsonParseReset(&x);
|
| +}
|
| +
|
| +/*
|
| +** json_replace(JSON, PATH, VALUE, ...)
|
| +**
|
| +** Replace the value at PATH with VALUE. If PATH does not already exist,
|
| +** this routine is a no-op. If JSON or PATH is malformed, throw an error.
|
| +*/
|
| +static void jsonReplaceFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + JsonNode *pNode;
|
| + const char *zPath;
|
| + u32 i;
|
| +
|
| + if( argc<1 ) return;
|
| + if( (argc&1)==0 ) {
|
| + jsonWrongNumArgs(ctx, "replace");
|
| + return;
|
| + }
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + assert( x.nNode );
|
| + for(i=1; i<(u32)argc; i+=2){
|
| + zPath = (const char*)sqlite3_value_text(argv[i]);
|
| + pNode = jsonLookup(&x, zPath, 0, ctx);
|
| + if( x.nErr ) goto replace_err;
|
| + if( pNode ){
|
| + pNode->jnFlags |= (u8)JNODE_REPLACE;
|
| + pNode->iVal = (u8)(i+1);
|
| + }
|
| + }
|
| + if( x.aNode[0].jnFlags & JNODE_REPLACE ){
|
| + sqlite3_result_value(ctx, argv[x.aNode[0].iVal]);
|
| + }else{
|
| + jsonReturnJson(x.aNode, ctx, argv);
|
| + }
|
| +replace_err:
|
| + jsonParseReset(&x);
|
| +}
|
| +
|
| +/*
|
| +** json_set(JSON, PATH, VALUE, ...)
|
| +**
|
| +** Set the value at PATH to VALUE. Create the PATH if it does not already
|
| +** exist. Overwrite existing values that do exist.
|
| +** If JSON or PATH is malformed, throw an error.
|
| +**
|
| +** json_insert(JSON, PATH, VALUE, ...)
|
| +**
|
| +** Create PATH and initialize it to VALUE. If PATH already exists, this
|
| +** routine is a no-op. If JSON or PATH is malformed, throw an error.
|
| +*/
|
| +static void jsonSetFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + JsonNode *pNode;
|
| + const char *zPath;
|
| + u32 i;
|
| + int bApnd;
|
| + int bIsSet = *(int*)sqlite3_user_data(ctx);
|
| +
|
| + if( argc<1 ) return;
|
| + if( (argc&1)==0 ) {
|
| + jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert");
|
| + return;
|
| + }
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + assert( x.nNode );
|
| + for(i=1; i<(u32)argc; i+=2){
|
| + zPath = (const char*)sqlite3_value_text(argv[i]);
|
| + bApnd = 0;
|
| + pNode = jsonLookup(&x, zPath, &bApnd, ctx);
|
| + if( x.oom ){
|
| + sqlite3_result_error_nomem(ctx);
|
| + goto jsonSetDone;
|
| + }else if( x.nErr ){
|
| + goto jsonSetDone;
|
| + }else if( pNode && (bApnd || bIsSet) ){
|
| + pNode->jnFlags |= (u8)JNODE_REPLACE;
|
| + pNode->iVal = (u8)(i+1);
|
| + }
|
| + }
|
| + if( x.aNode[0].jnFlags & JNODE_REPLACE ){
|
| + sqlite3_result_value(ctx, argv[x.aNode[0].iVal]);
|
| + }else{
|
| + jsonReturnJson(x.aNode, ctx, argv);
|
| + }
|
| +jsonSetDone:
|
| + jsonParseReset(&x);
|
| +}
|
| +
|
| +/*
|
| +** json_type(JSON)
|
| +** json_type(JSON, PATH)
|
| +**
|
| +** Return the top-level "type" of a JSON string. Throw an error if
|
| +** either the JSON or PATH inputs are not well-formed.
|
| +*/
|
| +static void jsonTypeFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + const char *zPath;
|
| + JsonNode *pNode;
|
| +
|
| + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
|
| + assert( x.nNode );
|
| + if( argc==2 ){
|
| + zPath = (const char*)sqlite3_value_text(argv[1]);
|
| + pNode = jsonLookup(&x, zPath, 0, ctx);
|
| + }else{
|
| + pNode = x.aNode;
|
| + }
|
| + if( pNode ){
|
| + sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC);
|
| + }
|
| + jsonParseReset(&x);
|
| +}
|
| +
|
| +/*
|
| +** json_valid(JSON)
|
| +**
|
| +** Return 1 if JSON is a well-formed JSON string according to RFC-7159.
|
| +** Return 0 otherwise.
|
| +*/
|
| +static void jsonValidFunc(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonParse x; /* The parse */
|
| + int rc = 0;
|
| +
|
| + UNUSED_PARAM(argc);
|
| + if( jsonParse(&x, 0, (const char*)sqlite3_value_text(argv[0]))==0 ){
|
| + rc = 1;
|
| + }
|
| + jsonParseReset(&x);
|
| + sqlite3_result_int(ctx, rc);
|
| +}
|
| +
|
| +
|
| +/****************************************************************************
|
| +** Aggregate SQL function implementations
|
| +****************************************************************************/
|
| +/*
|
| +** json_group_array(VALUE)
|
| +**
|
| +** Return a JSON array composed of all values in the aggregate.
|
| +*/
|
| +static void jsonArrayStep(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonString *pStr;
|
| + UNUSED_PARAM(argc);
|
| + pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
|
| + if( pStr ){
|
| + if( pStr->zBuf==0 ){
|
| + jsonInit(pStr, ctx);
|
| + jsonAppendChar(pStr, '[');
|
| + }else{
|
| + jsonAppendChar(pStr, ',');
|
| + pStr->pCtx = ctx;
|
| + }
|
| + jsonAppendValue(pStr, argv[0]);
|
| + }
|
| +}
|
| +static void jsonArrayFinal(sqlite3_context *ctx){
|
| + JsonString *pStr;
|
| + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
|
| + if( pStr ){
|
| + pStr->pCtx = ctx;
|
| + jsonAppendChar(pStr, ']');
|
| + if( pStr->bErr ){
|
| + if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
|
| + assert( pStr->bStatic );
|
| + }else{
|
| + sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
|
| + pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
|
| + pStr->bStatic = 1;
|
| + }
|
| + }else{
|
| + sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC);
|
| + }
|
| + sqlite3_result_subtype(ctx, JSON_SUBTYPE);
|
| +}
|
| +
|
| +/*
|
| +** json_group_obj(NAME,VALUE)
|
| +**
|
| +** Return a JSON object composed of all names and values in the aggregate.
|
| +*/
|
| +static void jsonObjectStep(
|
| + sqlite3_context *ctx,
|
| + int argc,
|
| + sqlite3_value **argv
|
| +){
|
| + JsonString *pStr;
|
| + const char *z;
|
| + u32 n;
|
| + UNUSED_PARAM(argc);
|
| + pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
|
| + if( pStr ){
|
| + if( pStr->zBuf==0 ){
|
| + jsonInit(pStr, ctx);
|
| + jsonAppendChar(pStr, '{');
|
| + }else{
|
| + jsonAppendChar(pStr, ',');
|
| + pStr->pCtx = ctx;
|
| + }
|
| + z = (const char*)sqlite3_value_text(argv[0]);
|
| + n = (u32)sqlite3_value_bytes(argv[0]);
|
| + jsonAppendString(pStr, z, n);
|
| + jsonAppendChar(pStr, ':');
|
| + jsonAppendValue(pStr, argv[1]);
|
| + }
|
| +}
|
| +static void jsonObjectFinal(sqlite3_context *ctx){
|
| + JsonString *pStr;
|
| + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
|
| + if( pStr ){
|
| + jsonAppendChar(pStr, '}');
|
| + if( pStr->bErr ){
|
| + if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
|
| + assert( pStr->bStatic );
|
| + }else{
|
| + sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
|
| + pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
|
| + pStr->bStatic = 1;
|
| + }
|
| + }else{
|
| + sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC);
|
| + }
|
| + sqlite3_result_subtype(ctx, JSON_SUBTYPE);
|
| +}
|
| +
|
| +
|
| +#ifndef SQLITE_OMIT_VIRTUALTABLE
|
| +/****************************************************************************
|
| +** The json_each virtual table
|
| +****************************************************************************/
|
| +typedef struct JsonEachCursor JsonEachCursor;
|
| +struct JsonEachCursor {
|
| + sqlite3_vtab_cursor base; /* Base class - must be first */
|
| + u32 iRowid; /* The rowid */
|
| + u32 iBegin; /* The first node of the scan */
|
| + u32 i; /* Index in sParse.aNode[] of current row */
|
| + u32 iEnd; /* EOF when i equals or exceeds this value */
|
| + u8 eType; /* Type of top-level element */
|
| + u8 bRecursive; /* True for json_tree(). False for json_each() */
|
| + char *zJson; /* Input JSON */
|
| + char *zRoot; /* Path by which to filter zJson */
|
| + JsonParse sParse; /* Parse of the input JSON */
|
| +};
|
| +
|
| +/* Constructor for the json_each virtual table */
|
| +static int jsonEachConnect(
|
| + sqlite3 *db,
|
| + void *pAux,
|
| + int argc, const char *const*argv,
|
| + sqlite3_vtab **ppVtab,
|
| + char **pzErr
|
| +){
|
| + sqlite3_vtab *pNew;
|
| + int rc;
|
| +
|
| +/* Column numbers */
|
| +#define JEACH_KEY 0
|
| +#define JEACH_VALUE 1
|
| +#define JEACH_TYPE 2
|
| +#define JEACH_ATOM 3
|
| +#define JEACH_ID 4
|
| +#define JEACH_PARENT 5
|
| +#define JEACH_FULLKEY 6
|
| +#define JEACH_PATH 7
|
| +#define JEACH_JSON 8
|
| +#define JEACH_ROOT 9
|
| +
|
| + UNUSED_PARAM(pzErr);
|
| + UNUSED_PARAM(argv);
|
| + UNUSED_PARAM(argc);
|
| + UNUSED_PARAM(pAux);
|
| + rc = sqlite3_declare_vtab(db,
|
| + "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path,"
|
| + "json HIDDEN,root HIDDEN)");
|
| + if( rc==SQLITE_OK ){
|
| + pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
|
| + if( pNew==0 ) return SQLITE_NOMEM;
|
| + memset(pNew, 0, sizeof(*pNew));
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/* destructor for json_each virtual table */
|
| +static int jsonEachDisconnect(sqlite3_vtab *pVtab){
|
| + sqlite3_free(pVtab);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* constructor for a JsonEachCursor object for json_each(). */
|
| +static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
|
| + JsonEachCursor *pCur;
|
| +
|
| + UNUSED_PARAM(p);
|
| + pCur = sqlite3_malloc( sizeof(*pCur) );
|
| + if( pCur==0 ) return SQLITE_NOMEM;
|
| + memset(pCur, 0, sizeof(*pCur));
|
| + *ppCursor = &pCur->base;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* constructor for a JsonEachCursor object for json_tree(). */
|
| +static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
|
| + int rc = jsonEachOpenEach(p, ppCursor);
|
| + if( rc==SQLITE_OK ){
|
| + JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
|
| + pCur->bRecursive = 1;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/* Reset a JsonEachCursor back to its original state. Free any memory
|
| +** held. */
|
| +static void jsonEachCursorReset(JsonEachCursor *p){
|
| + sqlite3_free(p->zJson);
|
| + sqlite3_free(p->zRoot);
|
| + jsonParseReset(&p->sParse);
|
| + p->iRowid = 0;
|
| + p->i = 0;
|
| + p->iEnd = 0;
|
| + p->eType = 0;
|
| + p->zJson = 0;
|
| + p->zRoot = 0;
|
| +}
|
| +
|
| +/* Destructor for a jsonEachCursor object */
|
| +static int jsonEachClose(sqlite3_vtab_cursor *cur){
|
| + JsonEachCursor *p = (JsonEachCursor*)cur;
|
| + jsonEachCursorReset(p);
|
| + sqlite3_free(cur);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* Return TRUE if the jsonEachCursor object has been advanced off the end
|
| +** of the JSON object */
|
| +static int jsonEachEof(sqlite3_vtab_cursor *cur){
|
| + JsonEachCursor *p = (JsonEachCursor*)cur;
|
| + return p->i >= p->iEnd;
|
| +}
|
| +
|
| +/* Advance the cursor to the next element for json_tree() */
|
| +static int jsonEachNext(sqlite3_vtab_cursor *cur){
|
| + JsonEachCursor *p = (JsonEachCursor*)cur;
|
| + if( p->bRecursive ){
|
| + if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++;
|
| + p->i++;
|
| + p->iRowid++;
|
| + if( p->i<p->iEnd ){
|
| + u32 iUp = p->sParse.aUp[p->i];
|
| + JsonNode *pUp = &p->sParse.aNode[iUp];
|
| + p->eType = pUp->eType;
|
| + if( pUp->eType==JSON_ARRAY ){
|
| + if( iUp==p->i-1 ){
|
| + pUp->u.iKey = 0;
|
| + }else{
|
| + pUp->u.iKey++;
|
| + }
|
| + }
|
| + }
|
| + }else{
|
| + switch( p->eType ){
|
| + case JSON_ARRAY: {
|
| + p->i += jsonNodeSize(&p->sParse.aNode[p->i]);
|
| + p->iRowid++;
|
| + break;
|
| + }
|
| + case JSON_OBJECT: {
|
| + p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]);
|
| + p->iRowid++;
|
| + break;
|
| + }
|
| + default: {
|
| + p->i = p->iEnd;
|
| + break;
|
| + }
|
| + }
|
| + }
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* Append the name of the path for element i to pStr
|
| +*/
|
| +static void jsonEachComputePath(
|
| + JsonEachCursor *p, /* The cursor */
|
| + JsonString *pStr, /* Write the path here */
|
| + u32 i /* Path to this element */
|
| +){
|
| + JsonNode *pNode, *pUp;
|
| + u32 iUp;
|
| + if( i==0 ){
|
| + jsonAppendChar(pStr, '$');
|
| + return;
|
| + }
|
| + iUp = p->sParse.aUp[i];
|
| + jsonEachComputePath(p, pStr, iUp);
|
| + pNode = &p->sParse.aNode[i];
|
| + pUp = &p->sParse.aNode[iUp];
|
| + if( pUp->eType==JSON_ARRAY ){
|
| + jsonPrintf(30, pStr, "[%d]", pUp->u.iKey);
|
| + }else{
|
| + assert( pUp->eType==JSON_OBJECT );
|
| + if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--;
|
| + assert( pNode->eType==JSON_STRING );
|
| + assert( pNode->jnFlags & JNODE_LABEL );
|
| + jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1);
|
| + }
|
| +}
|
| +
|
| +/* Return the value of a column */
|
| +static int jsonEachColumn(
|
| + sqlite3_vtab_cursor *cur, /* The cursor */
|
| + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */
|
| + int i /* Which column to return */
|
| +){
|
| + JsonEachCursor *p = (JsonEachCursor*)cur;
|
| + JsonNode *pThis = &p->sParse.aNode[p->i];
|
| + switch( i ){
|
| + case JEACH_KEY: {
|
| + if( p->i==0 ) break;
|
| + if( p->eType==JSON_OBJECT ){
|
| + jsonReturn(pThis, ctx, 0);
|
| + }else if( p->eType==JSON_ARRAY ){
|
| + u32 iKey;
|
| + if( p->bRecursive ){
|
| + if( p->iRowid==0 ) break;
|
| + iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey;
|
| + }else{
|
| + iKey = p->iRowid;
|
| + }
|
| + sqlite3_result_int64(ctx, (sqlite3_int64)iKey);
|
| + }
|
| + break;
|
| + }
|
| + case JEACH_VALUE: {
|
| + if( pThis->jnFlags & JNODE_LABEL ) pThis++;
|
| + jsonReturn(pThis, ctx, 0);
|
| + break;
|
| + }
|
| + case JEACH_TYPE: {
|
| + if( pThis->jnFlags & JNODE_LABEL ) pThis++;
|
| + sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC);
|
| + break;
|
| + }
|
| + case JEACH_ATOM: {
|
| + if( pThis->jnFlags & JNODE_LABEL ) pThis++;
|
| + if( pThis->eType>=JSON_ARRAY ) break;
|
| + jsonReturn(pThis, ctx, 0);
|
| + break;
|
| + }
|
| + case JEACH_ID: {
|
| + sqlite3_result_int64(ctx,
|
| + (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0));
|
| + break;
|
| + }
|
| + case JEACH_PARENT: {
|
| + if( p->i>p->iBegin && p->bRecursive ){
|
| + sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]);
|
| + }
|
| + break;
|
| + }
|
| + case JEACH_FULLKEY: {
|
| + JsonString x;
|
| + jsonInit(&x, ctx);
|
| + if( p->bRecursive ){
|
| + jsonEachComputePath(p, &x, p->i);
|
| + }else{
|
| + if( p->zRoot ){
|
| + jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot));
|
| + }else{
|
| + jsonAppendChar(&x, '$');
|
| + }
|
| + if( p->eType==JSON_ARRAY ){
|
| + jsonPrintf(30, &x, "[%d]", p->iRowid);
|
| + }else{
|
| + jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1);
|
| + }
|
| + }
|
| + jsonResult(&x);
|
| + break;
|
| + }
|
| + case JEACH_PATH: {
|
| + if( p->bRecursive ){
|
| + JsonString x;
|
| + jsonInit(&x, ctx);
|
| + jsonEachComputePath(p, &x, p->sParse.aUp[p->i]);
|
| + jsonResult(&x);
|
| + break;
|
| + }
|
| + /* For json_each() path and root are the same so fall through
|
| + ** into the root case */
|
| + }
|
| + default: {
|
| + const char *zRoot = p->zRoot;
|
| + if( zRoot==0 ) zRoot = "$";
|
| + sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC);
|
| + break;
|
| + }
|
| + case JEACH_JSON: {
|
| + assert( i==JEACH_JSON );
|
| + sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC);
|
| + break;
|
| + }
|
| + }
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* Return the current rowid value */
|
| +static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
|
| + JsonEachCursor *p = (JsonEachCursor*)cur;
|
| + *pRowid = p->iRowid;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* The query strategy is to look for an equality constraint on the json
|
| +** column. Without such a constraint, the table cannot operate. idxNum is
|
| +** 1 if the constraint is found, 3 if the constraint and zRoot are found,
|
| +** and 0 otherwise.
|
| +*/
|
| +static int jsonEachBestIndex(
|
| + sqlite3_vtab *tab,
|
| + sqlite3_index_info *pIdxInfo
|
| +){
|
| + int i;
|
| + int jsonIdx = -1;
|
| + int rootIdx = -1;
|
| + const struct sqlite3_index_constraint *pConstraint;
|
| +
|
| + UNUSED_PARAM(tab);
|
| + pConstraint = pIdxInfo->aConstraint;
|
| + for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
|
| + if( pConstraint->usable==0 ) continue;
|
| + if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
|
| + switch( pConstraint->iColumn ){
|
| + case JEACH_JSON: jsonIdx = i; break;
|
| + case JEACH_ROOT: rootIdx = i; break;
|
| + default: /* no-op */ break;
|
| + }
|
| + }
|
| + if( jsonIdx<0 ){
|
| + pIdxInfo->idxNum = 0;
|
| + pIdxInfo->estimatedCost = 1e99;
|
| + }else{
|
| + pIdxInfo->estimatedCost = 1.0;
|
| + pIdxInfo->aConstraintUsage[jsonIdx].argvIndex = 1;
|
| + pIdxInfo->aConstraintUsage[jsonIdx].omit = 1;
|
| + if( rootIdx<0 ){
|
| + pIdxInfo->idxNum = 1;
|
| + }else{
|
| + pIdxInfo->aConstraintUsage[rootIdx].argvIndex = 2;
|
| + pIdxInfo->aConstraintUsage[rootIdx].omit = 1;
|
| + pIdxInfo->idxNum = 3;
|
| + }
|
| + }
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* Start a search on a new JSON string */
|
| +static int jsonEachFilter(
|
| + sqlite3_vtab_cursor *cur,
|
| + int idxNum, const char *idxStr,
|
| + int argc, sqlite3_value **argv
|
| +){
|
| + JsonEachCursor *p = (JsonEachCursor*)cur;
|
| + const char *z;
|
| + const char *zRoot = 0;
|
| + sqlite3_int64 n;
|
| +
|
| + UNUSED_PARAM(idxStr);
|
| + UNUSED_PARAM(argc);
|
| + jsonEachCursorReset(p);
|
| + if( idxNum==0 ) return SQLITE_OK;
|
| + z = (const char*)sqlite3_value_text(argv[0]);
|
| + if( z==0 ) return SQLITE_OK;
|
| + n = sqlite3_value_bytes(argv[0]);
|
| + p->zJson = sqlite3_malloc64( n+1 );
|
| + if( p->zJson==0 ) return SQLITE_NOMEM;
|
| + memcpy(p->zJson, z, (size_t)n+1);
|
| + if( jsonParse(&p->sParse, 0, p->zJson) ){
|
| + int rc = SQLITE_NOMEM;
|
| + if( p->sParse.oom==0 ){
|
| + sqlite3_free(cur->pVtab->zErrMsg);
|
| + cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON");
|
| + if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR;
|
| + }
|
| + jsonEachCursorReset(p);
|
| + return rc;
|
| + }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){
|
| + jsonEachCursorReset(p);
|
| + return SQLITE_NOMEM;
|
| + }else{
|
| + JsonNode *pNode = 0;
|
| + if( idxNum==3 ){
|
| + const char *zErr = 0;
|
| + zRoot = (const char*)sqlite3_value_text(argv[1]);
|
| + if( zRoot==0 ) return SQLITE_OK;
|
| + n = sqlite3_value_bytes(argv[1]);
|
| + p->zRoot = sqlite3_malloc64( n+1 );
|
| + if( p->zRoot==0 ) return SQLITE_NOMEM;
|
| + memcpy(p->zRoot, zRoot, (size_t)n+1);
|
| + if( zRoot[0]!='$' ){
|
| + zErr = zRoot;
|
| + }else{
|
| + pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr);
|
| + }
|
| + if( zErr ){
|
| + sqlite3_free(cur->pVtab->zErrMsg);
|
| + cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr);
|
| + jsonEachCursorReset(p);
|
| + return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM;
|
| + }else if( pNode==0 ){
|
| + return SQLITE_OK;
|
| + }
|
| + }else{
|
| + pNode = p->sParse.aNode;
|
| + }
|
| + p->iBegin = p->i = (int)(pNode - p->sParse.aNode);
|
| + p->eType = pNode->eType;
|
| + if( p->eType>=JSON_ARRAY ){
|
| + pNode->u.iKey = 0;
|
| + p->iEnd = p->i + pNode->n + 1;
|
| + if( p->bRecursive ){
|
| + p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType;
|
| + if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){
|
| + p->i--;
|
| + }
|
| + }else{
|
| + p->i++;
|
| + }
|
| + }else{
|
| + p->iEnd = p->i+1;
|
| + }
|
| + }
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/* The methods of the json_each virtual table */
|
| +static sqlite3_module jsonEachModule = {
|
| + 0, /* iVersion */
|
| + 0, /* xCreate */
|
| + jsonEachConnect, /* xConnect */
|
| + jsonEachBestIndex, /* xBestIndex */
|
| + jsonEachDisconnect, /* xDisconnect */
|
| + 0, /* xDestroy */
|
| + jsonEachOpenEach, /* xOpen - open a cursor */
|
| + jsonEachClose, /* xClose - close a cursor */
|
| + jsonEachFilter, /* xFilter - configure scan constraints */
|
| + jsonEachNext, /* xNext - advance a cursor */
|
| + jsonEachEof, /* xEof - check for end of scan */
|
| + jsonEachColumn, /* xColumn - read data */
|
| + jsonEachRowid, /* xRowid - read data */
|
| + 0, /* xUpdate */
|
| + 0, /* xBegin */
|
| + 0, /* xSync */
|
| + 0, /* xCommit */
|
| + 0, /* xRollback */
|
| + 0, /* xFindMethod */
|
| + 0, /* xRename */
|
| + 0, /* xSavepoint */
|
| + 0, /* xRelease */
|
| + 0 /* xRollbackTo */
|
| +};
|
| +
|
| +/* The methods of the json_tree virtual table. */
|
| +static sqlite3_module jsonTreeModule = {
|
| + 0, /* iVersion */
|
| + 0, /* xCreate */
|
| + jsonEachConnect, /* xConnect */
|
| + jsonEachBestIndex, /* xBestIndex */
|
| + jsonEachDisconnect, /* xDisconnect */
|
| + 0, /* xDestroy */
|
| + jsonEachOpenTree, /* xOpen - open a cursor */
|
| + jsonEachClose, /* xClose - close a cursor */
|
| + jsonEachFilter, /* xFilter - configure scan constraints */
|
| + jsonEachNext, /* xNext - advance a cursor */
|
| + jsonEachEof, /* xEof - check for end of scan */
|
| + jsonEachColumn, /* xColumn - read data */
|
| + jsonEachRowid, /* xRowid - read data */
|
| + 0, /* xUpdate */
|
| + 0, /* xBegin */
|
| + 0, /* xSync */
|
| + 0, /* xCommit */
|
| + 0, /* xRollback */
|
| + 0, /* xFindMethod */
|
| + 0, /* xRename */
|
| + 0, /* xSavepoint */
|
| + 0, /* xRelease */
|
| + 0 /* xRollbackTo */
|
| +};
|
| +#endif /* SQLITE_OMIT_VIRTUALTABLE */
|
| +
|
| +/****************************************************************************
|
| +** The following routines are the only publically visible identifiers in this
|
| +** file. Call the following routines in order to register the various SQL
|
| +** functions and the virtual table implemented by this file.
|
| +****************************************************************************/
|
| +
|
| +SQLITE_PRIVATE int sqlite3Json1Init(sqlite3 *db){
|
| + int rc = SQLITE_OK;
|
| + unsigned int i;
|
| + static const struct {
|
| + const char *zName;
|
| + int nArg;
|
| + int flag;
|
| + void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
|
| + } aFunc[] = {
|
| + { "json", 1, 0, jsonRemoveFunc },
|
| + { "json_array", -1, 0, jsonArrayFunc },
|
| + { "json_array_length", 1, 0, jsonArrayLengthFunc },
|
| + { "json_array_length", 2, 0, jsonArrayLengthFunc },
|
| + { "json_extract", -1, 0, jsonExtractFunc },
|
| + { "json_insert", -1, 0, jsonSetFunc },
|
| + { "json_object", -1, 0, jsonObjectFunc },
|
| + { "json_quote", 1, 0, jsonQuoteFunc },
|
| + { "json_remove", -1, 0, jsonRemoveFunc },
|
| + { "json_replace", -1, 0, jsonReplaceFunc },
|
| + { "json_set", -1, 1, jsonSetFunc },
|
| + { "json_type", 1, 0, jsonTypeFunc },
|
| + { "json_type", 2, 0, jsonTypeFunc },
|
| + { "json_valid", 1, 0, jsonValidFunc },
|
| +
|
| +#if SQLITE_DEBUG
|
| + /* DEBUG and TESTING functions */
|
| + { "json_parse", 1, 0, jsonParseFunc },
|
| + { "json_test1", 1, 0, jsonTest1Func },
|
| +#endif
|
| + };
|
| + static const struct {
|
| + const char *zName;
|
| + int nArg;
|
| + void (*xStep)(sqlite3_context*,int,sqlite3_value**);
|
| + void (*xFinal)(sqlite3_context*);
|
| + } aAgg[] = {
|
| + { "json_group_array", 1, jsonArrayStep, jsonArrayFinal },
|
| + { "json_group_object", 2, jsonObjectStep, jsonObjectFinal },
|
| + };
|
| +#ifndef SQLITE_OMIT_VIRTUALTABLE
|
| + static const struct {
|
| + const char *zName;
|
| + sqlite3_module *pModule;
|
| + } aMod[] = {
|
| + { "json_each", &jsonEachModule },
|
| + { "json_tree", &jsonTreeModule },
|
| + };
|
| +#endif
|
| + for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
|
| + rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
|
| + SQLITE_UTF8 | SQLITE_DETERMINISTIC,
|
| + (void*)&aFunc[i].flag,
|
| + aFunc[i].xFunc, 0, 0);
|
| + }
|
| + for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
|
| + rc = sqlite3_create_function(db, aAgg[i].zName, aAgg[i].nArg,
|
| + SQLITE_UTF8 | SQLITE_DETERMINISTIC, 0,
|
| + 0, aAgg[i].xStep, aAgg[i].xFinal);
|
| + }
|
| +#ifndef SQLITE_OMIT_VIRTUALTABLE
|
| + for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){
|
| + rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
|
| + }
|
| +#endif
|
| + return rc;
|
| +}
|
| +
|
| +
|
| +#ifndef SQLITE_CORE
|
| +#ifdef _WIN32
|
| +__declspec(dllexport)
|
| +#endif
|
| +SQLITE_API int sqlite3_json_init(
|
| + sqlite3 *db,
|
| + char **pzErrMsg,
|
| + const sqlite3_api_routines *pApi
|
| +){
|
| + SQLITE_EXTENSION_INIT2(pApi);
|
| + (void)pzErrMsg; /* Unused parameter */
|
| + return sqlite3Json1Init(db);
|
| +}
|
| +#endif
|
| +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) */
|
| +
|
| +/************** End of json1.c ***********************************************/
|
| +
|
| +/* Chain include. */
|
| +#include "sqlite3.09.c"
|
|
|
Chromium Code Reviews
Issue 2755803002:
NCI: trybot test for sqlite 3.17 import. (Closed)
