Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Fixes for the sqlite3changeset_concat() API regarding patchsets. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | sessions |
Files: | files | file ages | folders |
SHA1: |
dccb34859508eac8146ae5b19c447673 |
User & Date: | dan 2014-08-16 16:47:55.133 |
Context
2014-08-16
| ||
19:01 | Fix some missing and out-of-date comments in the sessions module. (check-in: 05c1d9149b user: dan tags: sessions) | |
16:47 | Fixes for the sqlite3changeset_concat() API regarding patchsets. (check-in: dccb348595 user: dan tags: sessions) | |
2014-08-15
| ||
20:15 | Begin adding the sqlite3session_patchset() API to the sessions extension. This is an interim commit. (check-in: 60a4565a8c user: dan tags: sessions) | |
Changes
Changes to ext/session/sessionB.test.
︙ | ︙ | |||
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | #------------------------------------------------------------------------- # sqlite3changeset_concat() # reset_db proc do_patchconcat_test {tn args} { set nSql [expr [llength $args]-1] set res [lindex $args $nSql] set patchlist [list] execsql BEGIN foreach sql [lrange $args 0 end-1] { sqlite3session S db main S attach * execsql $sql lappend patchlist [S patchset] S delete } execsql ROLLBACK set patch [lindex $patchlist 0] foreach p [lrange $patchlist 1 end] { set patch [sqlite3changeset_concat $patch $p] } | > > > > > > > | 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 | #------------------------------------------------------------------------- # sqlite3changeset_concat() # reset_db proc do_patchconcat_test {tn args} { set bRevert 0 if {[lindex $args 0] == "-revert"} { set bRevert 1 set args [lrange $args 1 end] } set nSql [expr [llength $args]-1] set res [lindex $args $nSql] set patchlist [list] execsql BEGIN if {$bRevert} { execsql { SAVEPOINT x } } foreach sql [lrange $args 0 end-1] { sqlite3session S db main S attach * execsql $sql lappend patchlist [S patchset] S delete if {$bRevert} { execsql { ROLLBACK TO x } } } execsql ROLLBACK set patch [lindex $patchlist 0] foreach p [lrange $patchlist 1 end] { set patch [sqlite3changeset_concat $patch $p] } |
︙ | ︙ | |||
211 212 213 214 215 216 217 | } { INSERT INTO t1 VALUES(4, 5, 6); } { {INSERT t1 0 X.. {} {i 1 i 2 i 3}} {INSERT t1 0 X.. {} {i 4 i 5 i 6}} } | < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 | } { INSERT INTO t1 VALUES(4, 5, 6); } { {INSERT t1 0 X.. {} {i 1 i 2 i 3}} {INSERT t1 0 X.. {} {i 4 i 5 i 6}} } do_execsql_test 4.2.1 { INSERT INTO t1 VALUES(1, 2, 3); INSERT INTO t1 VALUES(4, 5, 6); } do_patchconcat_test 4.2.2 { UPDATE t1 SET z = 'abc' WHERE x=1 } { UPDATE t1 SET z = 'def' WHERE x=4 } { {UPDATE t1 0 X.. {i 1 {} {} {} {}} {{} {} {} {} t abc}} {UPDATE t1 0 X.. {i 4 {} {} {} {}} {{} {} {} {} t def}} } do_patchconcat_test 4.2.3 { DELETE FROM t1 WHERE x=1; } { DELETE FROM t1 WHERE x=4; } { {DELETE t1 0 X.. {i 1 {} {} {} {}} {}} {DELETE t1 0 X.. {i 4 {} {} {} {}} {}} } do_execsql_test 4.3.1 { CREATE TABLE t2(a, b, c, d, PRIMARY KEY(c, b)); INSERT INTO t2 VALUES('.', 1, 1, '.'); INSERT INTO t2 VALUES('.', 1, 2, '.'); INSERT INTO t2 VALUES('.', 2, 1, '.'); INSERT INTO t2 VALUES('.', 2, 2, '.'); } # INSERT + INSERT do_patchconcat_test 4.3.2 -revert { INSERT INTO t2 VALUES('a', 'a', 'a', 'a'); } { INSERT INTO t2 VALUES('b', 'a', 'a', 'b'); } { {INSERT t2 0 .XX. {} {t a t a t a t a}} } # INSERT + DELETE do_patchconcat_test 4.3.3 { INSERT INTO t2 VALUES('a', 'a', 'a', 'a'); } { DELETE FROM t2 WHERE c = 'a'; } { } # INSERT + UPDATE do_patchconcat_test 4.3.4 { INSERT INTO t2 VALUES('a', 'a', 'a', 'a'); } { UPDATE t2 SET d = 'b' WHERE c='a'; } { {INSERT t2 0 .XX. {} {t a t a t a t b}} } # UPDATE + UPDATE do_patchconcat_test 4.3.5 { UPDATE t2 SET a = 'a' WHERE c=1 AND b=2; } { UPDATE t2 SET d = 'd' WHERE c=1 AND b=2; } { {UPDATE t2 0 .XX. {{} {} i 2 i 1 {} {}} {t a {} {} {} {} t d}} } # UPDATE + DELETE do_patchconcat_test 4.3.6 { UPDATE t2 SET a = 'a' WHERE c=1 AND b=2; } { DELETE FROM t2 WHERE c=1 AND b=2; } { {DELETE t2 0 .XX. {{} {} i 2 i 1 {} {}} {}} } # DELETE + INSERT do_patchconcat_test 4.3.7 { DELETE FROM t2 WHERE b=1; } { INSERT INTO t2 VALUES('x', 1, 2, '.'); } { {DELETE t2 0 .XX. {{} {} i 1 i 1 {} {}} {}} {UPDATE t2 0 .XX. {{} {} i 1 i 2 {} {}} {t x {} {} {} {} t .}} } # DELETE + UPDATE do_patchconcat_test 4.3.8 -revert { DELETE FROM t2 WHERE b=1 AND c=2; } { UPDATE t2 SET a=5 WHERE b=1 AND c=2; } { {DELETE t2 0 .XX. {{} {} i 1 i 2 {} {}} {}} } # DELETE + UPDATE do_patchconcat_test 4.3.9 -revert { DELETE FROM t2 WHERE b=1 AND c=2; } { DELETE FROM t2 WHERE b=1; } { {DELETE t2 0 .XX. {{} {} i 1 i 1 {} {}} {}} {DELETE t2 0 .XX. {{} {} i 1 i 2 {} {}} {}} } finish_test |
Changes to ext/session/sqlite3session.c.
︙ | ︙ | |||
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 | } /* ** 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(). */ static unsigned int sessionChangeHash( SessionTable *pTab, /* Table handle */ 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]; /* 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 | > > > > > | 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 | } /* ** 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 |
︙ | ︙ | |||
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 | ** 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 */ u8 *aLeft, /* Change record */ 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++){ int n1 = sessionSerialLen(a1); int n2 = sessionSerialLen(a2); if( pTab->abPK[iCol] && (n1!=n2 || memcmp(a1, a2, n1)) ){ return 0; } | > > | | | 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 | ** 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, u8 *aLeft, /* Change record */ int bRightPkOnly, 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++){ int n1 = sessionSerialLen(a1); int n2 = sessionSerialLen(a2); if( pTab->abPK[iCol] && (n1!=n2 || memcmp(a1, a2, n1)) ){ return 0; } if( pTab->abPK[iCol] || bLeftPkOnly==0 ) a1 += n1; if( pTab->abPK[iCol] || bRightPkOnly==0 ) a2 += n2; } return 1; } /* ** Arguments aLeft and aRight both point to buffers containing change |
︙ | ︙ | |||
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 | /* ** 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 */ 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; | > > > | | | | | | | | | | | | | | | | | | | > > | > | 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 | /* ** 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, 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; } } |
︙ | ︙ | |||
750 751 752 753 754 755 756 | ** 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. */ | | > | | 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 | ** 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); |
︙ | ︙ | |||
956 957 958 959 960 961 962 | if( pSession->rc ) return; /* Load table details if required */ if( sessionInitTable(pSession, pTab) ) return; /* Grow the hash table if required */ | | | 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 | if( pSession->rc ) return; /* Load table details if required */ if( sessionInitTable(pSession, pTab) ) 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. */ |
︙ | ︙ | |||
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 | /* ** 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 */ 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 */ ){ | > | 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 | /* ** 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 */ ){ |
︙ | ︙ | |||
3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 | || (op1==SQLITE_DELETE && op2==SQLITE_DELETE) ){ pNew = pExist; }else if( op1==SQLITE_INSERT && op2==SQLITE_DELETE ){ sqlite3_free(pExist); assert( pNew==0 ); }else{ int nByte; u8 *aCsr; 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; | > > > > | | | | > | | > | > > > > | > > | 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 | || (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 ) sessionReadRecord(&a1, pTab->nCol, 0, 0); sessionMergeRecord(&aCsr, pTab->nCol, aExist, a1); }else if( op1==SQLITE_DELETE ){ /* DELETE + INSERT */ assert( op2==SQLITE_INSERT ); pNew->op = SQLITE_UPDATE; 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 ){ sessionReadRecord(&a1, pTab->nCol, 0, 0); sessionReadRecord(&a2, pTab->nCol, 0, 0); } 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 passed via the first two arguments to ** hash tables. */ static int sessionConcatChangeset( int bPatchset, /* True to expect patchsets */ int nChangeset, /* Number of bytes in pChangeset */ void *pChangeset, /* Changeset buffer */ SessionTable **ppTabList /* IN/OUT: List of table objects */ ){ u8 *aRec; int nRec; sqlite3_changeset_iter *pIter; |
︙ | ︙ | |||
3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 | int nCol; int op; int iHash; int bIndirect; SessionChange *pChange; SessionChange *pExist = 0; SessionChange **pp; assert( pIter->apValue==0 ); sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect); assert( zNew>=(char *)pChangeset && zNew-nChangeset<((char *)pChangeset) ); assert( !pTab || pTab->zName-nChangeset<(char *)pChangeset ); assert( !pTab || zNew>=pTab->zName ); | > > > > > > > | 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 | int nCol; int op; int iHash; int bIndirect; SessionChange *pChange; SessionChange *pExist = 0; SessionChange **pp; assert( bPatchset==0 || bPatchset==1 ); assert( pIter->bPatchset==0 || pIter->bPatchset==1 ); if( pIter->bPatchset!=bPatchset ){ rc = SQLITE_ERROR; break; } assert( pIter->apValue==0 ); sqlite3changeset_op(pIter, &zNew, &nCol, &op, &bIndirect); assert( zNew>=(char *)pChangeset && zNew-nChangeset<((char *)pChangeset) ); assert( !pTab || pTab->zName-nChangeset<(char *)pChangeset ); assert( !pTab || zNew>=pTab->zName ); |
︙ | ︙ | |||
3331 3332 3333 3334 3335 3336 3337 | }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){ rc = SQLITE_SCHEMA; break; } pTab->zName = (char *)zNew; } | | | > > > > > > > > | | > > | 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 | }else if( pTab->nCol!=nCol || memcmp(pTab->abPK, abPK, nCol) ){ rc = SQLITE_SCHEMA; break; } pTab->zName = (char *)zNew; } if( sessionGrowHash(bPatchset, pTab) ){ rc = SQLITE_NOMEM; break; } iHash = sessionChangeHash( pTab, (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( 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, bPatchset, pExist, op, bIndirect, aRec, nRec, &pChange ); if( rc ) break; if( pChange ){ pChange->pNext = pTab->apChange[iHash]; pTab->apChange[iHash] = pChange; pTab->nEntry++; } } |
︙ | ︙ | |||
3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 | 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) */ ){ SessionTable *pList = 0; /* List of SessionTable objects */ int rc; /* Return code */ *pnOut = 0; *ppOut = 0; | > > | | | | 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 | 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) */ ){ SessionTable *pList = 0; /* List of SessionTable objects */ int rc; /* Return code */ int bPatch; /* True for a patchset */ *pnOut = 0; *ppOut = 0; bPatch = (nLeft>0 && *(char*)pLeft=='P') || (nRight>0 && *(char*)pRight=='P'); rc = sessionConcatChangeset(bPatch, nLeft, pLeft, &pList); if( rc==SQLITE_OK ){ rc = sessionConcatChangeset(bPatch, nRight, pRight, &pList); } /* Create the serialized output changeset based on the contents of the ** hash tables attached to the SessionTable objects in list pList. */ if( rc==SQLITE_OK ){ SessionTable *pTab; SessionBuffer buf = {0, 0, 0}; for(pTab=pList; pTab; pTab=pTab->pNext){ int i; if( pTab->nEntry==0 ) continue; sessionAppendTableHdr(&buf, 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); } |
︙ | ︙ |