Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Changes In Branch update-from Excluding Merge-Ins
This is equivalent to a diff from 73d62f82 to 270e17bb
2020-07-18
| ||
15:52 | Add UPDATE FROM compatible with postgresql. (check-in: 88baf1eb user: drh tags: trunk) | |
2020-07-17
| ||
22:20 | Add ALWAYS() around a conditional that is always true. (Closed-Leaf check-in: 270e17bb user: drh tags: update-from) | |
18:07 | Use #ifdef to omit code that is only reachable when the SQLITE_ENABLE_UPDATE_DELETE_LIMIT compile-time option is used. (check-in: 587ded60 user: drh tags: update-from) | |
2020-07-16
| ||
14:19 | Small performance improvement and size reduction in sqlite3DbStrNDup(). (check-in: 35cd8706 user: drh tags: trunk) | |
2020-07-15
| ||
20:01 | This was originally a merge to trunk. But after further testing, maybe it is better to run it a little longer on a branch. (check-in: 7d7d5ecb user: dan tags: update-from) | |
11:00 | Update this branch with changes from trunk. (check-in: 53b8b507 user: dan tags: update-from) | |
02:15 | New test cases for decimal and ieee754. (check-in: 73d62f82 user: drh tags: trunk) | |
2020-07-14
| ||
23:58 | Improvements to the min()/max() optimization so that it is able to use indexes where terms are constrained by IN operators. (check-in: b8ba2f17 user: drh tags: trunk) | |
Changes to src/alter.c.
︙ | ︙ | |||
1187 1188 1189 1190 1191 1192 1193 | for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){ if( pStep->pSelect ){ sqlite3SelectPrep(pParse, pStep->pSelect, &sNC); if( pParse->nErr ) rc = pParse->rc; } if( rc==SQLITE_OK && pStep->zTarget ){ | > > > > > | > | | > > | < < < < < > > | | | > > > | 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 | for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){ if( pStep->pSelect ){ sqlite3SelectPrep(pParse, pStep->pSelect, &sNC); if( pParse->nErr ) rc = pParse->rc; } if( rc==SQLITE_OK && pStep->zTarget ){ SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep); if( pSrc ){ int i; for(i=0; i<pSrc->nSrc; i++){ struct SrcList_item *p = &pSrc->a[i]; p->pTab = sqlite3LocateTableItem(pParse, 0, p); p->iCursor = pParse->nTab++; if( p->pTab==0 ){ rc = SQLITE_ERROR; }else{ p->pTab->nTabRef++; rc = sqlite3ViewGetColumnNames(pParse, p->pTab); } } sNC.pSrcList = pSrc; if( rc==SQLITE_OK && pStep->pWhere ){ rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere); } if( rc==SQLITE_OK ){ rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList); } assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) ); if( pStep->pUpsert ){ Upsert *pUpsert = pStep->pUpsert; assert( rc==SQLITE_OK ); pUpsert->pUpsertSrc = pSrc; sNC.uNC.pUpsert = pUpsert; sNC.ncFlags = NC_UUpsert; rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); if( rc==SQLITE_OK ){ ExprList *pUpsertSet = pUpsert->pUpsertSet; rc = sqlite3ResolveExprListNames(&sNC, pUpsertSet); } if( rc==SQLITE_OK ){ rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere); } if( rc==SQLITE_OK ){ rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); } sNC.ncFlags = 0; } sNC.pSrcList = 0; sqlite3SrcListDelete(db, pSrc); }else{ rc = SQLITE_NOMEM; } } } return rc; } /* |
︙ | ︙ |
Changes to src/attach.c.
︙ | ︙ | |||
594 595 596 597 598 599 600 601 602 603 604 605 606 607 | return 1; } if( sqlite3FixExpr(pFix, pStep->pWhere) ){ return 1; } if( sqlite3FixExprList(pFix, pStep->pExprList) ){ return 1; } #ifndef SQLITE_OMIT_UPSERT if( pStep->pUpsert ){ Upsert *pUp = pStep->pUpsert; if( sqlite3FixExprList(pFix, pUp->pUpsertTarget) || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere) || sqlite3FixExprList(pFix, pUp->pUpsertSet) | > > > | 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 | return 1; } if( sqlite3FixExpr(pFix, pStep->pWhere) ){ return 1; } if( sqlite3FixExprList(pFix, pStep->pExprList) ){ return 1; } if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){ return 1; } #ifndef SQLITE_OMIT_UPSERT if( pStep->pUpsert ){ Upsert *pUp = pStep->pUpsert; if( sqlite3FixExprList(pFix, pUp->pUpsertTarget) || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere) || sqlite3FixExprList(pFix, pUp->pUpsertSet) |
︙ | ︙ |
Changes to src/build.c.
︙ | ︙ | |||
4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 | pItem->fg.notIndexed = 1; }else{ pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); pItem->fg.isIndexedBy = 1; } } } /* ** Add the list of function arguments to the SrcList entry for a ** table-valued-function. */ void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ if( p ){ | > > > > > > > > > > > > > > > > > > > > | 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 | pItem->fg.notIndexed = 1; }else{ pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); pItem->fg.isIndexedBy = 1; } } } /* ** Append the contents of SrcList p2 to SrcList p1 and return the resulting ** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2 ** are deleted by this function. */ SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){ assert( p1 && p1->nSrc==1 ); if( p2 ){ SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1); if( pNew==0 ){ sqlite3SrcListDelete(pParse->db, p2); }else{ p1 = pNew; memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(struct SrcList_item)); sqlite3DbFree(pParse->db, p2); } } return p1; } /* ** Add the list of function arguments to the SrcList entry for a ** table-valued-function. */ void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ if( p ){ |
︙ | ︙ |
Changes to src/delete.c.
︙ | ︙ | |||
27 28 29 30 31 32 33 | ** pSrc->a[0].pTab Pointer to the Table object ** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one ** */ Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ struct SrcList_item *pItem = pSrc->a; Table *pTab; | | | 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | ** pSrc->a[0].pTab Pointer to the Table object ** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one ** */ Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ struct SrcList_item *pItem = pSrc->a; Table *pTab; assert( pItem && pSrc->nSrc>=1 ); pTab = sqlite3LocateTableItem(pParse, 0, pItem); sqlite3DeleteTable(pParse->db, pItem->pTab); pItem->pTab = pTab; if( pTab ){ pTab->nTabRef++; } if( sqlite3IndexedByLookup(pParse, pItem) ){ |
︙ | ︙ |
Changes to src/mem2.c.
︙ | ︙ | |||
375 376 377 378 379 380 381 | sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); } /* ** Set the "type" of an allocation. */ void sqlite3MemdebugSetType(void *p, u8 eType){ | | | | 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 | sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); } /* ** Set the "type" of an allocation. */ void sqlite3MemdebugSetType(void *p, u8 eType){ if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ struct MemBlockHdr *pHdr; pHdr = sqlite3MemsysGetHeader(p); assert( pHdr->iForeGuard==FOREGUARD ); pHdr->eType = eType; } } /* ** Return TRUE if the mask of type in eType matches the type of the ** allocation p. Also return true if p==NULL. ** ** This routine is designed for use within an assert() statement, to ** verify the type of an allocation. For example: ** ** assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); */ int sqlite3MemdebugHasType(void *p, u8 eType){ int rc = 1; if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ struct MemBlockHdr *pHdr; pHdr = sqlite3MemsysGetHeader(p); assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ if( (pHdr->eType&eType)==0 ){ rc = 0; } } |
︙ | ︙ | |||
416 417 418 419 420 421 422 | ** This routine is designed for use within an assert() statement, to ** verify the type of an allocation. For example: ** ** assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); */ int sqlite3MemdebugNoType(void *p, u8 eType){ int rc = 1; | | | 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 | ** This routine is designed for use within an assert() statement, to ** verify the type of an allocation. For example: ** ** assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); */ int sqlite3MemdebugNoType(void *p, u8 eType){ int rc = 1; if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ struct MemBlockHdr *pHdr; pHdr = sqlite3MemsysGetHeader(p); assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ if( (pHdr->eType&eType)!=0 ){ rc = 0; } } |
︙ | ︙ |
Changes to src/parse.y.
︙ | ︙ | |||
654 655 656 657 658 659 660 | %type stl_prefix {SrcList*} %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);} %type from {SrcList*} %destructor from {sqlite3SrcListDelete(pParse->db, $$);} // A complete FROM clause. // | | | 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 | %type stl_prefix {SrcList*} %destructor stl_prefix {sqlite3SrcListDelete(pParse->db, $$);} %type from {SrcList*} %destructor from {sqlite3SrcListDelete(pParse->db, $$);} // A complete FROM clause. // from(A) ::= . {A = 0;} from(A) ::= FROM seltablist(X). { A = X; sqlite3SrcListShiftJoinType(A); } // "seltablist" is a "Select Table List" - the content of the FROM clause // in a SELECT statement. "stl_prefix" is a prefix of this list. |
︙ | ︙ | |||
886 887 888 889 890 891 892 | where_opt(A) ::= . {A = 0;} where_opt(A) ::= WHERE expr(X). {A = X;} ////////////////////////// The UPDATE command //////////////////////////////// // %if SQLITE_ENABLE_UPDATE_DELETE_LIMIT || SQLITE_UDL_CAPABLE_PARSER | | > | > | 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 | where_opt(A) ::= . {A = 0;} where_opt(A) ::= WHERE expr(X). {A = X;} ////////////////////////// The UPDATE command //////////////////////////////// // %if SQLITE_ENABLE_UPDATE_DELETE_LIMIT || SQLITE_UDL_CAPABLE_PARSER cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) from(F) where_opt(W) orderby_opt(O) limit_opt(L). { sqlite3SrcListIndexedBy(pParse, X, &I); X = sqlite3SrcListAppendList(pParse, X, F); sqlite3ExprListCheckLength(pParse,Y,"set list"); #ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT if( O || L ){ updateDeleteLimitError(pParse,O,L); O = 0; L = 0; } #endif sqlite3Update(pParse,X,Y,W,R,O,L,0); } %else cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y) from(F) where_opt(W). { sqlite3SrcListIndexedBy(pParse, X, &I); sqlite3ExprListCheckLength(pParse,Y,"set list"); X = sqlite3SrcListAppendList(pParse, X, F); sqlite3Update(pParse,X,Y,W,R,0,0,0); } %endif %type setlist {ExprList*} |
︙ | ︙ | |||
1511 1512 1513 1514 1515 1516 1517 | %type trigger_cmd {TriggerStep*} %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);} // UPDATE trigger_cmd(A) ::= | | | | 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 | %type trigger_cmd {TriggerStep*} %destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);} // UPDATE trigger_cmd(A) ::= UPDATE(B) orconf(R) trnm(X) tridxby SET setlist(Y) from(F) where_opt(Z) scanpt(E). {A = sqlite3TriggerUpdateStep(pParse, &X, F, Y, Z, R, B.z, E);} // INSERT trigger_cmd(A) ::= scanpt(B) insert_cmd(R) INTO trnm(X) idlist_opt(F) select(S) upsert(U) scanpt(Z). { A = sqlite3TriggerInsertStep(pParse,&X,F,S,R,U,B,Z);/*A-overwrites-R*/ } // DELETE |
︙ | ︙ |
Changes to src/resolve.c.
︙ | ︙ | |||
752 753 754 755 756 757 758 | for(i=0; i<pNC->pSrcList->nSrc; i++){ assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab); } } #endif switch( pExpr->op ){ | < | > | < | < < | 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 | for(i=0; i<pNC->pSrcList->nSrc; i++){ assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab); } } #endif switch( pExpr->op ){ /* The special operator TK_ROW means use the rowid for the first ** column in the FROM clause. This is used by the LIMIT and ORDER BY ** clause processing on UPDATE and DELETE statements, and by ** UPDATE ... FROM statement processing. */ case TK_ROW: { SrcList *pSrcList = pNC->pSrcList; struct SrcList_item *pItem; assert( pSrcList && pSrcList->nSrc>=1 ); pItem = pSrcList->a; pExpr->op = TK_COLUMN; pExpr->y.pTab = pItem->pTab; pExpr->iTable = pItem->iCursor; pExpr->iColumn--; pExpr->affExpr = SQLITE_AFF_INTEGER; break; } /* A column name: ID ** Or table name and column name: ID.ID ** Or a database, table and column: ID.ID.ID ** ** The TK_ID and TK_OUT cases are combined so that there will only ** be one call to lookupName(). Then the compiler will in-line |
︙ | ︙ |
Changes to src/select.c.
︙ | ︙ | |||
99 100 101 102 103 104 105 106 107 108 109 110 111 112 | /* ** Initialize a SelectDest structure. */ void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){ pDest->eDest = (u8)eDest; pDest->iSDParm = iParm; pDest->zAffSdst = 0; pDest->iSdst = 0; pDest->nSdst = 0; } /* | > | 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | /* ** Initialize a SelectDest structure. */ void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){ pDest->eDest = (u8)eDest; pDest->iSDParm = iParm; pDest->iSDParm2 = 0; pDest->zAffSdst = 0; pDest->iSdst = 0; pDest->nSdst = 0; } /* |
︙ | ︙ | |||
971 972 973 974 975 976 977 | testcase( regOrig ); testcase( eDest==SRT_Set ); testcase( eDest==SRT_Mem ); testcase( eDest==SRT_Coroutine ); testcase( eDest==SRT_Output ); assert( eDest==SRT_Set || eDest==SRT_Mem | | > | 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 | testcase( regOrig ); testcase( eDest==SRT_Set ); testcase( eDest==SRT_Mem ); testcase( eDest==SRT_Coroutine ); testcase( eDest==SRT_Output ); assert( eDest==SRT_Set || eDest==SRT_Mem || eDest==SRT_Coroutine || eDest==SRT_Output || eDest==SRT_Upfrom ); } sRowLoadInfo.regResult = regResult; sRowLoadInfo.ecelFlags = ecelFlags; #ifdef SQLITE_ENABLE_SORTER_REFERENCES sRowLoadInfo.pExtra = pExtra; sRowLoadInfo.regExtraResult = regResult + nResultCol; if( pExtra ) nResultCol += pExtra->nExpr; |
︙ | ︙ | |||
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 | sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2); sqlite3VdbeChangeP5(v, OPFLAG_APPEND); sqlite3ReleaseTempReg(pParse, r2); } sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1); break; } #ifndef SQLITE_OMIT_SUBQUERY /* If we are creating a set for an "expr IN (SELECT ...)" construct, ** then there should be a single item on the stack. Write this ** item into the set table with bogus data. */ case SRT_Set: { | > > > > > > > > > > > > > > > > > > > > | 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 | sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2); sqlite3VdbeChangeP5(v, OPFLAG_APPEND); sqlite3ReleaseTempReg(pParse, r2); } sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1); break; } case SRT_Upfrom: { #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT if( pSort ){ pushOntoSorter( pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); }else #endif { int i2 = pDest->iSDParm2; int r1 = sqlite3GetTempReg(pParse); sqlite3VdbeAddOp3(v, OP_MakeRecord,regResult+(i2<0),nResultCol-(i2<0),r1); if( i2<0 ){ sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult); }else{ sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2); } } break; } #ifndef SQLITE_OMIT_SUBQUERY /* If we are creating a set for an "expr IN (SELECT ...)" construct, ** then there should be a single item on the stack. Write this ** item into the set table with bogus data. */ case SRT_Set: { |
︙ | ︙ | |||
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 | sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol, r1, pDest->zAffSdst, nResultCol); sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol); sqlite3ReleaseTempReg(pParse, r1); } break; } /* If any row exist in the result set, record that fact and abort. */ case SRT_Exists: { sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm); /* The LIMIT clause will terminate the loop for us */ break; | > | 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 | sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol, r1, pDest->zAffSdst, nResultCol); sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol); sqlite3ReleaseTempReg(pParse, r1); } break; } /* If any row exist in the result set, record that fact and abort. */ case SRT_Exists: { sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm); /* The LIMIT clause will terminate the loop for us */ break; |
︙ | ︙ | |||
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 | sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn); break; } case SRT_Mem: { /* The LIMIT clause will terminate the loop for us */ break; } #endif default: { assert( eDest==SRT_Output || eDest==SRT_Coroutine ); testcase( eDest==SRT_Output ); testcase( eDest==SRT_Coroutine ); if( eDest==SRT_Output ){ sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn); | > > > > > > > > > > > > > | 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 | sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn); break; } case SRT_Mem: { /* The LIMIT clause will terminate the loop for us */ break; } #endif #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT case SRT_Upfrom: { int i2 = pDest->iSDParm2; int r1 = sqlite3GetTempReg(pParse); sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1); if( i2<0 ){ sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow); }else{ sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2); } break; } #endif default: { assert( eDest==SRT_Output || eDest==SRT_Coroutine ); testcase( eDest==SRT_Output ); testcase( eDest==SRT_Coroutine ); if( eDest==SRT_Output ){ sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn); |
︙ | ︙ | |||
4965 4966 4967 4968 4969 4970 4971 | /* Look up every table named in the FROM clause of the select. If ** an entry of the FROM clause is a subquery instead of a table or view, ** then create a transient table structure to describe the subquery. */ for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){ Table *pTab; assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 ); | | | | 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 | /* Look up every table named in the FROM clause of the select. If ** an entry of the FROM clause is a subquery instead of a table or view, ** then create a transient table structure to describe the subquery. */ for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){ Table *pTab; assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 ); if( pFrom->pTab ) continue; assert( pFrom->fg.isRecursive==0 ); #ifndef SQLITE_OMIT_CTE if( withExpand(pWalker, pFrom) ) return WRC_Abort; if( pFrom->pTab ) {} else #endif if( pFrom->zName==0 ){ #ifndef SQLITE_OMIT_SUBQUERY Select *pSel = pFrom->pSelect; |
︙ | ︙ | |||
5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 | assert( p->pEList!=0 ); #if SELECTTRACE_ENABLED if( sqlite3SelectTrace & 0x104 ){ SELECTTRACE(0x104,pParse,p, ("after name resolution:\n")); sqlite3TreeViewSelect(0, p, 0); } #endif if( pDest->eDest==SRT_Output ){ generateColumnNames(pParse, p); } #ifndef SQLITE_OMIT_WINDOWFUNC rc = sqlite3WindowRewrite(pParse, p); | > > > > > > > > > > > > > > > > > > | 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 | assert( p->pEList!=0 ); #if SELECTTRACE_ENABLED if( sqlite3SelectTrace & 0x104 ){ SELECTTRACE(0x104,pParse,p, ("after name resolution:\n")); sqlite3TreeViewSelect(0, p, 0); } #endif /* If the SF_UpdateFrom flag is set, then this function is being called ** as part of populating the temp table for an UPDATE...FROM statement. ** In this case, it is an error if the target object (pSrc->a[0]) name ** or alias is duplicated within FROM clause (pSrc->a[1..n]). */ if( p->selFlags & SF_UpdateFrom ){ struct SrcList_item *p0 = &p->pSrc->a[0]; for(i=1; i<p->pSrc->nSrc; i++){ struct SrcList_item *p1 = &p->pSrc->a[i]; if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){ sqlite3ErrorMsg(pParse, "target object/alias may not appear in FROM clause: %s", p0->zAlias ? p0->zAlias : p0->pTab->zName ); goto select_end; } } } if( pDest->eDest==SRT_Output ){ generateColumnNames(pParse, p); } #ifndef SQLITE_OMIT_WINDOWFUNC rc = sqlite3WindowRewrite(pParse, p); |
︙ | ︙ |
Changes to src/sqliteInt.h.
︙ | ︙ | |||
3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 | #define SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */ #define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */ #define SF_ComplexResult 0x0040000 /* Result contains subquery or function */ #define SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */ #define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */ #define SF_View 0x0200000 /* SELECT statement is a view */ #define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */ /* ** The results of a SELECT can be distributed in several ways, as defined ** by one of the following macros. The "SRT" prefix means "SELECT Result ** Type". ** ** SRT_Union Store results as a key in a temporary index | > | 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 | #define SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */ #define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */ #define SF_ComplexResult 0x0040000 /* Result contains subquery or function */ #define SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */ #define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */ #define SF_View 0x0200000 /* SELECT statement is a view */ #define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */ #define SF_UpdateFrom 0x0800000 /* Statement is an UPDATE...FROM */ /* ** The results of a SELECT can be distributed in several ways, as defined ** by one of the following macros. The "SRT" prefix means "SELECT Result ** Type". ** ** SRT_Union Store results as a key in a temporary index |
︙ | ︙ | |||
3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 | ** SRT_Queue Store results in priority queue pDest->iSDParm (really ** an index). Append a sequence number so that all entries ** are distinct. ** ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if ** the same record has never been stored before. The ** index at pDest->iSDParm+1 hold all prior stores. */ #define SRT_Union 1 /* Store result as keys in an index */ #define SRT_Except 2 /* Remove result from a UNION index */ #define SRT_Exists 3 /* Store 1 if the result is not empty */ #define SRT_Discard 4 /* Do not save the results anywhere */ #define SRT_Fifo 5 /* Store result as data with an automatic rowid */ #define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */ #define SRT_Queue 7 /* Store result in an queue */ #define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */ /* The ORDER BY clause is ignored for all of the above */ #define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue) #define SRT_Output 9 /* Output each row of result */ #define SRT_Mem 10 /* Store result in a memory cell */ #define SRT_Set 11 /* Store results as keys in an index */ #define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */ #define SRT_Coroutine 13 /* Generate a single row of result */ #define SRT_Table 14 /* Store result as data with an automatic rowid */ /* ** An instance of this object describes where to put of the results of ** a SELECT statement. */ struct SelectDest { | > > > > > > > > > | > | 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 | ** SRT_Queue Store results in priority queue pDest->iSDParm (really ** an index). Append a sequence number so that all entries ** are distinct. ** ** SRT_DistQueue Store results in priority queue pDest->iSDParm only if ** the same record has never been stored before. The ** index at pDest->iSDParm+1 hold all prior stores. ** ** SRT_Upfrom Store results in the temporary table already opened by ** pDest->iSDParm. If (pDest->iSDParm<0), then the temp ** table is an intkey table - in this case the first ** column returned by the SELECT is used as the integer ** key. If (pDest->iSDParm>0), then the table is an index ** table. (pDest->iSDParm) is the number of key columns in ** each index record in this case. */ #define SRT_Union 1 /* Store result as keys in an index */ #define SRT_Except 2 /* Remove result from a UNION index */ #define SRT_Exists 3 /* Store 1 if the result is not empty */ #define SRT_Discard 4 /* Do not save the results anywhere */ #define SRT_Fifo 5 /* Store result as data with an automatic rowid */ #define SRT_DistFifo 6 /* Like SRT_Fifo, but unique results only */ #define SRT_Queue 7 /* Store result in an queue */ #define SRT_DistQueue 8 /* Like SRT_Queue, but unique results only */ /* The ORDER BY clause is ignored for all of the above */ #define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue) #define SRT_Output 9 /* Output each row of result */ #define SRT_Mem 10 /* Store result in a memory cell */ #define SRT_Set 11 /* Store results as keys in an index */ #define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */ #define SRT_Coroutine 13 /* Generate a single row of result */ #define SRT_Table 14 /* Store result as data with an automatic rowid */ #define SRT_Upfrom 15 /* Store result as data with rowid */ /* ** An instance of this object describes where to put of the results of ** a SELECT statement. */ struct SelectDest { u8 eDest; /* How to dispose of the results. One of SRT_* above. */ int iSDParm; /* A parameter used by the eDest disposal method */ int iSDParm2; /* A second parameter for the eDest disposal method */ int iSdst; /* Base register where results are written */ int nSdst; /* Number of registers allocated */ char *zAffSdst; /* Affinity used when eDest==SRT_Set */ ExprList *pOrderBy; /* Key columns for SRT_Queue and SRT_DistQueue */ }; /* |
︙ | ︙ | |||
3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 | */ struct TriggerStep { u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ u8 orconf; /* OE_Rollback etc. */ Trigger *pTrig; /* The trigger that this step is a part of */ Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ ExprList *pExprList; /* SET clause for UPDATE */ IdList *pIdList; /* Column names for INSERT */ Upsert *pUpsert; /* Upsert clauses on an INSERT */ char *zSpan; /* Original SQL text of this command */ TriggerStep *pNext; /* Next in the link-list */ TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ | > | 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 | */ struct TriggerStep { u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ u8 orconf; /* OE_Rollback etc. */ Trigger *pTrig; /* The trigger that this step is a part of */ Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ SrcList *pFrom; /* FROM clause for UPDATE statement (if any) */ Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ ExprList *pExprList; /* SET clause for UPDATE */ IdList *pIdList; /* Column names for INSERT */ Upsert *pUpsert; /* Upsert clauses on an INSERT */ char *zSpan; /* Original SQL text of this command */ TriggerStep *pNext; /* Next in the link-list */ TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ |
︙ | ︙ | |||
4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS void sqlite3ComputeGeneratedColumns(Parse*, int, Table*); #endif void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); IdList *sqlite3IdListAppend(Parse*, IdList*, Token*); int sqlite3IdListIndex(IdList*,const char*); SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int); SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*); SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, Token*, Select*, Expr*, IdList*); void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); void sqlite3SrcListShiftJoinType(SrcList*); | > | 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 | #ifndef SQLITE_OMIT_GENERATED_COLUMNS void sqlite3ComputeGeneratedColumns(Parse*, int, Table*); #endif void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); IdList *sqlite3IdListAppend(Parse*, IdList*, Token*); int sqlite3IdListIndex(IdList*,const char*); SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int); SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2); SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*); SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, Token*, Select*, Expr*, IdList*); void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); int sqlite3IndexedByLookup(Parse *, struct SrcList_item *); void sqlite3SrcListShiftJoinType(SrcList*); |
︙ | ︙ | |||
4395 4396 4397 4398 4399 4400 4401 | void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*, const char*,const char*); TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*, Select*,u8,Upsert*, const char*,const char*); | | | > > | 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 | void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*, const char*,const char*); TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*, Select*,u8,Upsert*, const char*,const char*); TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,SrcList*,ExprList*, Expr*, u8, const char*,const char*); TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*, const char*,const char*); void sqlite3DeleteTrigger(sqlite3*, Trigger*); void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int); SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*); # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) # define sqlite3IsToplevel(p) ((p)->pToplevel==0) #else # define sqlite3TriggersExist(B,C,D,E,F) 0 # define sqlite3DeleteTrigger(A,B) # define sqlite3DropTriggerPtr(A,B) # define sqlite3UnlinkAndDeleteTrigger(A,B,C) # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) # define sqlite3TriggerList(X, Y) 0 # define sqlite3ParseToplevel(p) p # define sqlite3IsToplevel(p) 1 # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 # define sqlite3TriggerStepSrc(A,B) 0 #endif int sqlite3JoinType(Parse*, Token*, Token*, Token*); void sqlite3SetJoinExpr(Expr*,int); void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int); void sqlite3DeferForeignKey(Parse*, int); #ifndef SQLITE_OMIT_AUTHORIZATION |
︙ | ︙ |
Changes to src/test_malloc.c.
︙ | ︙ | |||
108 109 110 111 112 113 114 | void *p = 0; if( !faultsimStep() ){ p = memfault.m.xRealloc(pOld, n); } return p; } | < < < < < < < < < < < < < < < < < < < < < < < < < < | 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | void *p = 0; if( !faultsimStep() ){ p = memfault.m.xRealloc(pOld, n); } return p; } /* ** This routine configures the malloc failure simulation. After ** calling this routine, the next nDelay mallocs will succeed, followed ** by a block of nRepeat failures, after which malloc() calls will begin ** to succeed again. */ static void faultsimConfig(int nDelay, int nRepeat){ |
︙ | ︙ | |||
200 201 202 203 204 205 206 | } /* ** Add or remove the fault-simulation layer using sqlite3_config(). If ** the argument is non-zero, the */ static int faultsimInstall(int install){ | < < < < < < < < < < > > > | 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 | } /* ** Add or remove the fault-simulation layer using sqlite3_config(). If ** the argument is non-zero, the */ static int faultsimInstall(int install){ int rc; install = (install ? 1 : 0); assert(memfault.isInstalled==1 || memfault.isInstalled==0); if( install==memfault.isInstalled ){ return SQLITE_ERROR; } if( install ){ rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memfault.m); assert(memfault.m.xMalloc); if( rc==SQLITE_OK ){ sqlite3_mem_methods m = memfault.m; m.xMalloc = faultsimMalloc; m.xRealloc = faultsimRealloc; rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &m); } sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, faultsimBeginBenign, faultsimEndBenign ); }else{ sqlite3_mem_methods m2; |
︙ | ︙ |
Changes to src/trigger.c.
︙ | ︙ | |||
22 23 24 25 26 27 28 29 30 31 32 33 34 35 | pTriggerStep = pTriggerStep->pNext; sqlite3ExprDelete(db, pTmp->pWhere); sqlite3ExprListDelete(db, pTmp->pExprList); sqlite3SelectDelete(db, pTmp->pSelect); sqlite3IdListDelete(db, pTmp->pIdList); sqlite3UpsertDelete(db, pTmp->pUpsert); sqlite3DbFree(db, pTmp->zSpan); sqlite3DbFree(db, pTmp); } } /* | > | 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | pTriggerStep = pTriggerStep->pNext; sqlite3ExprDelete(db, pTmp->pWhere); sqlite3ExprListDelete(db, pTmp->pExprList); sqlite3SelectDelete(db, pTmp->pSelect); sqlite3IdListDelete(db, pTmp->pIdList); sqlite3UpsertDelete(db, pTmp->pUpsert); sqlite3SrcListDelete(db, pTmp->pFrom); sqlite3DbFree(db, pTmp->zSpan); sqlite3DbFree(db, pTmp); } } /* |
︙ | ︙ | |||
482 483 484 485 486 487 488 489 490 491 492 493 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 | ** Construct a trigger step that implements an UPDATE statement and return ** a pointer to that trigger step. The parser calls this routine when it ** sees an UPDATE statement inside the body of a CREATE TRIGGER. */ TriggerStep *sqlite3TriggerUpdateStep( Parse *pParse, /* Parser */ Token *pTableName, /* Name of the table to be updated */ ExprList *pEList, /* The SET clause: list of column and new values */ Expr *pWhere, /* The WHERE clause */ u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ const char *zStart, /* Start of SQL text */ const char *zEnd /* End of SQL text */ ){ sqlite3 *db = pParse->db; TriggerStep *pTriggerStep; pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd); if( pTriggerStep ){ if( IN_RENAME_OBJECT ){ pTriggerStep->pExprList = pEList; pTriggerStep->pWhere = pWhere; pEList = 0; pWhere = 0; }else{ pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); } pTriggerStep->orconf = orconf; } sqlite3ExprListDelete(db, pEList); sqlite3ExprDelete(db, pWhere); return pTriggerStep; } /* ** Construct a trigger step that implements a DELETE statement and return ** a pointer to that trigger step. The parser calls this routine when it ** sees a DELETE statement inside the body of a CREATE TRIGGER. | > > > > > | 483 484 485 486 487 488 489 490 491 492 493 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 | ** Construct a trigger step that implements an UPDATE statement and return ** a pointer to that trigger step. The parser calls this routine when it ** sees an UPDATE statement inside the body of a CREATE TRIGGER. */ TriggerStep *sqlite3TriggerUpdateStep( Parse *pParse, /* Parser */ Token *pTableName, /* Name of the table to be updated */ SrcList *pFrom, ExprList *pEList, /* The SET clause: list of column and new values */ Expr *pWhere, /* The WHERE clause */ u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ const char *zStart, /* Start of SQL text */ const char *zEnd /* End of SQL text */ ){ sqlite3 *db = pParse->db; TriggerStep *pTriggerStep; pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd); if( pTriggerStep ){ if( IN_RENAME_OBJECT ){ pTriggerStep->pExprList = pEList; pTriggerStep->pWhere = pWhere; pTriggerStep->pFrom = pFrom; pEList = 0; pWhere = 0; pFrom = 0; }else{ pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE); } pTriggerStep->orconf = orconf; } sqlite3ExprListDelete(db, pEList); sqlite3ExprDelete(db, pWhere); sqlite3SrcListDelete(db, pFrom); return pTriggerStep; } /* ** Construct a trigger step that implements a DELETE statement and return ** a pointer to that trigger step. The parser calls this routine when it ** sees a DELETE statement inside the body of a CREATE TRIGGER. |
︙ | ︙ | |||
732 733 734 735 736 737 738 | ** ** This routine adds a specific database name, if needed, to the target when ** forming the SrcList. This prevents a trigger in one database from ** referring to a target in another database. An exception is when the ** trigger is in TEMP in which case it can refer to any other database it ** wants. */ | | < | | > > < < | > | | > | < > | > > | 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 | ** ** This routine adds a specific database name, if needed, to the target when ** forming the SrcList. This prevents a trigger in one database from ** referring to a target in another database. An exception is when the ** trigger is in TEMP in which case it can refer to any other database it ** wants. */ SrcList *sqlite3TriggerStepSrc( Parse *pParse, /* The parsing context */ TriggerStep *pStep /* The trigger containing the target token */ ){ sqlite3 *db = pParse->db; SrcList *pSrc; /* SrcList to be returned */ char *zName = sqlite3DbStrDup(db, pStep->zTarget); pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); assert( pSrc==0 || pSrc->nSrc==1 ); assert( zName || pSrc==0 ); if( pSrc ){ Schema *pSchema = pStep->pTrig->pSchema; pSrc->a[0].zName = zName; if( pSchema!=db->aDb[1].pSchema ){ pSrc->a[0].pSchema = pSchema; } if( pStep->pFrom ){ SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0); pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup); } }else{ sqlite3DbFree(db, zName); } return pSrc; } /* ** Generate VDBE code for the statements inside the body of a single ** trigger. |
︙ | ︙ | |||
799 800 801 802 803 804 805 | P4_DYNAMIC); } #endif switch( pStep->op ){ case TK_UPDATE: { sqlite3Update(pParse, | | | | | 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 | P4_DYNAMIC); } #endif switch( pStep->op ){ case TK_UPDATE: { sqlite3Update(pParse, sqlite3TriggerStepSrc(pParse, pStep), sqlite3ExprListDup(db, pStep->pExprList, 0), sqlite3ExprDup(db, pStep->pWhere, 0), pParse->eOrconf, 0, 0, 0 ); break; } case TK_INSERT: { sqlite3Insert(pParse, sqlite3TriggerStepSrc(pParse, pStep), sqlite3SelectDup(db, pStep->pSelect, 0), sqlite3IdListDup(db, pStep->pIdList), pParse->eOrconf, sqlite3UpsertDup(db, pStep->pUpsert) ); break; } case TK_DELETE: { sqlite3DeleteFrom(pParse, sqlite3TriggerStepSrc(pParse, pStep), sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0 ); break; } default: assert( pStep->op==TK_SELECT ); { SelectDest sDest; Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0); |
︙ | ︙ |
Changes to src/update.c.
︙ | ︙ | |||
125 126 127 128 129 130 131 132 133 134 135 | int *aXRef, /* aXRef[j]>=0 if column j is being updated */ int chngRowid /* true if the rowid is being updated */ ){ if( pIdx->pPartIdxWhere==0 ) return 0; return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere, aXRef, chngRowid); } /* ** Process an UPDATE statement. ** | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | | > > | 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 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 206 207 208 209 210 211 212 213 214 215 216 217 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 | int *aXRef, /* aXRef[j]>=0 if column j is being updated */ int chngRowid /* true if the rowid is being updated */ ){ if( pIdx->pPartIdxWhere==0 ) return 0; return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere, aXRef, chngRowid); } /* ** Allocate and return a pointer to an expression of type TK_ROW with ** Expr.iColumn set to value (iCol+1). The resolver will modify the ** expression to be a TK_COLUMN reading column iCol of the first ** table in the source-list (pSrc->a[0]). */ static Expr *exprRowColumn(Parse *pParse, int iCol){ Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0); if( pRet ) pRet->iColumn = iCol+1; return pRet; } /* ** Assuming both the pLimit and pOrderBy parameters are NULL, this function ** generates VM code to run the query: ** ** SELECT <other-columns>, pChanges FROM pTabList WHERE pWhere ** ** and write the results to the ephemeral table already opened as cursor ** iEph. None of pChanges, pTabList or pWhere are modified or consumed by ** this function, they must be deleted by the caller. ** ** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view: ** ** SELECT <other-columns>, pChanges FROM pTabList ** WHERE pWhere ** GROUP BY <other-columns> ** ORDER BY pOrderBy LIMIT pLimit ** ** If pTab is a view, the GROUP BY clause is omitted. ** ** Exactly how results are written to table iEph, and exactly what ** the <other-columns> in the query above are is determined by the type ** of table pTabList->a[0].pTab. ** ** If the table is a WITHOUT ROWID table, then argument pPk must be its ** PRIMARY KEY. In this case <other-columns> are the primary key columns ** of the table, in order. The results of the query are written to ephemeral ** table iEph as index keys, using OP_IdxInsert. ** ** If the table is actually a view, then <other-columns> are all columns of ** the view. The results are written to the ephemeral table iEph as records ** with automatically assigned integer keys. ** ** If the table is a virtual or ordinary intkey table, then <other-columns> ** is its rowid. For a virtual table, the results are written to iEph as ** records with automatically assigned integer keys For intkey tables, the ** rowid value in <other-columns> is used as the integer key, and the ** remaining fields make up the table record. */ static void updateFromSelect( Parse *pParse, /* Parse context */ int iEph, /* Cursor for open eph. table */ Index *pPk, /* PK if table 0 is WITHOUT ROWID */ ExprList *pChanges, /* List of expressions to return */ SrcList *pTabList, /* List of tables to select from */ Expr *pWhere, /* WHERE clause for query */ ExprList *pOrderBy, Expr *pLimit ){ int i; SelectDest dest; Select *pSelect = 0; ExprList *pList = 0; ExprList *pGrp = 0; Expr *pLimit2 = 0; ExprList *pOrderBy2 = 0; sqlite3 *db = pParse->db; Table *pTab = pTabList->a[0].pTab; SrcList *pSrc; Expr *pWhere2; int eDest; #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT if( pOrderBy && pLimit==0 ) { sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE"); return; } pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0); pLimit2 = sqlite3ExprDup(db, pLimit, 0); #endif pSrc = sqlite3SrcListDup(db, pTabList, 0); pWhere2 = sqlite3ExprDup(db, pWhere, 0); assert( pTabList->nSrc>1 ); if( pSrc ){ pSrc->a[0].iCursor = -1; pSrc->a[0].pTab->nTabRef--; pSrc->a[0].pTab = 0; } if( pPk ){ for(i=0; i<pPk->nKeyCol; i++){ Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]); #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT if( pLimit ){ pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0)); } #endif pList = sqlite3ExprListAppend(pParse, pList, pNew); } eDest = SRT_Upfrom; }else if( pTab->pSelect ){ for(i=0; i<pTab->nCol; i++){ pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); } eDest = SRT_Table; }else{ eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT if( pLimit ){ pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); } #endif } if( ALWAYS(pChanges) ){ for(i=0; i<pChanges->nExpr; i++){ pList = sqlite3ExprListAppend(pParse, pList, sqlite3ExprDup(db, pChanges->a[i].pExpr, 0) ); } } pSelect = sqlite3SelectNew(pParse, pList, pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UpdateFrom|SF_IncludeHidden, pLimit2 ); sqlite3SelectDestInit(&dest, eDest, iEph); dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1); sqlite3Select(pParse, pSelect, &dest); sqlite3SelectDelete(db, pSelect); } /* ** Process an UPDATE statement. ** ** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL; ** \_______/ \_/ \______/ \_____/ \________________/ ** onError | pChanges | pWhere ** \_______________________/ ** pTabList */ void sqlite3Update( Parse *pParse, /* The parser context */ SrcList *pTabList, /* The table in which we should change things */ ExprList *pChanges, /* Things to be changed */ Expr *pWhere, /* The WHERE clause. May be null */ int onError, /* How to handle constraint errors */ |
︙ | ︙ | |||
165 166 167 168 169 170 171 172 173 174 175 176 177 178 | ** an expression for the i-th column of the table. ** aXRef[i]==-1 if the i-th column is not changed. */ u8 *aToOpen; /* 1 for tables and indices to be opened */ u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ u8 chngRowid; /* Rowid changed in a normal table */ u8 chngKey; /* Either chngPk or chngRowid */ Expr *pRowidExpr = 0; /* Expression defining the new record number */ AuthContext sContext; /* The authorization context */ NameContext sNC; /* The name-context to resolve expressions in */ int iDb; /* Database containing the table being updated */ int eOnePass; /* ONEPASS_XXX value from where.c */ int hasFK; /* True if foreign key processing is required */ int labelBreak; /* Jump here to break out of UPDATE loop */ int labelContinue; /* Jump here to continue next step of UPDATE loop */ | > | 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 | ** an expression for the i-th column of the table. ** aXRef[i]==-1 if the i-th column is not changed. */ u8 *aToOpen; /* 1 for tables and indices to be opened */ u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ u8 chngRowid; /* Rowid changed in a normal table */ u8 chngKey; /* Either chngPk or chngRowid */ Expr *pRowidExpr = 0; /* Expression defining the new record number */ int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */ AuthContext sContext; /* The authorization context */ NameContext sNC; /* The name-context to resolve expressions in */ int iDb; /* Database containing the table being updated */ int eOnePass; /* ONEPASS_XXX value from where.c */ int hasFK; /* True if foreign key processing is required */ int labelBreak; /* Jump here to break out of UPDATE loop */ int labelContinue; /* Jump here to continue next step of UPDATE loop */ |
︙ | ︙ | |||
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ int addrOpen = 0; /* Address of OP_OpenEphemeral */ int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */ i16 nPk = 0; /* Number of components of the PRIMARY KEY */ int bReplace = 0; /* True if REPLACE conflict resolution might happen */ int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */ /* Register Allocations */ int regRowCount = 0; /* A count of rows changed */ int regOldRowid = 0; /* The old rowid */ int regNewRowid = 0; /* The new rowid */ int regNew = 0; /* Content of the NEW.* table in triggers */ int regOld = 0; /* Content of OLD.* table in triggers */ int regRowSet = 0; /* Rowset of rows to be updated */ int regKey = 0; /* composite PRIMARY KEY value */ memset(&sContext, 0, sizeof(sContext)); db = pParse->db; if( pParse->nErr || db->mallocFailed ){ goto update_cleanup; } | > < | 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 | int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ int addrOpen = 0; /* Address of OP_OpenEphemeral */ int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */ i16 nPk = 0; /* Number of components of the PRIMARY KEY */ int bReplace = 0; /* True if REPLACE conflict resolution might happen */ int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */ int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */ /* Register Allocations */ int regRowCount = 0; /* A count of rows changed */ int regOldRowid = 0; /* The old rowid */ int regNewRowid = 0; /* The new rowid */ int regNew = 0; /* Content of the NEW.* table in triggers */ int regOld = 0; /* Content of OLD.* table in triggers */ int regRowSet = 0; /* Rowset of rows to be updated */ int regKey = 0; /* composite PRIMARY KEY value */ memset(&sContext, 0, sizeof(sContext)); db = pParse->db; if( pParse->nErr || db->mallocFailed ){ goto update_cleanup; } /* Locate the table which we want to update. */ pTab = sqlite3SrcListLookup(pParse, pTabList); if( pTab==0 ) goto update_cleanup; iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); |
︙ | ︙ | |||
228 229 230 231 232 233 234 235 | # define tmask 0 #endif #ifdef SQLITE_OMIT_VIEW # undef isView # define isView 0 #endif #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT | > > > > > > > | | 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 | # define tmask 0 #endif #ifdef SQLITE_OMIT_VIEW # undef isView # define isView 0 #endif /* If there was a FROM clause, set nChangeFrom to the number of expressions ** in the change-list. Otherwise, set it to 0. There cannot be a FROM ** clause if this function is being called to generate code for part of ** an UPSERT statement. */ nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0; assert( nChangeFrom==0 || pUpsert==0 ); #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT if( !isView && nChangeFrom==0 ){ pWhere = sqlite3LimitWhere( pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE" ); pOrderBy = 0; pLimit = 0; } #endif |
︙ | ︙ | |||
298 299 300 301 302 303 304 | ** of the UPDATE statement. Also find the column index ** for each column to be updated in the pChanges array. For each ** column to be updated, make sure we have authorization to change ** that column. */ chngRowid = chngPk = 0; for(i=0; i<pChanges->nExpr; i++){ | > > | > | 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 | ** of the UPDATE statement. Also find the column index ** for each column to be updated in the pChanges array. For each ** column to be updated, make sure we have authorization to change ** that column. */ chngRowid = chngPk = 0; for(i=0; i<pChanges->nExpr; i++){ /* If this is an UPDATE with a FROM clause, do not resolve expressions ** here. The call to sqlite3Select() below will do that. */ if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ goto update_cleanup; } for(j=0; j<pTab->nCol; j++){ if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zEName)==0 ){ if( j==pTab->iPKey ){ chngRowid = 1; pRowidExpr = pChanges->a[i].pExpr; iRowidExpr = i; }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){ chngPk = 1; } #ifndef SQLITE_OMIT_GENERATED_COLUMNS else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){ testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ); testcase( pTab->aCol[j].colFlags & COLFLAG_STORED ); |
︙ | ︙ | |||
328 329 330 331 332 333 334 335 336 337 338 339 340 341 | } } if( j>=pTab->nCol ){ if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){ j = -1; chngRowid = 1; pRowidExpr = pChanges->a[i].pExpr; }else{ sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName); pParse->checkSchema = 1; goto update_cleanup; } } #ifndef SQLITE_OMIT_AUTHORIZATION | > | 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 | } } if( j>=pTab->nCol ){ if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){ j = -1; chngRowid = 1; pRowidExpr = pChanges->a[i].pExpr; iRowidExpr = i; }else{ sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName); pParse->checkSchema = 1; goto update_cleanup; } } #ifndef SQLITE_OMIT_AUTHORIZATION |
︙ | ︙ | |||
457 458 459 460 461 462 463 | sqlite3AuthContextPush(pParse, &sContext, pTab->zName); } /* If we are trying to update a view, realize that view into ** an ephemeral table. */ #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) | | | | 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 | sqlite3AuthContextPush(pParse, &sContext, pTab->zName); } /* If we are trying to update a view, realize that view into ** an ephemeral table. */ #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) if( nChangeFrom==0 && isView ){ sqlite3MaterializeView(pParse, pTab, pWhere, pOrderBy, pLimit, iDataCur ); pOrderBy = 0; pLimit = 0; } #endif /* Resolve the column names in all the expressions in the ** WHERE clause. */ if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){ goto update_cleanup; } #ifndef SQLITE_OMIT_VIRTUALTABLE /* Virtual tables must be handled separately */ if( IsVirtual(pTab) ){ updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, |
︙ | ︙ | |||
496 497 498 499 500 501 502 | && !pParse->nested && pUpsert==0 ){ regRowCount = ++pParse->nMem; sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); } | | | | > > | | > | > > > | | > > > > > > > | > > > > > > > > > | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | > | | 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 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 | && !pParse->nested && pUpsert==0 ){ regRowCount = ++pParse->nMem; sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); } if( nChangeFrom==0 && HasRowid(pTab) ){ sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); }else{ assert( pPk!=0 || HasRowid(pTab) ); nPk = pPk ? pPk->nKeyCol : 0; iPk = pParse->nMem+1; pParse->nMem += nPk; pParse->nMem += nChangeFrom; regKey = ++pParse->nMem; if( pUpsert==0 ){ int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0); iEph = pParse->nTab++; if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1); addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol); if( pPk ){ KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk); if( pKeyInfo ){ pKeyInfo->nAllField = nEphCol; sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); } } if( nChangeFrom ){ updateFromSelect( pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit ); #ifndef SQLITE_OMIT_SUBQUERY if( isView ) iDataCur = iEph; #endif } } } if( nChangeFrom ){ sqlite3MultiWrite(pParse); eOnePass = ONEPASS_OFF; nKey = nPk; regKey = iPk; }else{ if( pUpsert ){ /* If this is an UPSERT, then all cursors have already been opened by ** the outer INSERT and the data cursor should be pointing at the row ** that is to be updated. So bypass the code that searches for the ** row(s) to be updated. */ pWInfo = 0; eOnePass = ONEPASS_SINGLE; sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL); bFinishSeek = 0; }else{ /* Begin the database scan. ** ** Do not consider a single-pass strategy for a multi-row update if ** there are any triggers or foreign keys to process, or rows may ** be deleted as a result of REPLACE conflict handling. Any of these ** things might disturb a cursor being used to scan through the table ** or index, causing a single-pass approach to malfunction. */ flags = WHERE_ONEPASS_DESIRED|WHERE_SEEK_UNIQ_TABLE; if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){ flags |= WHERE_ONEPASS_MULTIROW; } pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags,iIdxCur); if( pWInfo==0 ) goto update_cleanup; /* A one-pass strategy that might update more than one row may not ** be used if any column of the index used for the scan is being ** updated. Otherwise, if there is an index on "b", statements like ** the following could create an infinite loop: ** ** UPDATE t1 SET b=b+1 WHERE b>? ** ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI ** strategy that uses an index for which one or more columns are being ** updated. */ eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo); if( eOnePass!=ONEPASS_SINGLE ){ sqlite3MultiWrite(pParse); if( eOnePass==ONEPASS_MULTI ){ int iCur = aiCurOnePass[1]; if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){ eOnePass = ONEPASS_OFF; } assert( iCur!=iDataCur || !HasRowid(pTab) ); } } } if( HasRowid(pTab) ){ /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF ** mode, write the rowid into the FIFO. In either of the one-pass modes, ** leave it in register regOldRowid. */ sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); if( eOnePass==ONEPASS_OFF ){ /* We need to use regRowSet, so reallocate aRegIdx[nAllIdx] */ aRegIdx[nAllIdx] = ++pParse->nMem; sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid); } }else{ /* Read the PK of the current row into an array of registers. In ** ONEPASS_OFF mode, serialize the array into a record and store it in ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table ** is not required) and leave the PK fields in the array of registers. */ for(i=0; i<nPk; i++){ assert( pPk->aiColumn[i]>=0 ); sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i], iPk+i); } if( eOnePass ){ if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen); nKey = nPk; regKey = iPk; }else{ sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, sqlite3IndexAffinityStr(db, pPk), nPk); sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk); } } } if( pUpsert==0 ){ if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){ sqlite3WhereEnd(pWInfo); } if( !isView ){ int addrOnce = 0; /* Open every index that needs updating. */ |
︙ | ︙ | |||
630 631 632 633 634 635 636 | } if( eOnePass!=ONEPASS_SINGLE ){ labelContinue = sqlite3VdbeMakeLabel(pParse); } sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); VdbeCoverageIf(v, pPk==0); VdbeCoverageIf(v, pPk!=0); | | > > > > > > > > > > > > > > > > > > | | | > > > | > > > | 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 | } if( eOnePass!=ONEPASS_SINGLE ){ labelContinue = sqlite3VdbeMakeLabel(pParse); } sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); VdbeCoverageIf(v, pPk==0); VdbeCoverageIf(v, pPk!=0); }else if( pPk || nChangeFrom ){ labelContinue = sqlite3VdbeMakeLabel(pParse); sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); addrTop = sqlite3VdbeCurrentAddr(v); if( nChangeFrom ){ if( !isView ){ if( pPk ){ for(i=0; i<nPk; i++){ sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i); } sqlite3VdbeAddOp4Int( v, OP_NotFound, iDataCur, labelContinue, iPk, nPk ); VdbeCoverage(v); }else{ sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid); sqlite3VdbeAddOp3( v, OP_NotExists, iDataCur, labelContinue, regOldRowid ); VdbeCoverage(v); } } }else{ sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey); sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0); VdbeCoverage(v); } }else{ labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet,labelBreak, regOldRowid); VdbeCoverage(v); sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); VdbeCoverage(v); } } /* If the rowid value will change, set register regNewRowid to ** contain the new value. If the rowid is not being modified, ** then regNewRowid is the same register as regOldRowid, which is ** already populated. */ assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid ); if( chngRowid ){ assert( iRowidExpr>=0 ); if( nChangeFrom==0 ){ sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); }else{ sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid); } sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); } /* Compute the old pre-UPDATE content of the row being changed, if that ** information is needed */ if( chngPk || hasFK || pTrigger ){ u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); |
︙ | ︙ | |||
704 705 706 707 708 709 710 | if( i==pTab->iPKey ){ sqlite3VdbeAddOp2(v, OP_Null, 0, k); }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){ if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; }else{ j = aXRef[i]; if( j>=0 ){ | > > > > > | > | 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 | if( i==pTab->iPKey ){ sqlite3VdbeAddOp2(v, OP_Null, 0, k); }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){ if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; }else{ j = aXRef[i]; if( j>=0 ){ if( nChangeFrom ){ assert( eOnePass==ONEPASS_OFF ); int nOff = (isView ? pTab->nCol : nPk); sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k); }else{ sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k); } }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ /* This branch loads the value of a column that will not be changed ** into a register. This is done if there are no BEFORE triggers, or ** if there are one or more BEFORE triggers that use this value via ** a new.* reference in a trigger program. */ testcase( i==31 ); |
︙ | ︙ | |||
736 737 738 739 740 741 742 | ** verified. One could argue that this is wrong. */ if( tmask&TRIGGER_BEFORE ){ sqlite3TableAffinity(v, pTab, regNew); sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); | > | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | > | 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 | ** verified. One could argue that this is wrong. */ if( tmask&TRIGGER_BEFORE ){ sqlite3TableAffinity(v, pTab, regNew); sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); if( !isView ){ /* The row-trigger may have deleted the row being updated. In this ** case, jump to the next row. No updates or AFTER triggers are ** required. This behavior - what happens when the row being updated ** is deleted or renamed by a BEFORE trigger - is left undefined in the ** documentation. */ if( pPk ){ sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); VdbeCoverage(v); }else{ sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); VdbeCoverage(v); } /* After-BEFORE-trigger-reload-loop: ** If it did not delete it, the BEFORE trigger may still have modified ** some of the columns of the row being updated. Load the values for ** all columns not modified by the update statement into their registers ** in case this has happened. Only unmodified columns are reloaded. ** The values computed for modified columns use the values before the ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26) ** for an example. */ for(i=0, k=regNew; i<pTab->nCol; i++, k++){ if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; }else if( aXRef[i]<0 && i!=pTab->iPKey ){ sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); } } #ifndef SQLITE_OMIT_GENERATED_COLUMNS if( pTab->tabFlags & TF_HasGenerated ){ testcase( pTab->tabFlags & TF_HasVirtual ); testcase( pTab->tabFlags & TF_HasStored ); sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); } #endif } } if( !isView ){ /* Do constraint checks. */ assert( regOldRowid>0 ); sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace, |
︙ | ︙ | |||
875 876 877 878 879 880 881 | ** all record selected by the WHERE clause have been updated. */ if( eOnePass==ONEPASS_SINGLE ){ /* Nothing to do at end-of-loop for a single-pass */ }else if( eOnePass==ONEPASS_MULTI ){ sqlite3VdbeResolveLabel(v, labelContinue); sqlite3WhereEnd(pWInfo); | | | 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 | ** all record selected by the WHERE clause have been updated. */ if( eOnePass==ONEPASS_SINGLE ){ /* Nothing to do at end-of-loop for a single-pass */ }else if( eOnePass==ONEPASS_MULTI ){ sqlite3VdbeResolveLabel(v, labelContinue); sqlite3WhereEnd(pWInfo); }else if( pPk || nChangeFrom ){ sqlite3VdbeResolveLabel(v, labelContinue); sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); }else{ sqlite3VdbeGoto(v, labelContinue); } sqlite3VdbeResolveLabel(v, labelBreak); |
︙ | ︙ | |||
978 979 980 981 982 983 984 | ** create and open the ephemeral table in which the records created from ** these arguments will be temporarily stored. */ assert( v ); ephemTab = pParse->nTab++; addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); regArg = pParse->nMem + 1; pParse->nMem += nArg; | > > > > > > > > > > > > > > > > > > > > > > > > | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | > > | > | 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 | ** create and open the ephemeral table in which the records created from ** these arguments will be temporarily stored. */ assert( v ); ephemTab = pParse->nTab++; addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); regArg = pParse->nMem + 1; pParse->nMem += nArg; if( pSrc->nSrc>1 ){ Expr *pRow; ExprList *pList; if( pRowid ){ pRow = sqlite3ExprDup(db, pRowid, 0); }else{ pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0); } pList = sqlite3ExprListAppend(pParse, 0, pRow); for(i=0; i<pTab->nCol; i++){ if( aXRef[i]>=0 ){ pList = sqlite3ExprListAppend(pParse, pList, sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0) ); }else{ pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); } } updateFromSelect(pParse, ephemTab, 0, pList, pSrc, pWhere, 0, 0); sqlite3ExprListDelete(db, pList); eOnePass = ONEPASS_OFF; }else{ regRec = ++pParse->nMem; regRowid = ++pParse->nMem; /* Start scanning the virtual table */ pWInfo = sqlite3WhereBegin(pParse, pSrc,pWhere,0,0,WHERE_ONEPASS_DESIRED,0); if( pWInfo==0 ) return; /* Populate the argument registers. */ for(i=0; i<pTab->nCol; i++){ assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ); if( aXRef[i]>=0 ){ sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i); }else{ sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i); sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */ } } if( HasRowid(pTab) ){ sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg); if( pRowid ){ sqlite3ExprCode(pParse, pRowid, regArg+1); }else{ sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1); } }else{ Index *pPk; /* PRIMARY KEY index */ i16 iPk; /* PRIMARY KEY column */ pPk = sqlite3PrimaryKeyIndex(pTab); assert( pPk!=0 ); assert( pPk->nKeyCol==1 ); iPk = pPk->aiColumn[0]; sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg); sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1); } eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy); /* There is no ONEPASS_MULTI on virtual tables */ assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); if( eOnePass ){ /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded ** above. */ sqlite3VdbeChangeToNoop(v, addr); sqlite3VdbeAddOp1(v, OP_Close, iCsr); }else{ /* Create a record from the argument register contents and insert it into ** the ephemeral table. */ sqlite3MultiWrite(pParse); sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec); #if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM) /* Signal an assert() within OP_MakeRecord that it is allowed to ** accept no-change records with serial_type 10 */ sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC); #endif sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid); sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid); } } if( eOnePass==ONEPASS_OFF ){ /* End the virtual table scan */ if( pSrc->nSrc==1 ){ sqlite3WhereEnd(pWInfo); } /* Begin scannning through the ephemeral table. */ addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v); /* Extract arguments from the current row of the ephemeral table and ** invoke the VUpdate method. */ for(i=0; i<nArg; i++){ |
︙ | ︙ |
Changes to test/altertab3.test.
︙ | ︙ | |||
581 582 583 584 585 586 587 588 589 590 | ALTER TABLE v0 RENAME TO xyz; SELECT sql FROM sqlite_master WHERE type='trigger' } {{CREATE TRIGGER x AFTER INSERT ON v2 WHEN ( 0 AND (SELECT rowid FROM "xyz") ) BEGIN DELETE FROM v2; END}} finish_test | > > > > > > > > > > > > > > | 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 | ALTER TABLE v0 RENAME TO xyz; SELECT sql FROM sqlite_master WHERE type='trigger' } {{CREATE TRIGGER x AFTER INSERT ON v2 WHEN ( 0 AND (SELECT rowid FROM "xyz") ) BEGIN DELETE FROM v2; END}} #------------------------------------------------------------------------ # reset_db do_execsql_test 25.1 { CREATE TABLE t1(a, b, c); CREATE TABLE t2(a, b, c); CREATE TRIGGER ttt AFTER INSERT ON t1 BEGIN UPDATE t1 SET a=t2.a FROM t2 WHERE t1.a=t2.a; END; } #do_execsql_test 25.2 { # ALTER TABLE t2 RENAME COLUMN a TO aaa; #} finish_test |
Added test/fts4upfrom.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | # 2020 February 24 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #************************************************************************* # This file implements regression tests for SQLite library. The # focus of this script is testing UPDATE statements with FROM clauses # against FTS4 tables. # # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix fts4upfrom # If SQLITE_ENABLE_FTS3 is defined, omit this file. ifcapable !fts3 { finish_test return } foreach {tn create_table} { 0 { CREATE VIRTUAL TABLE ft USING fts5(a, b, c) } 1 { CREATE VIRTUAL TABLE ft USING fts3(a, b, c) } 2 { CREATE TABLE ft(a, b, c) } 3 { CREATE TABLE real(a, b, c); CREATE INDEX i1 ON real(a); CREATE VIEW ft AS SELECT rowid, a, b, c FROM real; CREATE TRIGGER tr1 INSTEAD OF INSERT ON ft BEGIN INSERT INTO real(rowid, a, b, c) VALUES(new.rowid, new.a, new.b, new.c); END; CREATE TRIGGER tr2 INSTEAD OF UPDATE ON ft BEGIN UPDATE real SET rowid=new.rowid, a=new.a, b=new.b, c=new.c WHERE rowid=old.rowid; END; } } { if {$tn==0} { ifcapable !fts5 { continue } } catchsql { DROP VIEW IF EXISTS changes } catchsql { DROP TABLE IF EXISTS ft } catchsql { DROP VIEW IF EXISTS ft } execsql $create_table do_execsql_test 1.$tn.0 { INSERT INTO ft(a, b, c) VALUES('a', NULL, 'apple'); INSERT INTO ft(a, b, c) VALUES('b', NULL, 'banana'); INSERT INTO ft(a, b, c) VALUES('c', NULL, 'cherry'); INSERT INTO ft(a, b, c) VALUES('d', NULL, 'damson plum'); } do_execsql_test 1.$tn.1 { SELECT a, b, c FROM ft ORDER BY rowid; } { a {} apple b {} banana c {} cherry d {} {damson plum} } do_execsql_test 1.$tn.2 { UPDATE ft SET b=o.c FROM ft AS o WHERE (ft.a == char(unicode(o.a)+1)) } do_execsql_test 1.$tn.3 { SELECT a, b, c FROM ft ORDER BY rowid; } { a {} apple b apple banana c banana cherry d cherry {damson plum} } do_catchsql_test 1.$tn.4 { UPDATE ft SET c=v FROM changes WHERE a=k; } {1 {no such table: changes}} do_execsql_test 1.$tn.5 { create view changes(k, v) AS VALUES( 'd', 'dewberry' ) UNION ALL VALUES( 'c', 'clementine' ) UNION ALL VALUES( 'b', 'blueberry' ) UNION ALL VALUES( 'a', 'apricot' ) ; } do_execsql_test 1.$tn.6 { UPDATE ft SET c=v FROM changes WHERE a=k; } do_execsql_test 1.$tn.7 { SELECT rowid, a, b, c FROM ft ORDER BY rowid; } { 1 a {} apricot 2 b apple blueberry 3 c banana clementine 4 d cherry dewberry } do_execsql_test 1.$tn.8 " WITH x1(o, n) AS ( VALUES(1, 11) UNION ALL VALUES(2, 12) UNION ALL VALUES(3, 13) UNION ALL VALUES(4, 14) ) SELECT ft.rowid, a, b, c, o, n FROM ft, x1 WHERE ft.rowid = o; " { 1 a {} apricot 1 11 2 b apple blueberry 2 12 3 c banana clementine 3 13 4 d cherry dewberry 4 14 } set ROWID rowid if {$tn==1} { set ROWID docid } do_execsql_test 1.$tn.9 " WITH x1(o, n) AS ( VALUES(1, 11) UNION ALL VALUES(2, 12) UNION ALL VALUES(3, 13) UNION ALL VALUES(4, 14) ) UPDATE ft SET $ROWID = n FROM x1 WHERE ft.rowid = o; SELECT rowid, a, b, c FROM ft ORDER BY rowid; " { 11 a {} apricot 12 b apple blueberry 13 c banana clementine 14 d cherry dewberry } } finish_test |
Changes to test/pg_common.tcl.
︙ | ︙ | |||
13 14 15 16 17 18 19 20 21 22 23 24 25 26 | package require sqlite3 package require Pgtcl set db [pg_connect -conninfo "dbname=postgres user=postgres password=postgres"] sqlite3 sqlite "" proc execsql {sql} { set lSql [list] set frag "" while {[string length $sql]>0} { set i [string first ";" $sql] if {$i>=0} { append frag [string range $sql 0 $i] | > > | 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | package require sqlite3 package require Pgtcl set db [pg_connect -conninfo "dbname=postgres user=postgres password=postgres"] sqlite3 sqlite "" proc execsql {sql} { set sql [string map {{WITHOUT ROWID} {}} $sql] set lSql [list] set frag "" while {[string length $sql]>0} { set i [string first ";" $sql] if {$i>=0} { append frag [string range $sql 0 $i] |
︙ | ︙ |
Changes to test/tester.tcl.
︙ | ︙ | |||
125 126 127 128 129 130 131 132 133 134 135 136 137 138 | if {[info exists ::G(perm:presql)]} { [lindex $args 0] eval $::G(perm:presql) } if {[info exists ::G(perm:dbconfig)]} { set ::dbhandle [lindex $args 0] uplevel #0 $::G(perm:dbconfig) } set res } else { # This command is not opening a new database connection. Pass the # arguments through to the C implementation as the are. # uplevel 1 sqlite_orig $args } | > | 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | if {[info exists ::G(perm:presql)]} { [lindex $args 0] eval $::G(perm:presql) } if {[info exists ::G(perm:dbconfig)]} { set ::dbhandle [lindex $args 0] uplevel #0 $::G(perm:dbconfig) } [lindex $args 0] cache size 3 set res } else { # This command is not opening a new database connection. Pass the # arguments through to the C implementation as the are. # uplevel 1 sqlite_orig $args } |
︙ | ︙ |
Added test/triggerupfrom.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | # 2020 July 14 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix triggerupfrom do_execsql_test 1.0 { CREATE TABLE map(k, v); INSERT INTO map VALUES(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four'); CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c); CREATE TRIGGER tr AFTER INSERT ON t1 BEGIN UPDATE t1 SET c = v FROM map WHERE k=new.a AND a=new.a; END; } do_execsql_test 1.1 { INSERT INTO t1(a) VALUES(1); } do_execsql_test 1.2 { SELECT a, c FROM t1 ORDER BY a; } {1 one} do_execsql_test 1.3 { INSERT INTO t1(a) VALUES(2), (3), (4), (5); SELECT a, c FROM t1 ORDER BY a; } {1 one 2 two 3 three 4 four 5 {}} forcedelete test.db2 do_execsql_test 2.0 { ATTACH 'test.db2' AS aux; CREATE TABLE aux.t3(x, y); INSERT INTO aux.t3 VALUES('x', 'y'); } do_catchsql_test 2.1 { CREATE TRIGGER tr2 AFTER INSERT ON t1 BEGIN UPDATE t1 SET b = y FROM aux.t3 WHERE k=new.a; END; } {1 {trigger tr2 cannot reference objects in database aux}} do_execsql_test 2.2 { CREATE TEMP TRIGGER tr2 AFTER INSERT ON t1 BEGIN UPDATE t1 SET b = y FROM aux.t3 WHERE a=new.a; END; INSERT INTO t1(a) VALUES(10), (20); SELECT * FROM t1; } { 1 {} one 2 {} two 3 {} three 4 {} four 5 {} {} 10 y {} 20 y {} } do_execsql_test 2.3 { CREATE TABLE link(f, t); INSERT INTO link VALUES(5, 2), (20, 10), (2, 1); CREATE TRIGGER tr3 BEFORE DELETE ON t1 BEGIN UPDATE t1 SET b=coalesce(old.b,old.c) FROM main.link WHERE a=t AND old.a=f; END; DELETE FROM t1 WHERE a=2; SELECT * FROM t1; } { 1 two one 3 {} three 4 {} four 5 {} {} 10 y {} 20 y {} } db close sqlite3 db "" do_catchsql_test 2.4 { ATTACH 'test.db' AS yyy; SELECT * FROM t1; } {1 {malformed database schema (tr3) - trigger tr3 cannot reference objects in database main}} #------------------------------------------------------------------------- reset_db forcedelete test.db2 do_execsql_test 3.0 { CREATE TABLE mmm(x, y); INSERT INTO mmm VALUES(1, 'one'); INSERT INTO mmm VALUES(2, 'two'); INSERT INTO mmm VALUES(3, 'three'); ATTACH 'test.db2' AS aux; CREATE TABLE aux.t1(a, b); CREATE TABLE aux.mmm(x, y); INSERT INTO aux.mmm VALUES(1, 'ONE'); INSERT INTO aux.mmm VALUES(2, 'TWO'); INSERT INTO aux.mmm VALUES(3, 'THREE'); CREATE TRIGGER aux.ttt AFTER INSERT ON t1 BEGIN UPDATE t1 SET b=y FROM mmm WHERE x=new.a AND a=new.a; END; INSERT INTO t1(a) VALUES (2); SELECT * FROM t1; } {2 TWO} #------------------------------------------------------------------------- # Test that INSTEAD OF UPDATE triggers on views work with UPDATE...FROM # statements. Including, if the library is built with ENABLE_HIDDEN_COLUMNS, # that they work correctly on views with hidden columns. # reset_db do_execsql_test 4.0 { CREATE TABLE t1(k, a, b); INSERT INTO t1 VALUES('a', 1, 'one'); INSERT INTO t1 VALUES('b', 2, 'two'); INSERT INTO t1 VALUES('c', 3, 'three'); INSERT INTO t1 VALUES('d', 4, 'four'); CREATE TABLE log(x); CREATE VIEW v1 AS SELECT k, a, b AS __hidden__b FROM t1; CREATE TRIGGER tr1 INSTEAD OF UPDATE ON v1 BEGIN INSERT INTO log VALUES( '('||old.a||','||old.__hidden__b||')->('||new.a||','||new.__hidden__b||')' ); END; } ifcapable hiddencolumns { do_execsql_test 4.1-hc-enabled { SELECT * FROM v1 } {a 1 b 2 c 3 d 4} } else { do_execsql_test 4.1-hc-disabled { SELECT * FROM v1 } {a 1 one b 2 two c 3 three d 4 four} } do_execsql_test 4.2 { UPDATE v1 SET a='xyz' WHERE k IN ('a', 'c'); SELECT * FROM log; DELETE FROM log; } { (1,one)->(xyz,one) (3,three)->(xyz,three) } do_execsql_test 4.3 { CREATE TABLE map(k, v); INSERT INTO map VALUES('b', 'twelve'); INSERT INTO map VALUES('d', 'fourteen'); UPDATE v1 SET a=map.v FROM map WHERE v1.k=map.k; SELECT * FROM log; DELETE FROM log; } { (2,two)->(twelve,two) (4,four)->(fourteen,four) } finish_test |
Added test/upfrom1.tcl.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 | # 2020 April 22 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # source [file join [file dirname $argv0] pg_common.tcl] #========================================================================= start_test upfrom1 "2020 April 22" foreach {tn wo} { 1 "WITHOUT ROWID" 2 "" } { eval [string map [list %TN% $tn %WITHOUT_ROWID% $wo] { execsql_test 1.%TN%.0 { DROP TABLE IF EXISTS t2; CREATE TABLE t2(a INTEGER PRIMARY KEY, b INTEGER, c INTEGER) %WITHOUT_ROWID%; INSERT INTO t2 VALUES(1, 2, 3); INSERT INTO t2 VALUES(4, 5, 6); INSERT INTO t2 VALUES(7, 8, 9); DROP TABLE IF EXISTS chng; CREATE TABLE chng(a INTEGER, b INTEGER, c INTEGER); INSERT INTO chng VALUES(1, 100, 1000); INSERT INTO chng VALUES(7, 700, 7000); } execsql_test 1.%TN%.1 { SELECT * FROM t2; } execsql_test 1.%TN%.2 { UPDATE t2 SET b = chng.b, c = chng.c FROM chng WHERE chng.a = t2.a; SELECT * FROM t2 ORDER BY a; } execsql_test 1.%TN%.3 { DELETE FROM t2; INSERT INTO t2 VALUES(1, 2, 3); INSERT INTO t2 VALUES(4, 5, 6); INSERT INTO t2 VALUES(7, 8, 9); } execsql_test 1.%TN%.4 { UPDATE t2 SET (b, c) = (SELECT b, c FROM chng WHERE a=t2.a) WHERE a IN (SELECT a FROM chng); SELECT * FROM t2 ORDER BY a; } execsql_test 1.%TN%.5 { DROP TABLE IF EXISTS t3; CREATE TABLE t3(a INTEGER PRIMARY KEY, b INTEGER, c TEXT) %WITHOUT_ROWID%; INSERT INTO t3 VALUES(1, 1, 'one'); INSERT INTO t3 VALUES(2, 2, 'two'); INSERT INTO t3 VALUES(3, 3, 'three'); DROP TABLE IF EXISTS t4; CREATE TABLE t4(x TEXT); INSERT INTO t4 VALUES('five'); SELECT * FROM t3 ORDER BY a; } execsql_test 1.%TN%.6 { UPDATE t3 SET c=x FROM t4; SELECT * FROM t3 ORDER BY a; } }]} execsql_test 2.1 { DROP TABLE IF EXISTS t5; DROP TABLE IF EXISTS m1; DROP TABLE IF EXISTS m2; CREATE TABLE t5(a INTEGER PRIMARY KEY, b TEXT, c TEXT); CREATE TABLE m1(x INTEGER PRIMARY KEY, y TEXT); CREATE TABLE m2(u INTEGER PRIMARY KEY, v TEXT); INSERT INTO t5 VALUES(1, 'one', 'ONE'); INSERT INTO t5 VALUES(2, 'two', 'TWO'); INSERT INTO t5 VALUES(3, 'three', 'THREE'); INSERT INTO t5 VALUES(4, 'four', 'FOUR'); INSERT INTO m1 VALUES(1, 'i'); INSERT INTO m1 VALUES(2, 'ii'); INSERT INTO m1 VALUES(3, 'iii'); INSERT INTO m2 VALUES(1, 'I'); INSERT INTO m2 VALUES(3, 'II'); INSERT INTO m2 VALUES(4, 'III'); } execsql_test 2.2 { UPDATE t5 SET b=y, c=v FROM m1 LEFT JOIN m2 ON (x=u) WHERE x=a; SELECT * FROM t5 ORDER BY a; } errorsql_test 2.3.1 { UPDATE t5 SET b=1 FROM t5; } errorsql_test 2.3.2 { UPDATE t5 AS apples SET b=1 FROM t5 AS apples; } finish_test |
Added test/upfrom1.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | # 2020 April 22 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. # #################################################### # DO NOT EDIT! THIS FILE IS AUTOMATICALLY GENERATED! #################################################### set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix upfrom1 do_execsql_test 1.1.0 { DROP TABLE IF EXISTS t2; CREATE TABLE t2(a INTEGER PRIMARY KEY, b INTEGER, c INTEGER) WITHOUT ROWID; INSERT INTO t2 VALUES(1, 2, 3); INSERT INTO t2 VALUES(4, 5, 6); INSERT INTO t2 VALUES(7, 8, 9); DROP TABLE IF EXISTS chng; CREATE TABLE chng(a INTEGER, b INTEGER, c INTEGER); INSERT INTO chng VALUES(1, 100, 1000); INSERT INTO chng VALUES(7, 700, 7000); } {} do_execsql_test 1.1.1 { SELECT * FROM t2; } {1 2 3 4 5 6 7 8 9} do_execsql_test 1.1.2 { UPDATE t2 SET b = chng.b, c = chng.c FROM chng WHERE chng.a = t2.a; SELECT * FROM t2 ORDER BY a; } {1 100 1000 4 5 6 7 700 7000} do_execsql_test 1.1.3 { DELETE FROM t2; INSERT INTO t2 VALUES(1, 2, 3); INSERT INTO t2 VALUES(4, 5, 6); INSERT INTO t2 VALUES(7, 8, 9); } {} do_execsql_test 1.1.4 { UPDATE t2 SET (b, c) = (SELECT b, c FROM chng WHERE a=t2.a) WHERE a IN (SELECT a FROM chng); SELECT * FROM t2 ORDER BY a; } {1 100 1000 4 5 6 7 700 7000} do_execsql_test 1.1.5 { DROP TABLE IF EXISTS t3; CREATE TABLE t3(a INTEGER PRIMARY KEY, b INTEGER, c TEXT) WITHOUT ROWID; INSERT INTO t3 VALUES(1, 1, 'one'); INSERT INTO t3 VALUES(2, 2, 'two'); INSERT INTO t3 VALUES(3, 3, 'three'); DROP TABLE IF EXISTS t4; CREATE TABLE t4(x TEXT); INSERT INTO t4 VALUES('five'); SELECT * FROM t3 ORDER BY a; } {1 1 one 2 2 two 3 3 three} do_execsql_test 1.1.6 { UPDATE t3 SET c=x FROM t4; SELECT * FROM t3 ORDER BY a; } {1 1 five 2 2 five 3 3 five} do_execsql_test 1.2.0 { DROP TABLE IF EXISTS t2; CREATE TABLE t2(a INTEGER PRIMARY KEY, b INTEGER, c INTEGER) ; INSERT INTO t2 VALUES(1, 2, 3); INSERT INTO t2 VALUES(4, 5, 6); INSERT INTO t2 VALUES(7, 8, 9); DROP TABLE IF EXISTS chng; CREATE TABLE chng(a INTEGER, b INTEGER, c INTEGER); INSERT INTO chng VALUES(1, 100, 1000); INSERT INTO chng VALUES(7, 700, 7000); } {} do_execsql_test 1.2.1 { SELECT * FROM t2; } {1 2 3 4 5 6 7 8 9} do_execsql_test 1.2.2 { UPDATE t2 SET b = chng.b, c = chng.c FROM chng WHERE chng.a = t2.a; SELECT * FROM t2 ORDER BY a; } {1 100 1000 4 5 6 7 700 7000} do_execsql_test 1.2.3 { DELETE FROM t2; INSERT INTO t2 VALUES(1, 2, 3); INSERT INTO t2 VALUES(4, 5, 6); INSERT INTO t2 VALUES(7, 8, 9); } {} do_execsql_test 1.2.4 { UPDATE t2 SET (b, c) = (SELECT b, c FROM chng WHERE a=t2.a) WHERE a IN (SELECT a FROM chng); SELECT * FROM t2 ORDER BY a; } {1 100 1000 4 5 6 7 700 7000} do_execsql_test 1.2.5 { DROP TABLE IF EXISTS t3; CREATE TABLE t3(a INTEGER PRIMARY KEY, b INTEGER, c TEXT) ; INSERT INTO t3 VALUES(1, 1, 'one'); INSERT INTO t3 VALUES(2, 2, 'two'); INSERT INTO t3 VALUES(3, 3, 'three'); DROP TABLE IF EXISTS t4; CREATE TABLE t4(x TEXT); INSERT INTO t4 VALUES('five'); SELECT * FROM t3 ORDER BY a; } {1 1 one 2 2 two 3 3 three} do_execsql_test 1.2.6 { UPDATE t3 SET c=x FROM t4; SELECT * FROM t3 ORDER BY a; } {1 1 five 2 2 five 3 3 five} do_execsql_test 2.1 { DROP TABLE IF EXISTS t5; DROP TABLE IF EXISTS m1; DROP TABLE IF EXISTS m2; CREATE TABLE t5(a INTEGER PRIMARY KEY, b TEXT, c TEXT); CREATE TABLE m1(x INTEGER PRIMARY KEY, y TEXT); CREATE TABLE m2(u INTEGER PRIMARY KEY, v TEXT); INSERT INTO t5 VALUES(1, 'one', 'ONE'); INSERT INTO t5 VALUES(2, 'two', 'TWO'); INSERT INTO t5 VALUES(3, 'three', 'THREE'); INSERT INTO t5 VALUES(4, 'four', 'FOUR'); INSERT INTO m1 VALUES(1, 'i'); INSERT INTO m1 VALUES(2, 'ii'); INSERT INTO m1 VALUES(3, 'iii'); INSERT INTO m2 VALUES(1, 'I'); INSERT INTO m2 VALUES(3, 'II'); INSERT INTO m2 VALUES(4, 'III'); } {} do_execsql_test 2.2 { UPDATE t5 SET b=y, c=v FROM m1 LEFT JOIN m2 ON (x=u) WHERE x=a; SELECT * FROM t5 ORDER BY a; } {1 i I 2 ii {} 3 iii II 4 four FOUR} # PG says ERROR: table name "t5" specified more than once do_test 2.3.1 { catch { execsql { UPDATE t5 SET b=1 FROM t5; } } } 1 # PG says ERROR: table name "apples" specified more than once do_test 2.3.2 { catch { execsql { UPDATE t5 AS apples SET b=1 FROM t5 AS apples; } } } 1 finish_test |
Added test/upfrom2.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 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 206 207 208 209 210 211 212 213 214 215 216 217 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 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 | # 2020 April 29 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix upfrom2 # Test cases: # # 1.*: Test that triggers are fired correctly for UPDATE FROM statements, # and only once for each row. Except for INSTEAD OF triggers on # views - these are fired once for each row returned by the join, # including duplicates. # # 2.*: Test adding ORDER BY and LIMIT clauses with UPDATE FROM statements. # # 5.*: Test that specifying the target table name or alias in the FROM # clause of an UPDATE statement is an error. # foreach {tn wo} { 1 "" 2 "WITHOUT ROWID" } { reset_db eval [string map [list %WO% $wo %TN% $tn] { do_execsql_test 1.%TN%.0 { CREATE TABLE log(t TEXT); CREATE TABLE t1(x PRIMARY KEY, y, z UNIQUE) %WO%; CREATE INDEX t1y ON t1(y); INSERT INTO t1 VALUES(1, 'i', 'one'); INSERT INTO t1 VALUES(2, 'ii', 'two'); INSERT INTO t1 VALUES(3, 'iii', 'three'); INSERT INTO t1 VALUES(4, 'iv', 'four'); CREATE TRIGGER tr1 BEFORE UPDATE ON t1 BEGIN INSERT INTO log VALUES(old.z || '->' || new.z); END; CREATE TRIGGER tr2 AFTER UPDATE ON t1 BEGIN INSERT INTO log VALUES(old.y || '->' || new.y); END; } do_execsql_test 1.%TN%.1 { WITH data(k, v) AS ( VALUES(3, 'thirty'), (1, 'ten') ) UPDATE t1 SET z=v FROM data WHERE x=k; SELECT * FROM t1; SELECT * FROM log; } { 1 i ten 2 ii two 3 iii thirty 4 iv four one->ten i->i three->thirty iii->iii } do_execsql_test 1.%TN%.2 { CREATE TABLE t2(a, b); CREATE TABLE t3(k, v); INSERT INTO t3 VALUES(5, 'v'); INSERT INTO t3 VALUES(12, 'xii'); INSERT INTO t2 VALUES(2, 12); INSERT INTO t2 VALUES(3, 5); DELETE FROM log; UPDATE t1 SET y=v FROM t2, t3 WHERE t1.x=t2.a AND t3.k=t2.b; SELECT * FROM t1; SELECT * FROM log; } { 1 i ten 2 xii two 3 v thirty 4 iv four two->two ii->xii thirty->thirty iii->v } do_execsql_test 1.%TN%.3 { DELETE FROM log; WITH data(k, v) AS ( VALUES(1, 'seven'), (1, 'eight'), (2, 'eleven'), (2, 'twelve') ) UPDATE t1 SET z=v FROM data WHERE x=k; SELECT * FROM t1; SELECT * FROM log; } { 1 i eight 2 xii twelve 3 v thirty 4 iv four ten->eight i->i two->twelve xii->xii } do_test 1.%TN%.4 { db changes } {2} do_execsql_test 1.%TN%.5 { CREATE VIEW v1 AS SELECT * FROM t1; CREATE TRIGGER v1tr INSTEAD OF UPDATE ON v1 BEGIN UPDATE t1 SET y=new.y, z=new.z WHERE x=new.x; END; DELETE FROM log; WITH data(k, v) AS ( VALUES(3, 'thirteen'), (3, 'fourteen'), (4, 'fifteen'), (4, 'sixteen') ) UPDATE v1 SET z=v FROM data WHERE x=k; } do_execsql_test 1.%TN%.6 { SELECT * FROM v1; SELECT * FROM log; } { 1 i eight 2 xii twelve 3 v fourteen 4 iv sixteen thirty->thirteen v->v thirteen->fourteen v->v four->fifteen iv->iv fifteen->sixteen iv->iv } #-------------------------------------------------------------- do_execsql_test 1.%TN%.7 { CREATE TABLE o1(w, x, y, z UNIQUE, PRIMARY KEY(w, x)) %WO%; CREATE INDEX o1y ON t1(y); INSERT INTO o1 VALUES(0, 0, 'i', 'one'); INSERT INTO o1 VALUES(0, 1, 'ii', 'two'); INSERT INTO o1 VALUES(1, 0, 'iii', 'three'); INSERT INTO o1 VALUES(1, 1, 'iv', 'four'); CREATE TRIGGER tro1 BEFORE UPDATE ON o1 BEGIN INSERT INTO log VALUES(old.z || '->' || new.z); END; CREATE TRIGGER tro2 AFTER UPDATE ON o1 BEGIN INSERT INTO log VALUES(old.y || '->' || new.y); END; } do_execsql_test 1.%TN%.8 { DELETE FROM log; WITH data(k, v) AS ( VALUES(3, 'thirty'), (1, 'ten') ) UPDATE o1 SET z=v FROM data WHERE (1+x+w*2)=k; SELECT * FROM o1; SELECT * FROM log; } { 0 0 i ten 0 1 ii two 1 0 iii thirty 1 1 iv four one->ten i->i three->thirty iii->iii } do_execsql_test 1.%TN%.9 { DELETE FROM log; UPDATE o1 SET y=v FROM t2, t3 WHERE (1+o1.w*2+o1.x)=t2.a AND t3.k=t2.b; SELECT * FROM o1; SELECT * FROM log; } { 0 0 i ten 0 1 xii two 1 0 v thirty 1 1 iv four two->two ii->xii thirty->thirty iii->v } do_execsql_test 1.%TN%.10 { DELETE FROM log; WITH data(k, v) AS ( VALUES(1, 'seven'), (1, 'eight'), (2, 'eleven'), (2, 'twelve') ) UPDATE o1 SET z=v FROM data WHERE (1+w*2+x)=k; SELECT * FROM o1; SELECT * FROM log; } { 0 0 i eight 0 1 xii twelve 1 0 v thirty 1 1 iv four ten->eight i->i two->twelve xii->xii } do_test 1.%TN%.11 { db changes } {2} do_execsql_test 1.%TN%.12 { CREATE VIEW w1 AS SELECT * FROM o1; CREATE TRIGGER w1tr INSTEAD OF UPDATE ON w1 BEGIN UPDATE o1 SET y=new.y, z=new.z WHERE w=new.w AND x=new.x; END; DELETE FROM log; WITH data(k, v) AS ( VALUES(3, 'thirteen'), (3, 'fourteen'), (4, 'fifteen'), (4, 'sixteen') ) UPDATE w1 SET z=v FROM data WHERE (1+w*2+x)=k; } do_execsql_test 1.%TN%.13 { SELECT * FROM w1; SELECT * FROM log; } { 0 0 i eight 0 1 xii twelve 1 0 v fourteen 1 1 iv sixteen thirty->thirteen v->v thirteen->fourteen v->v four->fifteen iv->iv fifteen->sixteen iv->iv } }] } ifcapable update_delete_limit { foreach {tn wo} { 1 "" 2 "WITHOUT ROWID" } { reset_db eval [string map [list %WO% $wo %TN% $tn] { do_execsql_test 2.%TN%.1 { CREATE TABLE x1(a INTEGER PRIMARY KEY, b) %WO%; INSERT INTO x1 VALUES (1, 'one'), (2, 'two'), (3, 'three'), (4, 'four'), (5, 'five'), (6, 'six'), (7, 'seven'), (8, 'eight'); } do_execsql_test 2.%TN%.2 { CREATE TABLE data1(x, y); INSERT INTO data1 VALUES (1, 'eleven'), (1, 'twenty-one'), (2, 'twelve'), (2, 'twenty-two'), (3, 'thirteen'), (3, 'twenty-three'), (4, 'fourteen'), (4, 'twenty-four'); } do_execsql_test 2.%TN%.3 { UPDATE x1 SET b=y FROM data1 WHERE a=x ORDER BY a LIMIT 3; SELECT * FROM x1; } { 1 eleven 2 twelve 3 thirteen 4 four 5 five 6 six 7 seven 8 eight } do_execsql_test 2.%TN%.4 { UPDATE x1 SET b=b||y FROM data1 WHERE a=x ORDER BY b LIMIT 3; SELECT * FROM x1; } { 1 eleveneleven 2 twelve 3 thirteenthirteen 4 fourfourteen 5 five 6 six 7 seven 8 eight } do_catchsql_test 2.%TN%.5 { UPDATE x1 SET b=b||b ORDER BY b; } {1 {ORDER BY without LIMIT on UPDATE}} do_catchsql_test 2.%TN%.6 { UPDATE x1 SET b=b||y FROM data1 WHERE a=x ORDER BY b; } {1 {ORDER BY without LIMIT on UPDATE}} #----------------------------------------------------------------------- do_execsql_test 2.%TN%.6 { DROP TABLE x1; CREATE TABLE x1(u, v, b, PRIMARY KEY(u, v)) %WO%; INSERT INTO x1 VALUES (0, 1, 'one'), (1, 0, 'two'), (1, 1, 'three'), (2, 0, 'four'), (2, 1, 'five'), (3, 0, 'six'), (3, 1, 'seven'), (4, 0, 'eight'); } do_execsql_test 2.%TN%.7 { UPDATE x1 SET b=y FROM data1 WHERE (u*2+v)=x ORDER BY u, v LIMIT 3; SELECT * FROM x1; } { 0 1 eleven 1 0 twelve 1 1 thirteen 2 0 four 2 1 five 3 0 six 3 1 seven 4 0 eight } do_execsql_test 2.%TN%.8 { UPDATE x1 SET b=b||y FROM data1 WHERE (u*2+v)=x ORDER BY b LIMIT 3; SELECT * FROM x1; } { 0 1 eleveneleven 1 0 twelve 1 1 thirteenthirteen 2 0 fourfourteen 2 1 five 3 0 six 3 1 seven 4 0 eight } }] }} reset_db do_execsql_test 3.0 { CREATE TABLE data(x, y, z); CREATE VIEW t1 AS SELECT * FROM data; CREATE TRIGGER t1_insert INSTEAD OF INSERT ON t1 BEGIN INSERT INTO data VALUES(new.x, new.y, new.z); END; CREATE TRIGGER t1_update INSTEAD OF UPDATE ON t1 BEGIN INSERT INTO log VALUES(old.z || '->' || new.z); END; CREATE TABLE log(t TEXT); INSERT INTO t1 VALUES(1, 'i', 'one'); INSERT INTO t1 VALUES(2, 'ii', 'two'); INSERT INTO t1 VALUES(3, 'iii', 'three'); INSERT INTO t1 VALUES(4, 'iv', 'four'); } do_execsql_test 3.1 { WITH input(k, v) AS ( VALUES(3, 'thirty'), (1, 'ten') ) UPDATE t1 SET z=v FROM input WHERE x=k; } foreach {tn sql} { 2 { CREATE TABLE x1(a INT PRIMARY KEY, b, c) WITHOUT ROWID; } 1 { CREATE TABLE x1(a INTEGER PRIMARY KEY, b, c); } 3 { CREATE TABLE x1(a INT PRIMARY KEY, b, c); } } { reset_db execsql $sql do_execsql_test 4.$tn.0 { INSERT INTO x1 VALUES(1, 1, 1); INSERT INTO x1 VALUES(2, 2, 2); INSERT INTO x1 VALUES(3, 3, 3); INSERT INTO x1 VALUES(4, 4, 4); INSERT INTO x1 VALUES(5, 5, 5); CREATE TABLE map(o, t); INSERT INTO map VALUES(3, 30), (4, 40), (1, 10); } do_execsql_test 4.$tn.1 { UPDATE x1 SET a=t FROM map WHERE a=o; SELECT * FROM x1 ORDER BY a; } {2 2 2 5 5 5 10 1 1 30 3 3 40 4 4} } reset_db do_execsql_test 5.0 { CREATE TABLE x1(a, b, c); CREATE TABLE x2(a, b, c); } foreach {tn update nm} { 1 "UPDATE x1 SET a=5 FROM x1" x1 2 "UPDATE x1 AS grapes SET a=5 FROM x1 AS grapes" grapes 3 "UPDATE x1 SET a=5 FROM x2, x1" x1 4 "UPDATE x1 AS grapes SET a=5 FROM x2, x1 AS grapes" grapes } { do_catchsql_test 5.$tn $update \ "1 {target object/alias may not appear in FROM clause: $nm}" } finish_test |
Added test/upfrom3.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 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 206 207 208 209 210 211 212 213 214 215 216 217 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 | # 2020 July 14 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix upfrom3 # Test plan: # # 1.*: Test UPDATE ... FROM statements that modify IPK fields. And that # modify "INTEGER PRIMARY KEY" fields on WITHOUT ROWID tables. # # 2.*: Test UPDATE ... FROM statements that modify PK fields of WITHOUT # ROWID tables. # # 3.*: Test that UPDATE ... FROM statements are not confused if there # are multiple tables of the same name in attached databases. # # 4.*: Tests for UPDATE ... FROM statements and foreign keys. # foreach {tn wo} { 1 "" 2 "WITHOUT ROWID" } { reset_db eval [string map [list %WO% $wo %TN% $tn] { do_execsql_test 1.%TN%.0 { CREATE TABLE log(t TEXT); CREATE TABLE t1(x INTEGER PRIMARY KEY, y, z UNIQUE) %WO%; CREATE INDEX t1y ON t1(y); INSERT INTO t1 VALUES(1, 'i', 'one'); INSERT INTO t1 VALUES(2, 'ii', 'two'); INSERT INTO t1 VALUES(3, 'iii', 'three'); INSERT INTO t1 VALUES(4, 'iv', 'four'); } do_execsql_test 1.%TN%.1 { CREATE TABLE x1(o, n); INSERT INTO x1 VALUES(1, 11); INSERT INTO x1 VALUES(2, 12); INSERT INTO x1 VALUES(3, 13); INSERT INTO x1 VALUES(4, 14); UPDATE t1 SET x=n FROM x1 WHERE x=o; SELECT x, y, z FROM t1 ORDER BY 1; } { 11 i one 12 ii two 13 iii three 14 iv four } do_test 1.%TN%.2 { db changes } 4 do_execsql_test 1.%TN%.3 { INSERT INTO x1 VALUES(11, 21); INSERT INTO x1 VALUES(12, 22); INSERT INTO x1 VALUES(13, 23); INSERT INTO x1 VALUES(14, 24); INSERT INTO x1 VALUES(21, 31); INSERT INTO x1 VALUES(22, 32); INSERT INTO x1 VALUES(23, 33); INSERT INTO x1 VALUES(24, 34); UPDATE t1 SET x=n FROM x1 WHERE x=o; SELECT x, y, z FROM t1 ORDER BY 1; } { 21 i one 22 ii two 23 iii three 24 iv four } do_execsql_test 1.%TN%.4 { UPDATE t1 SET x=n FROM x1 WHERE x=o; SELECT x, y, z FROM t1 ORDER BY 1; } { 31 i one 32 ii two 33 iii three 34 iv four } do_execsql_test 1.%TN%.5 { INSERT INTO x1 VALUES(31, 32); INSERT INTO x1 VALUES(33, 34); UPDATE OR REPLACE t1 SET x=n FROM x1 WHERE x=o; SELECT x, y, z FROM t1 ORDER BY 1; } { 32 i one 34 iii three } do_execsql_test 1.%TN%.6 { INSERT INTO t1 VALUES(33, 'ii', 'two'); INSERT INTO t1 VALUES(35, 'iv', 'four'); } do_execsql_test 1.%TN%.7 { CREATE TABLE x2(o, n, zz); INSERT INTO x2 VALUES(32, 41, 'four'); INSERT INTO x2 VALUES(33, 42, 'three'); UPDATE OR IGNORE t1 SET x=n, z=zz FROM x2 WHERE x=o; SELECT x, y, z FROM t1 ORDER BY 1; } { 32 i one 33 ii two 34 iii three 35 iv four } do_execsql_test 1.%TN%.8 { UPDATE OR REPLACE t1 SET x=n, z=zz FROM x2 WHERE x=o; SELECT x, y, z FROM t1 ORDER BY 1; } { 41 i four 42 ii three } }] } do_execsql_test 2.1.1 { CREATE TABLE u1(a, b, c, PRIMARY KEY(b, c)) WITHOUT ROWID; INSERT INTO u1 VALUES(0, 0, 0); INSERT INTO u1 VALUES(1, 0, 1); INSERT INTO u1 VALUES(2, 1, 0); INSERT INTO u1 VALUES(3, 1, 1); } do_execsql_test 2.1.2 { CREATE TABLE map(f, t); INSERT INTO map VALUES(0, 10); INSERT INTO map VALUES(1, 11); UPDATE u1 SET c=t FROM map WHERE c=f; SELECT * FROM u1 ORDER BY a; } { 0 0 10 1 0 11 2 1 10 3 1 11 } do_execsql_test 2.1.3 { UPDATE u1 SET b=t FROM map WHERE b=f; SELECT * FROM u1 ORDER BY a; } { 0 10 10 1 10 11 2 11 10 3 11 11 } do_execsql_test 2.1.4 { CREATE TABLE map2(o1, o2, n1, n2); INSERT INTO map2 VALUES (10, 10, 50, 50), (10, 11, 50, 60), (11, 10, 60, 50), (11, 11, 60, 60); UPDATE u1 SET b=n1, c=n2 FROM map2 WHERE b=o1 AND c=o2; SELECT * FROM u1 ORDER BY a; } { 0 50 50 1 50 60 2 60 50 3 60 60 } #------------------------------------------------------------------------- foreach {tn wo} { 1 "" 2 "WITHOUT ROWID" } { reset_db forcedelete test.db2 eval [string map [list %WO% $wo %TN% $tn] { do_execsql_test 3.$tn.1 { CREATE TABLE g1(a, b, c, PRIMARY KEY(a, b)) %WO%; INSERT INTO g1 VALUES(1, 1, 1); ATTACH 'test.db2' AS aux; CREATE TABLE aux.g1(a, b, c, PRIMARY KEY(a, b)) %WO%; INSERT INTO aux.g1 VALUES(10, 1, 10); INSERT INTO aux.g1 VALUES(20, 2, 20); INSERT INTO aux.g1 VALUES(30, 3, 30); } do_execsql_test 3.$tn.2 { UPDATE aux.g1 SET c=101 FROM main.g1; } do_execsql_test 3.$tn.3 { SELECT * FROM aux.g1; } {10 1 101 20 2 101 30 3 101} do_execsql_test 3.$tn.4 { UPDATE g1 SET c=101 FROM g1 AS g2; } do_execsql_test 3.$tn.5 { SELECT * FROM g1; } {1 1 101} }] } #------------------------------------------------------------------------- reset_db foreach {tn wo} { 1 "" 2 "WITHOUT ROWID" } { reset_db forcedelete test.db2 eval [string map [list %WO% $wo %TN% $tn] { do_execsql_test 4.$tn.1 { CREATE TABLE p1(a INTEGER PRIMARY KEY, b) %WO%; CREATE TABLE c1(x PRIMARY KEY, y REFERENCES p1 ON UPDATE CASCADE) %WO%; PRAGMA foreign_keys = 1; INSERT INTO p1 VALUES(1, 'one'); INSERT INTO p1 VALUES(11, 'eleven'); INSERT INTO p1 VALUES(111, 'eleventyone'); INSERT INTO c1 VALUES('a', 1); INSERT INTO c1 VALUES('b', 11); INSERT INTO c1 VALUES('c', 111); } do_execsql_test 4.$tn.2 { CREATE TABLE map(f, t); INSERT INTO map VALUES('a', 111); INSERT INTO map VALUES('c', 112); } do_catchsql_test 4.$tn.3 { UPDATE c1 SET y=t FROM map WHERE x=f; } {1 {FOREIGN KEY constraint failed}} do_execsql_test 4.$tn.4 { INSERT INTO map VALUES('eleven', 12); INSERT INTO map VALUES('eleventyone', 112); UPDATE p1 SET a=t FROM map WHERE b=f; } do_execsql_test 4.$tn.5 { SELECT * FROM c1 } {a 1 b 12 c 112} }] } finish_test |
Added test/upfromfault.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | # 2020 April 29 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix upfromfault foreach {tn sql} { 1 { CREATE TABLE t1(x PRIMARY KEY, y, z UNIQUE); CREATE INDEX t1y ON t1(y); } 2 { CREATE TABLE t1(x PRIMARY KEY, y, z UNIQUE) WITHOUT ROWID; CREATE INDEX t1y ON t1(y); } 3 { CREATE TABLE t1(x, y, z UNIQUE, PRIMARY KEY(x,y)) WITHOUT ROWID; } 4 { CREATE VIRTUAL TABLE t1 USING fts5(x, y, z); } 5 { CREATE TABLE real(x, y, z); CREATE VIEW t1 AS SELECT * FROM real; CREATE TRIGGER t1_insert INSTEAD OF INSERT ON t1 BEGIN INSERT INTO real VALUES(new.x, new.y, new.z); END; CREATE TRIGGER t1_update INSTEAD OF UPDATE ON t1 BEGIN INSERT INTO log VALUES(old.z || '->' || new.z); UPDATE real SET y=new.y, z=new.z WHERE x=old.x; END; } } { if {$tn<5} continue reset_db ifcapable !fts5 { if {$tn==4} continue } execsql $sql do_execsql_test 1.$tn.0 { CREATE TABLE log(t TEXT); INSERT INTO t1 VALUES(1, 'i', 'one'); INSERT INTO t1 VALUES(2, 'ii', 'two'); INSERT INTO t1 VALUES(3, 'iii', 'three'); INSERT INTO t1 VALUES(4, 'iv', 'four'); } if {$tn!=4 && $tn!=5} { do_execsql_test 1.$tn.0b { CREATE TRIGGER tr1 BEFORE UPDATE ON t1 BEGIN INSERT INTO log VALUES(old.z || '->' || new.z); END; CREATE TRIGGER tr2 AFTER UPDATE ON t1 BEGIN INSERT INTO log VALUES(old.y || '->' || new.y); END; } } faultsim_save_and_close do_faultsim_test 1.$tn -prep { faultsim_restore_and_reopen execsql { SELECT * FROM t1 } } -body { execsql { WITH data(k, v) AS ( VALUES(3, 'thirty'), (1, 'ten') ) UPDATE t1 SET z=v FROM data WHERE x=k; } } -test { faultsim_test_result {0 {}} {1 {vtable constructor failed: t1}} if {$testrc==0} { set res [execsql { SELECT * FROM t1 }] if {$res!="1 i ten 2 ii two 3 iii thirty 4 iv four"} { error "unexpected result: $res" } } } } reset_db do_execsql_test 2.0 { CREATE TABLE t1(a, b, c); CREATE TABLE t2(x, y, z); } faultsim_save_and_close do_faultsim_test 2.1 -prep { faultsim_restore_and_reopen } -body { execsql { CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN UPDATE t2 SET x=a FROM t1 WHERE c=z; END; } } -test { faultsim_test_result {0 {}} } faultsim_restore_and_reopen do_execsql_test 2.2 { CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN UPDATE t1 SET a=x FROM t2 WHERE c=z; END; INSERT INTO t2 VALUES(1, 1, 1); INSERT INTO t2 VALUES(2, 2, 2); INSERT INTO t2 VALUES(3, 3, 3); } faultsim_save_and_close do_faultsim_test 2.3 -prep { faultsim_restore_and_reopen } -body { execsql { INSERT INTO t1 VALUES(NULL, NULL, 1), (NULL, NULL, 3); } } -test { faultsim_test_result {0 {}} if {$testrc==0} { set res [execsql { SELECT * FROM t1 }] if {$res!="1 {} 1 3 {} 3"} { error "unexpected result: $res" } } } finish_test |