Index: ext/session/sqlite3session.c ================================================================== --- ext/session/sqlite3session.c +++ ext/session/sqlite3session.c @@ -6,11 +6,10 @@ #include #include "sqliteInt.h" #include "vdbeInt.h" -typedef struct RowChange RowChange; typedef struct SessionTable SessionTable; typedef struct SessionChange SessionChange; typedef struct SessionBuffer SessionBuffer; /* @@ -55,10 +54,12 @@ */ 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 */ }; @@ -126,11 +127,11 @@ /* ** For each row modified during a session, there exists a single instance of ** this structure stored in a SessionTable.aChange[] hash table. */ struct SessionChange { - sqlite3_int64 iKey; /* Key value */ + int bInsert; /* True if row was inserted this session */ int nRecord; /* Number of bytes in buffer aRecord[] */ u8 *aRecord; /* Buffer containing old.* record */ SessionChange *pNext; /* For hash-table collisions */ }; @@ -262,16 +263,192 @@ *pnWrite += nByte; return SQLITE_OK; } -/* -** Return the hash of iKey, assuming there are nBucket hash buckets in -** the hash table. -*/ -static int sessionKeyhash(int nBucket, sqlite3_int64 iKey){ - return (iKey % nBucket); +#define HASH_APPEND(hash, add) ((hash) << 3) ^ (hash) ^ (int)(add) +static int sessionHashAppendI64(int h, i64 i){ + h = HASH_APPEND(h, i & 0xFFFFFFFF); + return HASH_APPEND(h, (i>>32)&0xFFFFFFFF); +} +static int sessionHashAppendBlob(int h, int n, const u8 *z){ + int i; + for(i=0; inCol==sqlite3_preupdate_count(db) ); + for(i=0; inCol; i++){ + if( pTab->abPK[i] ){ + int rc; + int eType; + sqlite3_value *pVal; + + if( bNew ){ + rc = sqlite3_preupdate_new(db, i, &pVal); + }else{ + rc = sqlite3_preupdate_old(db, i, &pVal); + } + + eType = sqlite3_value_type(pVal); + h = HASH_APPEND(h, eType); + switch( eType ){ + case SQLITE_INTEGER: + case 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); + break; + } + + case SQLITE_TEXT: + case SQLITE_BLOB: { + int n = sqlite3_value_bytes(pVal); + const u8 *z = eType==SQLITE_TEXT ? + sqlite3_value_text(pVal) : sqlite3_value_blob(pVal); + h = sessionHashAppendBlob(h, n, z); + break; + } + } + } + } + + *piHash = (h % pTab->nChange); + return SQLITE_OK; +} + +static int sessionChangeHash( + sqlite3 *db, + SessionTable *pTab, + SessionChange *pChange, + int nBucket +){ + int h = 0; + int i; + u8 *a = pChange->aRecord; + + for(i=0; inCol; i++){ + int eType = *a++; + int isPK = pTab->abPK[i]; + + if( isPK ) h = HASH_APPEND(h, eType); + switch( eType ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + if( isPK ){ + i64 iVal = sessionGetI64(a); + h = sessionHashAppendI64(h, iVal); + } + a += 8; + break; + } + case SQLITE_TEXT: + case SQLITE_BLOB: { + int n; + a += sessionVarintGet(a, &n); + if( isPK ){ + h = sessionHashAppendBlob(h, n, a); + } + a += n; + break; + } + } + } + return (h % nBucket); +} + +static int sessionPreupdateEqual( + sqlite3 *db, + SessionTable *pTab, + SessionChange *pChange, + int bNew, + int *pbEqual +){ + int i; + u8 *a = pChange->aRecord; + + *pbEqual = 0; + + for(i=0; inCol; i++){ + int eType = *a++; + if( !pTab->abPK[i] ){ + switch( eType ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + a += 8; + break; + + case SQLITE_TEXT: + case SQLITE_BLOB: { + int n; + a += sessionVarintGet(a, &n); + a += n; + break; + } + } + }else{ + sqlite3_value *pVal; + int rc; + if( bNew ){ + rc = sqlite3_preupdate_new(db, i, &pVal); + }else{ + rc = sqlite3_preupdate_old(db, i, &pVal); + } + if( rc!=SQLITE_OK || sqlite3_value_type(pVal)!=eType ) return rc; + + switch( eType ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + i64 iVal = sessionGetI64(a); + a += 8; + if( eType==SQLITE_INTEGER ){ + if( sqlite3_value_int64(pVal)!=iVal ) return SQLITE_OK; + }else{ + double rVal; + assert( sizeof(iVal)==8 && sizeof(rVal)==8 ); + memcpy(&rVal, &iVal, 8); + if( sqlite3_value_double(pVal)!=rVal ) return SQLITE_OK; + } + break; + } + case SQLITE_TEXT: + case SQLITE_BLOB: { + int n; + const u8 *z; + a += sessionVarintGet(a, &n); + if( sqlite3_value_bytes(pVal)!=n ) return SQLITE_OK; + z = eType==SQLITE_TEXT ? + sqlite3_value_text(pVal) : sqlite3_value_blob(pVal); + if( memcmp(a, z, n) ) return SQLITE_OK; + a += n; + break; + } + } + } + } + + *pbEqual = 1; + return SQLITE_OK; } /* ** 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 @@ -301,11 +478,11 @@ for(i=0; inChange; i++){ SessionChange *p; SessionChange *pNext; for(p=pTab->apChange[i]; p; p=pNext){ - int iHash = sessionKeyhash(nNew, p->iKey); + int iHash = sessionChangeHash(pSession->db, pTab, p, nNew); pNext = p->pNext; p->pNext = apNew[iHash]; apNew[iHash] = p; } } @@ -315,10 +492,134 @@ 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 it is not NULL, 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 three output variables are populated as follows: +** +** *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 nCol, /* Expected 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; + u8 *pFree = 0; + char **azCol; + u8 *abPK; + + assert( pazCol || pabPK ); + + nThis = strlen(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( nDbCol!=nCol ){ + rc = SQLITE_SCHEMA; + } + 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 ){ + pFree = pAlloc; + if( pazCol ){ + azCol = (char **)pAlloc; + pAlloc = (u8 *)&azCol[nCol]; + } + if( pabPK ){ + abPK = (u8 *)pAlloc; + pAlloc = &abPK[nCol]; + } + 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; + if( pazCol ){ + memcpy(pAlloc, zName, nName+1); + azCol[i] = (char *)pAlloc; + pAlloc += nName+1; + } + if( pabPK ) 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 ){ + if( pazCol ) *pazCol = (const char **)azCol; + if( pabPK ) *pabPK = abPK; + }else{ + if( pazCol ) *pazCol = 0; + if( pabPK ) *pabPK = 0; + if( pzTab ) *pzTab = 0; + sqlite3_free(pFree); + } + 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, set the SessionTable.nCol variable to the number @@ -334,16 +635,108 @@ ** for which changes are being recorded by the session module. If they do so, ** it is an error. */ static int sessionInitTable(sqlite3_session *pSession, SessionTable *pTab){ if( pTab->nCol==0 ){ + assert( pTab->azCol==0 || pTab->abPK==0 ); pTab->nCol = sqlite3_preupdate_count(pSession->db); + pSession->rc = sessionTableInfo(pSession->db, pSession->zDb, + pTab->zName, pTab->nCol, 0, &pTab->azCol, &pTab->abPK + ); }else if( pTab->nCol!=sqlite3_preupdate_count(pSession->db) ){ pSession->rc = SQLITE_SCHEMA; - return SQLITE_ERROR; } - return SQLITE_OK; + return pSession->rc; +} + +static void sessionPreupdateOneChange( + int op, + sqlite3_session *pSession, + SessionTable *pTab +){ + sqlite3 *db = pSession->db; + SessionChange *pChange; + SessionChange *pC; + int iHash; + int rc = SQLITE_OK; + + if( pSession->rc ) return; + + /* Load table details if required */ + if( sessionInitTable(pSession, pTab) ) return; + + /* Grow the hash table if required */ + if( sessionGrowHash(pSession, pTab) ) return; + + /* Search the hash table for an existing entry for rowid=iKey2. If + ** one is found, store a pointer to it in pChange and unlink it from + ** the hash table. Otherwise, set pChange to NULL. + */ + rc = sessionPreupdateHash(db, pTab, op==SQLITE_INSERT, &iHash); + for(pC=pTab->apChange[iHash]; rc==SQLITE_OK && pC; pC=pC->pNext){ + int bEqual; + rc = sessionPreupdateEqual(db, pTab, pC, op==SQLITE_INSERT, &bEqual); + if( bEqual ) 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). */ + int nByte; /* Number of bytes to allocate */ + int i; /* Used to iterate through columns */ + + pTab->nEntry++; + + /* Figure out how large an allocation is required */ + nByte = sizeof(SessionChange); + for(i=0; inCol && rc==SQLITE_OK; i++){ + sqlite3_value *p = 0; + if( op!=SQLITE_INSERT ){ + rc = sqlite3_preupdate_old(pSession->db, i, &p); + }else if( 1 || pTab->abPK[i] ){ + rc = sqlite3_preupdate_new(pSession->db, i, &p); + } + if( p && rc==SQLITE_OK ){ + rc = sessionSerializeValue(0, p, &nByte); + } + } + + /* Allocate the change object */ + pChange = (SessionChange *)sqlite3_malloc(nByte); + if( !pChange ){ + rc = SQLITE_NOMEM; + }else{ + memset(pChange, 0, sizeof(SessionChange)); + pChange->aRecord = (u8 *)&pChange[1]; + } + + /* Populate the change object */ + nByte = 0; + for(i=0; inCol && rc==SQLITE_OK; i++){ + sqlite3_value *p = 0; + if( op!=SQLITE_INSERT ){ + rc = sqlite3_preupdate_old(pSession->db, i, &p); + }else if( 1 || pTab->abPK[i] ){ + rc = sqlite3_preupdate_new(pSession->db, i, &p); + } + if( p && rc==SQLITE_OK ){ + rc = sessionSerializeValue(&pChange->aRecord[nByte], p, &nByte); + } + } + pChange->nRecord = nByte; + + /* If an error has occurred, mark the session object as failed. */ + if( rc!=SQLITE_OK ){ + sqlite3_free(pChange); + pSession->rc = rc; + }else{ + /* Add the change back to the hash-table */ + pChange->bInsert = (op==SQLITE_INSERT); + pChange->pNext = pTab->apChange[iHash]; + pTab->apChange[iHash] = pChange; + } + } } /* ** The 'pre-update' hook registered by this module with SQLite databases. */ @@ -361,97 +754,23 @@ int nName = strlen(zDb); for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){ SessionTable *pTab; - /* If this session is already in the error-state, or if it 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 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; for(pTab=pSession->pTable; pTab; pTab=pTab->pNext){ if( 0==sqlite3_strnicmp(pTab->zName, zName, nName+1) ){ - SessionChange *pChange; - SessionChange *pC; - int iHash; - int rc = SQLITE_OK; - - /* Load table details if required */ - if( sessionInitTable(pSession, pTab) ) return; - - /* Grow the hash table if required */ - if( sessionGrowHash(pSession, pTab) ) return; - - /* Search the hash table for an existing entry for rowid=iKey2. If - ** one is found, store a pointer to it in pChange and unlink it from - ** the hash table. Otherwise, set pChange to NULL. - */ - iHash = sessionKeyhash(pTab->nChange, iKey2); - for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){ - if( pC->iKey==iKey2 ) break; + sessionPreupdateOneChange(op, pSession, pTab); + if( op==SQLITE_UPDATE ){ + sessionPreupdateOneChange(SQLITE_INSERT, pSession, pTab); } - if( pC ) continue; - - pTab->nEntry++; - - /* Create a new change object containing all the old values (if - ** this is an SQLITE_UPDATE or SQLITE_DELETE), or no record at - ** all (if this is an INSERT). */ - if( op==SQLITE_INSERT ){ - pChange = (SessionChange *)sqlite3_malloc(sizeof(SessionChange)); - if( pChange ){ - memset(pChange, 0, sizeof(SessionChange)); - } - }else{ - int nByte; /* Number of bytes to allocate */ - int i; /* Used to iterate through columns */ - - /* Figure out how large an allocation is required */ - nByte = sizeof(SessionChange); - for(i=0; inCol && rc==SQLITE_OK; i++){ - sqlite3_value *p; /* old.* value */ - rc = sqlite3_preupdate_old(pSession->db, i, &p); - if( rc==SQLITE_OK ){ - rc = sessionSerializeValue(0, p, &nByte); - } - } - - /* Allocate the change object */ - pChange = (SessionChange *)sqlite3_malloc(nByte); - if( !pChange ){ - rc = SQLITE_NOMEM; - }else{ - memset(pChange, 0, sizeof(SessionChange)); - pChange->aRecord = (u8 *)&pChange[1]; - } - - /* Populate the change object */ - nByte = 0; - for(i=0; inCol && rc==SQLITE_OK; i++){ - sqlite3_value *p; /* old.* value */ - rc = sqlite3_preupdate_old(pSession->db, i, &p); - if( rc==SQLITE_OK ){ - rc = sessionSerializeValue(&pChange->aRecord[nByte], p, &nByte); - } - } - pChange->nRecord = nByte; - } - - /* If an error has occurred, mark the session object as failed. */ - if( rc!=SQLITE_OK ){ - sqlite3_free(pChange); - pSession->rc = rc; - return; - } - - /* Add the change back to the hash-table */ - pChange->iKey = iKey2; - pChange->pNext = pTab->apChange[iHash]; - pTab->apChange[iHash] = pChange; break; } } } } @@ -522,10 +841,11 @@ for(p=pTab->apChange[i]; p; p=pNext){ pNext = p->pNext; sqlite3_free(p); } } + sqlite3_free(pTab->azCol); sqlite3_free(pTab->apChange); sqlite3_free(pTab); } /* Free the session object itself. */ @@ -850,131 +1170,103 @@ sqlite3_free(buf2.aBuf); } } } -/* -** 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 it is not NULL, 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 three output variables are populated as follows: -** -** *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 nCol, /* Expected 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 */ +static int sessionSelectStmt( + sqlite3 *db, /* Database handle */ + const char *zTab, /* Table name */ + int nCol, + const char **azCol, + u8 *abPK, + sqlite3_stmt **ppStmt ){ - char *zPragma; - sqlite3_stmt *pStmt; - int rc; - int nByte; - int nDbCol = 0; - int nThis; + int rc = SQLITE_OK; int i; - u8 *pAlloc; - u8 *pFree = 0; - char **azCol; - u8 *abPK; + const char *zSep = ""; + SessionBuffer buf = {0, 0, 0}; - assert( pazCol || pabPK ); - - nThis = strlen(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( nDbCol!=nCol ){ - rc = SQLITE_SCHEMA; - } - if( rc==SQLITE_OK ){ - nByte += nDbCol * (sizeof(const char *) + sizeof(u8) + 1); - pAlloc = sqlite3_malloc(nByte); - if( pAlloc==0 ){ - rc = SQLITE_NOMEM; + sessionAppendStr(&buf, "SELECT * FROM ", &rc); + sessionAppendIdent(&buf, zTab, &rc); + sessionAppendStr(&buf, " WHERE ", &rc); + for(i=0; irc; for(pTab=pSession->pTable; rc==SQLITE_OK && pTab; pTab=pTab->pNext){ if( pTab->nEntry ){ + int nCol = pTab->nCol; /* Local copy of member variable */ + u8 *abPK = pTab->abPK; /* Local copy of member variable */ int i; sqlite3_stmt *pStmt = 0; int bNoop = 1; int nRewind = buf.nBuf; - u8 *abPK = 0; /* Write a table header */ sessionAppendByte(&buf, 'T', &rc); - sessionAppendVarint(&buf, pTab->nCol, &rc); + sessionAppendVarint(&buf, nCol, &rc); sessionAppendBlob(&buf, (u8 *)pTab->zName, strlen(pTab->zName)+1, &rc); /* Build and compile a statement to execute: */ if( rc==SQLITE_OK ){ - char *zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q WHERE _rowid_ = ?", - pSession->zDb, pTab->zName - ); - if( !zSql ){ - rc = SQLITE_NOMEM; - }else{ - rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); - } - sqlite3_free(zSql); + rc = sessionSelectStmt(db, pTab->zName, nCol, pTab->azCol, abPK,&pStmt); } - if( rc==SQLITE_OK && pTab->nCol!=sqlite3_column_count(pStmt) ){ + if( rc==SQLITE_OK && nCol!=sqlite3_column_count(pStmt) ){ rc = SQLITE_SCHEMA; } - if( rc==SQLITE_OK ){ - rc = sessionTableInfo( - db, pSession->zDb, pTab->zName, pTab->nCol, 0, 0, &abPK); - } - for(i=0; inChange; i++){ - SessionChange *p; + SessionChange *p; /* Used to iterate through changes */ + for(p=pTab->apChange[i]; rc==SQLITE_OK && p; p=p->pNext){ - sqlite3_bind_int64(pStmt, 1, p->iKey); - if( sqlite3_step(pStmt)==SQLITE_ROW ){ - int iCol; - if( p->aRecord ){ - sessionAppendUpdate(&buf, pStmt, p, abPK, &rc); - }else{ - sessionAppendByte(&buf, SQLITE_INSERT, &rc); - for(iCol=0; iColnCol; iCol++){ - sessionAppendCol(&buf, pStmt, iCol, &rc); + rc = sessionSelectBind(pStmt, nCol, abPK, p->aRecord, p->nRecord); + if( rc==SQLITE_OK ){ + if( sqlite3_step(pStmt)==SQLITE_ROW ){ + int iCol; + if( p->bInsert ){ + sessionAppendByte(&buf, SQLITE_INSERT, &rc); + for(iCol=0; iColbInsert ){ + /* A DELETE change */ + sessionAppendByte(&buf, SQLITE_DELETE, &rc); + sessionAppendBlob(&buf, p->aRecord, p->nRecord, &rc); + bNoop = 0; } - bNoop = 0; - }else if( p->aRecord ){ - /* A DELETE change */ - sessionAppendByte(&buf, SQLITE_DELETE, &rc); - sessionAppendBlob(&buf, p->aRecord, p->nRecord, &rc); - bNoop = 0; + rc = sqlite3_reset(pStmt); } - rc = sqlite3_reset(pStmt); } } sqlite3_finalize(pStmt); - sqlite3_free(abPK); if( bNoop ){ buf.nBuf = nRewind; } } @@ -1630,32 +1912,11 @@ static int sessionSelectRow( 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}; - - sessionAppendStr(&buf, "SELECT * FROM ", &rc); - sessionAppendIdent(&buf, zTab, &rc); - sessionAppendStr(&buf, " WHERE ", &rc); - for(i=0; inCol; i++){ - if( p->abPK[i] ){ - sessionAppendStr(&buf, zSep, &rc); - sessionAppendIdent(&buf, p->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, &p->pSelect, 0); - } - sqlite3_free(buf.aBuf); - return rc; + return sessionSelectStmt(db, zTab, p->nCol, p->azCol, p->abPK, &p->pSelect); } /* ** Formulate and prepare an INSERT statement to add a record to table zTab. ** For example: Index: test/session1.test ================================================================== --- test/session1.test +++ test/session1.test @@ -35,11 +35,11 @@ set x }]] [list $r] } do_execsql_test 1.0 { - CREATE TABLE t1(x, y); + CREATE TABLE t1(x PRIMARY KEY, y); INSERT INTO t1 VALUES('abc', 'def'); } #------------------------------------------------------------------------- # Test creating, attaching tables to and deleting session objects. @@ -111,10 +111,11 @@ {INSERT t1 {} {i 3 t Thonburi}} } do_test 2.2.4 { S delete } {} do_test 2.3.1 { + execsql { DELETE FROM t1 } sqlite3session S db main execsql { INSERT INTO t1 VALUES(1, 'Sukhothai') } execsql { INSERT INTO t1 VALUES(2, 'Ayutthaya') } execsql { INSERT INTO t1 VALUES(3, 'Thonburi') } S attach t1 @@ -124,18 +125,23 @@ UPDATE t1 SET x = 20, y = 'Thapae' WHERE x = 3; } } {} do_changeset_test 2.3.2 S { - {UPDATE t1 {i 1 {} {}} {i 10 {} {}}} - {UPDATE t1 {{} {} t Ayutthaya} {{} {} t Surin}} - {UPDATE t1 {i 3 t Thonburi} {i 20 t Thapae}} + {INSERT t1 {} {i 10 t Sukhothai}} + {DELETE t1 {i 1 t Sukhothai} {}} + {UPDATE t1 {i 2 t Ayutthaya} {{} {} t Surin}} + {DELETE t1 {i 3 t Thonburi} {}} + {INSERT t1 {} {i 20 t Thapae}} } + do_changeset_invert_test 2.3.3 S { - {UPDATE t1 {i 10 {} {}} {i 1 {} {}}} - {UPDATE t1 {{} {} t Surin} {{} {} t Ayutthaya}} - {UPDATE t1 {i 20 t Thapae} {i 3 t Thonburi}} + {DELETE t1 {i 10 t Sukhothai} {}} + {INSERT t1 {} {i 1 t Sukhothai}} + {UPDATE t1 {{} {} t Surin} {i 2 t Ayutthaya}} + {INSERT t1 {} {i 3 t Thonburi}} + {DELETE t1 {i 20 t Thapae} {}} } do_test 2.3.4 { S delete } {} do_test 2.4.1 { sqlite3session S db main @@ -207,25 +213,26 @@ INSERT INTO t1 VALUES(1, 'one'); INSERT INTO t1 VALUES(2, 'two'); } db } {} do_db2_test 3.1.1 "INSERT INTO t1 VALUES(6, 'VI')" -do_conflict_test 3.2.2 -tables t1 -sql { +do_conflict_test 3.1.2 -tables t1 -sql { INSERT INTO t1 VALUES(3, 'three'); INSERT INTO t1 VALUES(4, 'four'); INSERT INTO t1 VALUES(5, 'five'); INSERT INTO t1 VALUES(6, 'six'); INSERT INTO t1 VALUES(7, 'seven'); INSERT INTO t1 VALUES(8, NULL); } -conflicts { - {INSERT t1 CONFLICT {i 6 t six} {i 6 t VI}} {INSERT t1 CONSTRAINT {i 8 n {}}} + {INSERT t1 CONFLICT {i 6 t six} {i 6 t VI}} } -do_db2_test 3.1.2 "SELECT * FROM t1" { + +do_db2_test 3.1.3 "SELECT * FROM t1" { 6 VI 3 three 4 four 5 five 7 seven } -do_execsql_test 3.1.3 "SELECT * FROM t1" { +do_execsql_test 3.1.4 "SELECT * FROM t1" { 1 one 2 two 3 three 4 four 5 five 6 six 7 seven 8 {} } # Test DELETE changesets. # @@ -280,13 +287,13 @@ UPDATE t4 SET a = -1 WHERE b = 2; UPDATE t4 SET a = -1 WHERE b = 5; UPDATE t4 SET a = NULL WHERE c = 9; UPDATE t4 SET a = 'x' WHERE b = 11; } -conflicts { + {UPDATE t4 CONSTRAINT {i 7 i 8 i 9} {n {} {} {} {} {}}} {UPDATE t4 DATA {i 1 i 2 i 3} {i -1 {} {} {} {}} {i 0 i 2 i 3}} {UPDATE t4 NOTFOUND {i 4 i 5 i 6} {i -1 {} {} {} {}}} - {UPDATE t4 CONSTRAINT {i 7 i 8 i 9} {n {} {} {} {} {}}} } do_db2_test 3.3.4 { SELECT * FROM t4 } {0 2 3 4 5 7 7 8 9 x 11 12} do_execsql_test 3.3.5 { SELECT * FROM t4 } {-1 2 3 -1 5 6 {} 8 9 x 11 12} #------------------------------------------------------------------------- @@ -306,12 +313,12 @@ lappend ::xConflict $args return $::conflict_return } foreach {tn conflict_return after} { - 1 OMIT {1 2 value1 4 5 7 7 8 9 10 x x} - 2 REPLACE {1 2 value1 4 5 value2 10 8 9} + 1 OMIT {1 2 value1 4 5 7 10 x x} + 2 REPLACE {1 2 value1 4 5 value2 10 8 9} } { test_reset do_test 4.$tn.1 { foreach db {db db2} { @@ -331,12 +338,12 @@ do_conflict_test 4.$tn.2 -tables t1 -sql { UPDATE t1 SET c = 'value1' WHERE a = 1; -- no conflict UPDATE t1 SET c = 'value2' WHERE a = 4; -- DATA conflict UPDATE t1 SET a = 10 WHERE a = 7; -- CONFLICT conflict } -conflicts { + {INSERT t1 CONFLICT {i 10 i 8 i 9} {i 10 t x t x}} {UPDATE t1 DATA {i 4 {} {} i 6} {{} {} {} {} t value2} {i 4 i 5 i 7}} - {UPDATE t1 CONFLICT {i 7 {} {} {} {}} {i 10 {} {} {} {}} {i 10 t x t x}} } do_db2_test 4.$tn.3 "SELECT * FROM t1 ORDER BY a" $after }