#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

static int sessions_strm_chunk_size = SESSIONS_STRM_CHUNK_SIZE;

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_value *pZeroBlob; /* Value containing X'' */

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, do not discard in InputBuffer() */

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 bInvert; /* True to invert changeset */

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 */

int bStat1; /* True if this is sqlite_stat1 */

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 omitted. 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".

**

** REBASE BLOB FORMAT:

**

** A rebase blob may be output by sqlite3changeset_apply_v2() and its

** streaming equivalent for use with the sqlite3_rebaser APIs to rebase

** existing changesets. A rebase blob contains one entry for each conflict

** resolved using either the OMIT or REPLACE strategies within the apply_v2()

** call.

**

** The format used for a rebase blob is very similar to that used for

** changesets. All entries related to a single table are grouped together.

**

** Each group of entries begins with a table header in changeset format:

**

** 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 entries associated with the table.

**

** 1 byte: Either SQLITE_INSERT (0x12), DELETE (0x09).

** 1 byte: Flag. 0x01 for REPLACE, 0x00 for OMIT.

** record: (in the record format defined above).

**

** In a rebase blob, the first field is set to SQLITE_INSERT if the change

** that caused the conflict was an INSERT or UPDATE, or to SQLITE_DELETE if

** it was a DELETE. The second field is set to 0x01 if the conflict

** resolution strategy was REPLACE, or 0x00 if it was OMIT.

**

** If the change that caused the conflict was a DELETE, then the single

** record is a copy of the old.* record from the original changeset. If it

** was an INSERT, then the single record is a copy of the new.* record. If

** the conflicting change was an UPDATE, then the single record is a copy

** of the new.* record with the PK fields filled in based on the original

** old.* record.

*/

/*

** 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 */

sqlite3_int64 *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 );

assert( pTab->bStat1==0 || i!=1 );

*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 || e==0xFF ) 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( 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( n>0 && memcmp(a, z, n) ) return 0;

a += n;

}

}

}

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;

sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);

apNew = (SessionChange **)sqlite3_malloc64(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.

**

** 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

*/

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;

sqlite3_int64 nByte;

int nDbCol = 0;

int nThis;

int i;

u8 *pAlloc = 0;

char **azCol = 0;

u8 *abPK = 0;

assert( pazCol && pabPK );

nThis = sqlite3Strlen30(zThis);

if( nThis==12 && 0==sqlite3_stricmp("sqlite_stat1", zThis) ){

rc = sqlite3_table_column_metadata(db, zDb, zThis, 0, 0, 0, 0, 0, 0);

if( rc==SQLITE_OK ){

/* For sqlite_stat1, pretend that (tbl,idx) is the PRIMARY KEY. */

zPragma = sqlite3_mprintf(

"SELECT 0, 'tbl', '', 0, '', 1 UNION ALL "

"SELECT 1, 'idx', '', 0, '', 2 UNION ALL "

"SELECT 2, 'stat', '', 0, '', 0"

);

}else if( rc==SQLITE_ERROR ){

zPragma = sqlite3_mprintf("");

}else{

return rc;

}

}else{

zPragma = sqlite3_mprintf("PRAGMA '%q'.table_info('%q')", zDb, zThis);

}