diff --git a/manifest b/manifest index 68dfcd2302..6f1b232f46 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Fix\ssome\sauthorization\scallback\sproblems. -D 2009-08-31T08:22:46 +C More\sfixes\sfor\stest\scases. +D 2009-08-31T15:27:28 F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0 F Makefile.in 73ddeec9dd10b85876c5c2ce1fdce627e1dcc7f8 F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654 @@ -113,15 +113,15 @@ F src/build.c 212476dc971756e7f7429e677059fafc678afbd5 F src/callback.c 9bc0ae998f15207d3115224979331c0aafc9bcc3 F src/complete.c 5ad5c6cd4548211867c204c41a126d73a9fbcea0 F src/date.c ab5f7137656652a48434d64f96bdcdc823bb23b3 -F src/delete.c 5b7c810b7e70e1c4abe1d2532f97003565b14b61 -F src/expr.c ac30c21eef64684b5709d01f06dc3fb72eee1fdc +F src/delete.c 6b95963dabd558d45385e9b5be1fb4aa7ba7fa62 +F src/expr.c d95a040f0633d0f33b7c7123ad09463dcb828538 F src/fault.c dc88c821842157460750d2d61a8a8b4197d047ff F src/func.c e536218d193b8d326aab91120bc4c6f28aa2b606 F src/global.c 271952d199a8cc59d4ce840b3bbbfd2f30c8ba32 F src/hash.c ebcaa921ffd9d86f7ea5ae16a0a29d1c871130a7 F src/hash.h 35b216c13343d0b4f87d9f21969ac55ad72174e1 F src/hwtime.h 4a1d45f4cae1f402ea19686acf24acf4f0cb53cb -F src/insert.c 5b548c8070b492269f7dab999a0e2b4ae21516e2 +F src/insert.c 845f0f5aee678e131e3e944bb2ceea25b915bb1b F src/journal.c e00df0c0da8413ab6e1bb7d7cab5665d4a9000d0 F src/legacy.c 303b4ffcf1ae652fcf5ef635846c563c254564f6 F src/lempar.c 0c4d1ab0a5ef2b0381eb81a732c54f68f27a574d @@ -154,16 +154,16 @@ F src/pcache.c c92ffd4f3e1279b3766854c6d18b5bf4aac0d1fa F src/pcache.h 435ef324197f79391f9c92b71d7f92b548ad7a36 F src/pcache1.c 211295a9ff6a5b30f1ca50516731a5cf3e9bf82c F src/pragma.c 6b1fa9f180d88b3f905cebd593ef6aef9334be43 -F src/prepare.c 49739b385c4cd0667cfa9941c41bf6d4f8edc157 +F src/prepare.c 1be1832c0dea54dda436f8269e51372b7d0660af F src/printf.c 508a1c59433353552b6553cba175eaa7331f8fc1 F src/random.c 676b9d7ac820fe81e6fb2394ac8c10cff7f38628 -F src/resolve.c 5909b3e2fb7e05fc2695cd250a4f672ea2dc1499 +F src/resolve.c 522d6804a058937db9a7c6fd50ec0845abfff84c F src/rowset.c c64dafba1f9fd876836c8db8682966b9d197eb1f F src/select.c 56ecb073e6f6696173ad80493aa14355225b6e53 F src/shell.c db2643650b9268df89a4bedca3f1c6d9e786f1bb F src/sqlite.h.in 9d03ceaad971882482c158c0e3d39d361c2c18a1 F src/sqlite3ext.h 1db7d63ab5de4b3e6b83dd03d1a4e64fef6d2a17 -F src/sqliteInt.h d87eb4976edacb68fb9b7557163ae0def733354b +F src/sqliteInt.h 9036e5d0162426f94fa3989c537167586d731bef F src/sqliteLimit.h ffe93f5a0c4e7bd13e70cd7bf84cfb5c3465f45d F src/status.c 237b193efae0cf6ac3f0817a208de6c6c6ef6d76 F src/table.c cc86ad3d6ad54df7c63a3e807b5783c90411a08d @@ -200,12 +200,12 @@ F src/test_tclvar.c 9e42fa59d3d2f064b7ab8628e7ab2dc8a9fe93d4 F src/test_thread.c b8a1ab7ca1a632f18e8a361880d5d65eeea08eac F src/test_wsd.c 3ae5101de6cbfda2720152ab659ea84079719241 F src/tokenize.c af8a56e6a50c5042fc305bfa796275e9bf26ff2b -F src/trigger.c 2b0bdab4807cc0795afd8b7c88b503674994a43d -F src/update.c 574464e0049eb289ab863c583f84474b5b76cd39 +F src/trigger.c d652d3a073d17bfa9bd9af88350206a81ef08d71 +F src/update.c 12ffd68c2f241c730d5e051eb29b23e90682ff8a F src/utf.c 3ca2c9461b8e942c68da28bfccd448663f536a6f F src/util.c efb5f8e533d4beef545cf765cab5f7920b4c75f9 F src/vacuum.c 3fe0eebea6d2311c1c2ab2962887d11f7a4dcfb0 -F src/vdbe.c 5e9d870ec390fbc329f11424b121681e8da5d75c +F src/vdbe.c 69890b64d5f7a5ef0e5f0479baa79cb65da4e018 F src/vdbe.h 080fe6bc1264438becb8bf9b9f3c84074c336b78 F src/vdbeInt.h 1291908344bcbaa8cf47de86d7108cb92c3a71a3 F src/vdbeapi.c 8d5013ab6104be757c208a70ffb191cc27d2b688 @@ -662,7 +662,7 @@ F test/tkt3918.test e6cdf6bfcfe9ba939d86a4238a9dc55d6eec5d42 F test/tkt3922.test 022ace32c049e3964f68492c12eb803e8e4856d8 F test/tkt3929.test 6a4c3baefb4e75127356b7d675b5df42c35c00d1 F test/tkt3935.test e15261fedb9e30a4305a311da614a5d8e693c767 -F test/tkt3992.test 2ba939cc646eaa46761dfd55f975cad69bf4e254 +F test/tkt3992.test 88bd3d596b4b5ce4cbdf5b2f564d1321276ee097 F test/tkt3997.test a335fa41ca3985660a139df7b734a26ef53284bd F test/tkt4018.test 7c2c9ba4df489c676a0a7a0e809a1fb9b2185bd1 F test/tokenize.test ce430a7aed48fc98301611429595883fdfcab5d7 @@ -748,7 +748,7 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224 F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e F tool/vdbe-compress.tcl 672f81d693a03f80f5ae60bfefacd8a349e76746 -P 6e09e28751a7071969ef9f3445f4092d2c28f358 -R 81cbde85639275506b291e783c709236 +P 8a746fbfd51f70f56e25ade59df49d2dc03c131c +R c8861b3298b0eed46e58ea3f1386cd62 U dan -Z 54e813eac61f6f88a2d6f341a5499c38 +Z 83f9b1037a455c2681b775be9c2fdcd7 diff --git a/manifest.uuid b/manifest.uuid index f38085d800..eb06e434f1 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -8a746fbfd51f70f56e25ade59df49d2dc03c131c \ No newline at end of file +85d9f23be1e8673dbda42e43b9b23332ada9225f \ No newline at end of file diff --git a/src/delete.c b/src/delete.c index d4328d5b04..ae4a8b5846 100644 --- a/src/delete.c +++ b/src/delete.c @@ -391,12 +391,11 @@ void sqlite3DeleteFrom( ** data required by the old.* references in the trigger bodies. */ if( pTrigger ){ u32 mask = 0; /* Mask of OLD.* columns in use */ - u32 dummy = 0; /* Unused. Initialized to prevent valgrind error. */ pParse->nMem += pTab->nCol; /* Open the pseudo-table used to store OLD if there are triggers. */ - sqlite3TriggerUses( - pParse, pTrigger, TK_DELETE, 0, pTab, OE_Default, &mask, &dummy); + mask = sqlite3TriggerOldmask( + pParse, pTrigger, TK_DELETE, 0, pTab, OE_Default); /* If the record is no longer present in the table, jump to the ** next iteration of the loop through the contents of the fifo. diff --git a/src/expr.c b/src/expr.c index d5dda96ca0..c50a2c077c 100644 --- a/src/expr.c +++ b/src/expr.c @@ -2559,13 +2559,19 @@ int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){ } case TK_TRIGGER: { - int iVal = pExpr->iTable * (pExpr->pTab->nCol+1) + 1 + pExpr->iColumn; + Table *pTab = pExpr->pTab; + int iVal = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn; sqlite3VdbeAddOp2(v, OP_Param, iVal, target); VdbeComment((v, "%s.%s -> $%d", (pExpr->iTable ? "new" : "old"), (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName), target )); + if( pExpr->iColumn>=0 + && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL + ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + } break; } diff --git a/src/insert.c b/src/insert.c index 7afdd97c5c..95da84ee8a 100644 --- a/src/insert.c +++ b/src/insert.c @@ -979,8 +979,7 @@ void sqlite3Insert( keyColumn>=0, 0, onError, endOfLoop, &isReplace ); sqlite3CompleteInsertion( - pParse, pTab, baseCur, regIns, aRegIdx, 0, - (tmask&TRIGGER_AFTER) ? newIdx : -1, appendFlag, isReplace==0 + pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0 ); } } @@ -1376,7 +1375,6 @@ void sqlite3CompleteInsertion( int regRowid, /* Range of content */ int *aRegIdx, /* Register used by each index. 0 for unused indices */ int isUpdate, /* True for UPDATE, False for INSERT */ - int newIdx, /* Index of NEW table for triggers. -1 if none */ int appendBias, /* True if this is likely to be an append */ int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */ ){ diff --git a/src/prepare.c b/src/prepare.c index cd25d5a1f9..a1e5b3f8e1 100644 --- a/src/prepare.c +++ b/src/prepare.c @@ -676,9 +676,9 @@ static int sqlite3Prepare( sqlite3Error(db, rc, 0); } - while( pParse->pCodedTrigger ){ - CodedTrigger *pT = pParse->pCodedTrigger; - pParse->pCodedTrigger = pT->pNext; + while( pParse->pTriggerPrg ){ + TriggerPrg *pT = pParse->pTriggerPrg; + pParse->pTriggerPrg = pT->pNext; sqlite3VdbeProgramDelete(db, pT->pProgram, 0); sqlite3DbFree(db, pT); } diff --git a/src/resolve.c b/src/resolve.c index 2c4d4f2ed0..b8e5202541 100644 --- a/src/resolve.c +++ b/src/resolve.c @@ -225,15 +225,12 @@ static int lookupName( */ if( zDb==0 && zTab!=0 && cnt==0 && pParse->pTriggerTab!=0 ){ Table *pTab = 0; - u32 *piColMask = 0; if( pParse->triggerOp!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){ pExpr->iTable = 1; pTab = pParse->pTriggerTab; - piColMask = &(pParse->newmask); }else if( pParse->triggerOp!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){ pExpr->iTable = 0; pTab = pParse->pTriggerTab; - piColMask = &(pParse->oldmask); } if( pTab ){ @@ -246,13 +243,6 @@ static int lookupName( for(iCol=0; iColnCol; iCol++){ Column *pCol = &pTab->aCol[iCol]; if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ - testcase( iCol==31 ); - testcase( iCol==32 ); - if( iCol>=32 ){ - *piColMask = 0xffffffff; - }else{ - *piColMask |= ((u32)1)<iPKey ){ iCol = -1; } @@ -264,6 +254,10 @@ static int lookupName( cnt++; if( iCol<0 ){ pExpr->affinity = SQLITE_AFF_INTEGER; + }else if( pExpr->iTable==0 ){ + testcase( iCol==31 ); + testcase( iCol==32 ); + pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<iColumn = iCol; pExpr->pTab = pTab; diff --git a/src/sqliteInt.h b/src/sqliteInt.h index 278a179815..c394e4aa0c 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -611,7 +611,7 @@ typedef struct StrAccum StrAccum; typedef struct Table Table; typedef struct TableLock TableLock; typedef struct Token Token; -typedef struct TriggerStack TriggerStack; +typedef struct TriggerPrg TriggerPrg; typedef struct TriggerStep TriggerStep; typedef struct Trigger Trigger; typedef struct UnpackedRecord UnpackedRecord; @@ -1577,7 +1577,8 @@ struct Expr { *********************************************************************/ int iTable; /* TK_COLUMN: cursor number of table holding column - ** TK_REGISTER: register number */ + ** TK_REGISTER: register number + ** TK_TRIGGER: 1 -> new, 0 -> old */ i16 iColumn; /* TK_COLUMN: column index. -1 for rowid */ i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */ @@ -2016,14 +2017,25 @@ struct AutoincInfo { # define SQLITE_N_COLCACHE 10 #endif -typedef struct CodedTrigger CodedTrigger; -struct CodedTrigger { - SubProgram *pProgram; - Trigger *pTrigger; - u32 oldmask; /* Mask of old.* columns accessed */ - u32 newmask; /* Mask of new.* columns accessed */ +/* +** At least one instance of the following structure is created for each +** trigger that may be fired while parsing an INSERT, UPDATE or DELETE +** statement. All such objects are stored in the linked list headed at +** Parse.pTriggerPrg and deleted once statement compilation has been +** completed. +** +** A Vdbe sub-program that implements the body and WHEN clause of trigger +** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of +** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable. +** The Parse.pTriggerPrg list never contains two entries with the same +** values for both pTrigger and orconf. +*/ +struct TriggerPrg { + Trigger *pTrigger; /* Trigger this program was coded from */ int orconf; /* Default ON CONFLICT policy */ - CodedTrigger *pNext; + SubProgram *pProgram; /* Program implementing pTrigger/orconf */ + u32 oldmask; /* Mask of old.* columns accessed */ + TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */ }; /* @@ -2112,9 +2124,6 @@ struct Parse { const char *zTail; /* All SQL text past the last semicolon parsed */ Table *pNewTable; /* A table being constructed by CREATE TABLE */ Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ -#if 0 - TriggerStack *trigStack; /* Trigger actions being coded */ -#endif const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ #ifndef SQLITE_OMIT_VIRTUALTABLE Token sArg; /* Complete text of a module argument */ @@ -2124,7 +2133,7 @@ struct Parse { #endif int nHeight; /* Expression tree height of current sub-select */ Table *pZombieTab; /* List of Table objects to delete after code gen */ - CodedTrigger *pCodedTrigger; /* Linked list of coded triggers */ + TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ }; #ifdef SQLITE_OMIT_VIRTUALTABLE @@ -2241,45 +2250,6 @@ struct TriggerStep { TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ }; -/* - * An instance of struct TriggerStack stores information required during code - * generation of a single trigger program. While the trigger program is being - * coded, its associated TriggerStack instance is pointed to by the - * "pTriggerStack" member of the Parse structure. - * - * The pTab member points to the table that triggers are being coded on. The - * newIdx member contains the index of the vdbe cursor that points at the temp - * table that stores the new.* references. If new.* references are not valid - * for the trigger being coded (for example an ON DELETE trigger), then newIdx - * is set to -1. The oldIdx member is analogous to newIdx, for old.* references. - * - * The ON CONFLICT policy to be used for the trigger program steps is stored - * as the orconf member. If this is OE_Default, then the ON CONFLICT clause - * specified for individual triggers steps is used. - * - * struct TriggerStack has a "pNext" member, to allow linked lists to be - * constructed. When coding nested triggers (triggers fired by other triggers) - * each nested trigger stores its parent trigger's TriggerStack as the "pNext" - * pointer. Once the nested trigger has been coded, the pNext value is restored - * to the pTriggerStack member of the Parse stucture and coding of the parent - * trigger continues. - * - * Before a nested trigger is coded, the linked list pointed to by the - * pTriggerStack is scanned to ensure that the trigger is not about to be coded - * recursively. If this condition is detected, the nested trigger is not coded. - */ -struct TriggerStack { - Table *pTab; /* Table that triggers are currently being coded on */ - int newIdx; /* Index of vdbe cursor to "new" temp table */ - int oldIdx; /* Index of vdbe cursor to "old" temp table */ - u32 newColMask; - u32 oldColMask; - int orconf; /* Current orconf policy */ - int ignoreJump; /* where to jump to for a RAISE(IGNORE) */ - Trigger *pTrigger; /* The trigger currently being coded */ - TriggerStack *pNext; /* Next trigger down on the trigger stack */ -}; - /* ** The following structure contains information used by the sqliteFix... ** routines as they walk the parse tree to make database references @@ -2674,7 +2644,7 @@ void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*); int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int); void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int, int*,int,int,int,int,int*); -void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int,int,int); +void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int); int sqlite3OpenTableAndIndices(Parse*, Table*, int, int); void sqlite3BeginWriteOperation(Parse*, int, int); Expr *sqlite3ExprDup(sqlite3*,Expr*,int); @@ -2721,7 +2691,7 @@ void sqlite3MaterializeView(Parse*, Table*, Expr*, int); TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*); void sqlite3DeleteTrigger(sqlite3*, Trigger*); void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); - void sqlite3TriggerUses(Parse*,Trigger*,int,ExprList*,Table*,int,u32*,u32*); + u32 sqlite3TriggerOldmask(Parse*,Trigger*,int,ExprList*,Table*,int); #else # define sqlite3TriggersExist(B,C,D,E,F) 0 # define sqlite3DeleteTrigger(A,B) diff --git a/src/trigger.c b/src/trigger.c index 8442ec2e74..964db70de8 100644 --- a/src/trigger.c +++ b/src/trigger.c @@ -681,7 +681,6 @@ static int codeTriggerProgram( assert( pParse->pRoot ); assert( pStep!=0 ); assert( v!=0 ); -/* sqlite3VdbeAddOp2(v, OP_ContextPush, 0, 0); */ while( pStep ){ /* Figure out the ON CONFLICT policy that will be used for this step ** of the trigger program. If the statement that caused this trigger @@ -698,10 +697,6 @@ static int codeTriggerProgram( */ pParse->orconf = (orconfin==OE_Default)?pStep->orconf:orconfin; - if( pStep->op!=TK_SELECT ){ - sqlite3VdbeAddOp1(v, OP_ResetCount, 0); - } - switch( pStep->op ){ case TK_UPDATE: { sqlite3Update(pParse, @@ -743,7 +738,6 @@ static int codeTriggerProgram( } pStep = pStep->pNext; } -/* sqlite3VdbeAddOp2(v, OP_ContextPop, 0, 0); */ return 0; } @@ -782,7 +776,7 @@ static void transferParseError(Parse *pTo, Parse *pFrom){ } } -static CodedTrigger *codeRowTrigger( +static TriggerPrg *codeRowTrigger( Parse *pRoot, /* Root parse context */ Parse *pParse, /* Current parse context */ Trigger *pTrigger, /* Trigger to code */ @@ -791,28 +785,27 @@ static CodedTrigger *codeRowTrigger( int orconf ){ sqlite3 *db = pParse->db; - CodedTrigger *pC; + TriggerPrg *pPrg; Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */ Vdbe *v; /* Temporary VM */ - AuthContext sContext; /* Auth context for sub-vdbe */ NameContext sNC; /* Name context for sub-vdbe */ SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */ Parse *pSubParse; /* Parse context for sub-vdbe */ int iEndTrigger = 0; /* Label to jump to if WHEN is false */ - pC = sqlite3DbMallocZero(db, sizeof(CodedTrigger)); - if( !pC ) return 0; - pC->pNext = pRoot->pCodedTrigger; - pRoot->pCodedTrigger = pC; - pC->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram)); + pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg)); + if( !pPrg ) return 0; + pPrg->pNext = pRoot->pTriggerPrg; + pRoot->pTriggerPrg = pPrg; + pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram)); if( !pProgram ) return 0; pProgram->nRef = 1; pSubParse = sqlite3StackAllocZero(db, sizeof(Parse)); if( !pSubParse ) return 0; - pC->pProgram = pProgram; - pC->pTrigger = pTrigger; - pC->orconf = orconf; + pPrg->pProgram = pProgram; + pPrg->pTrigger = pTrigger; + pPrg->orconf = orconf; memset(&sNC, 0, sizeof(sNC)); sNC.pParse = pSubParse; @@ -865,8 +858,7 @@ static CodedTrigger *codeRowTrigger( pProgram->nMem = pSubParse->nMem; pProgram->nCsr = pSubParse->nTab; pProgram->token = (void *)pTrigger; - pC->oldmask = pSubParse->oldmask; - pC->newmask = pSubParse->newmask; + pPrg->oldmask = pSubParse->oldmask; sqlite3VdbeDelete(v); while( pSubParse->pAinc ){ @@ -877,36 +869,36 @@ static CodedTrigger *codeRowTrigger( } sqlite3StackFree(db, pSubParse); - return pC; + return pPrg; } -static CodedTrigger *getRowTrigger( +static TriggerPrg *getRowTrigger( Parse *pParse, Trigger *pTrigger, /* Trigger to code */ int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ Table *pTab, /* The table to code triggers from */ int orconf ){ - CodedTrigger *pC; + TriggerPrg *pPrg; Parse *pRoot = pParse; /* It may be that this trigger has already been coded (or is in the ** process of being coded). If this is the case, then an entry with - ** a matching CodedTrigger.pTrigger field will be present somewhere - ** in the Parse.pCodedTrigger list. Search for such an entry. */ + ** a matching TriggerPrg.pTrigger field will be present somewhere + ** in the Parse.pTriggerPrg list. Search for such an entry. */ if( pParse->pRoot ){ pRoot = pParse->pRoot; } - for(pC=pRoot->pCodedTrigger; - pC && (pC->pTrigger!=pTrigger || pC->orconf!=orconf); - pC=pC->pNext + for(pPrg=pRoot->pTriggerPrg; + pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf); + pPrg=pPrg->pNext ); - if( !pC ){ - pC = codeRowTrigger(pRoot, pParse, pTrigger, op, pTab, orconf); + if( !pPrg ){ + pPrg = codeRowTrigger(pRoot, pParse, pTrigger, op, pTab, orconf); } - return pC; + return pPrg; } /* @@ -969,45 +961,64 @@ void sqlite3CodeRowTrigger( && checkColumnOverlap(p->pColumns,pChanges) ){ Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */ - CodedTrigger *pC; - pC = getRowTrigger(pParse, p, op, pTab, orconf); - assert( pC || pParse->nErr || pParse->db->mallocFailed ); + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, op, pTab, orconf); + assert( pPrg || pParse->nErr || pParse->db->mallocFailed ); /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program ** is a pointer to the sub-vdbe containing the trigger program. */ - if( pC ){ + if( pPrg ){ sqlite3VdbeAddOp3(v, OP_Program, oldIdx, ignoreJump, ++pParse->nMem); - pC->pProgram->nRef++; - sqlite3VdbeChangeP4(v, -1, (const char *)pC->pProgram, P4_SUBPROGRAM); + pPrg->pProgram->nRef++; + sqlite3VdbeChangeP4(v, -1, (const char *)pPrg->pProgram, P4_SUBPROGRAM); VdbeComment((v, "Call: %s.%s", p->zName, onErrorText(orconf))); } } } } -void sqlite3TriggerUses( +/* +** Triggers fired by UPDATE or DELETE statements may access values stored +** in the old.* pseudo-table. This function returns a 32-bit bitmask +** indicating which columns of the old.* table actually are used by +** triggers. This information may be used by the caller to avoid having +** to load the entire old.* record into memory when executing an UPDATE +** or DELETE command. +** +** Bit 0 of the returned mask is set if the left-most column of the +** table may be accessed using an old. reference. Bit 1 is set if +** the second leftmost column value is required, and so on. If there +** are more than 32 columns in the table, and at least one of the columns +** with an index greater than 32 may be accessed, 0xffffffff is returned. +** +** It is not possible to determine if the old.rowid column is accessed +** by triggers. The caller must always assume that it is. +** +** There is no equivalent function for new.* references. +*/ +u32 sqlite3TriggerOldmask( Parse *pParse, /* Parse context */ Trigger *pTrigger, /* List of triggers on table pTab */ - int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ + int op, /* Either TK_UPDATE or TK_DELETE */ ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ Table *pTab, /* The table to code triggers from */ - int orconf, /* Default ON CONFLICT policy for trigger steps */ - u32 *piOldColMask, /* OUT: Mask of columns used from the OLD.* table */ - u32 *piNewColMask /* OUT: Mask of columns used from the NEW.* table */ + int orconf /* Default ON CONFLICT policy for trigger steps */ ){ + u32 mask = 0; Trigger *p; - assert(op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE); + assert(op==TK_UPDATE || op==TK_DELETE); for(p=pTrigger; p; p=p->pNext){ if( p->op==op && checkColumnOverlap(p->pColumns,pChanges) ){ - CodedTrigger *pC; - pC = getRowTrigger(pParse, p, op, pTab, orconf); - if( pC ){ - *piOldColMask |= pC->oldmask; - *piNewColMask |= pC->newmask; + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, op, pTab, orconf); + if( pPrg ){ + mask |= pPrg->oldmask; } } } + + return mask; } #endif /* !defined(SQLITE_OMIT_TRIGGER) */ diff --git a/src/update.c b/src/update.c index d44aace9a7..8015b04cc4 100644 --- a/src/update.c +++ b/src/update.c @@ -120,8 +120,7 @@ void sqlite3Update( int isView; /* Trying to update a view */ Trigger *pTrigger; /* List of triggers on pTab, if required */ #endif - u32 old_col_mask = 0; /* Mask of OLD.* columns in use */ - u32 new_col_mask = 0; /* Mask of NEW.* columns in use */ + u32 oldmask = 0; /* Mask of OLD.* columns in use */ /* Register Allocations */ int regRowCount = 0; /* A count of rows changed */ @@ -290,10 +289,9 @@ void sqlite3Update( sqlite3AuthContextPush(pParse, &sContext, pTab->zName); } - /* If there are any triggers, set old_col_mask and new_col_mask. */ - sqlite3TriggerUses(pParse, - pTrigger, TK_UPDATE, pChanges, pTab, onError, &old_col_mask, &new_col_mask - ); + /* If there are any triggers, set oldmask and new_col_mask. */ + oldmask = sqlite3TriggerOldmask( + pParse, pTrigger, TK_UPDATE, pChanges, pTab, onError); /* If we are trying to update a view, realize that view into ** a ephemeral table. @@ -384,7 +382,7 @@ void sqlite3Update( ** with the required old.* column data. */ if( pTrigger ){ for(i=0; inCol; i++){ - if( aXRef[i]<0 || old_col_mask==0xffffffff || (old_col_mask & (1<nCol, regRec); - sqlite3TableAffinityStr(v, pTab); - sqlite3ExprCacheAffinityChange(pParse, regNew, pTab->nCol); - } -#endif - /* Fire any BEFORE UPDATE triggers. This happens before constraints are ** verified. One could argue that this is wrong. */ - sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, - TRIGGER_BEFORE, pTab, -1, regOldRowid, onError, addr); + if( pTrigger ){ + sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol); + sqlite3TableAffinityStr(v, pTab); + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_BEFORE, pTab, -1, regOldRowid, onError, addr); + } if( !isView ){ @@ -458,20 +447,7 @@ void sqlite3Update( sqlite3VdbeJumpHere(v, j1); /* Insert the new index entries and the new record. */ - sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, -1, 0, 0); - -#if 0 - for(i=0; inested ){ - sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_STATIC); - sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_ISUPDATE); - } -#endif + sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0); } /* Increment the row counter diff --git a/src/vdbe.c b/src/vdbe.c index 1ce352342b..bd51386079 100644 --- a/src/vdbe.c +++ b/src/vdbe.c @@ -847,15 +847,23 @@ case OP_HaltIfNull: { /* in3 */ */ case OP_Halt: { if( pOp->p1==SQLITE_OK && p->pFrame ){ + /* Halt the sub-program. Return control to the parent frame. */ VdbeFrame *pFrame = p->pFrame; p->pFrame = pFrame->pParent; p->nFrame--; + sqlite3VdbeSetChanges(db, p->nChange); pc = sqlite3VdbeFrameRestore(pFrame); if( pOp->p2==OE_Ignore ){ + /* Instruction pc is the OP_Program that invoked the sub-program + ** currently being halted. If the p2 instruction of this OP_Halt + ** instruction is set to OE_Ignore, then the sub-program is throwing + ** an IGNORE exception. In this case jump to the address specified + ** as the p2 of the calling OP_Program. */ pc = p->aOp[pc].p2-1; } break; } + p->rc = pOp->p1; p->errorAction = (u8)pOp->p2; p->pc = pc; @@ -4846,6 +4854,7 @@ case OP_Program: { /* jump */ pFrame->pParent = p->pFrame; pFrame->lastRowid = db->lastRowid; pFrame->nChange = p->nChange; + p->nChange = 0; p->pFrame = pFrame; p->aMem = &VdbeFrameMem(pFrame)[-1]; p->nMem = pFrame->nChildMem; diff --git a/test/tkt3992.test b/test/tkt3992.test index 05cb74baa3..a3fac63ddc 100644 --- a/test/tkt3992.test +++ b/test/tkt3992.test @@ -29,7 +29,6 @@ do_test tkt3992-1.1 { INSERT INTO parameters2(mountcnt, version) VALUES(1, 1.0); } } {} -puts [execsql { SELECT *,typeof(mountcnt),typeof(version) FROM parameters1 }] do_test tkt3992-1.2 { execsql { @@ -39,12 +38,8 @@ do_test tkt3992-1.2 { } {2 1.0} do_test tkt3992-1.3 { - explain { UPDATE parameters2 SET mountcnt = mountcnt + 1 } -breakpoint execsql { - pragma vdbe_trace = 1; UPDATE parameters2 SET mountcnt = mountcnt + 1; - pragma vdbe_trace = 0; SELECT * FROM parameters2; } } {2 1.0}