Add UPDATE FROM compatible with postgresql.
FossilOrigin-Name: 88baf1eb0706503214012520be4d872594ccc5b4c9674c44cc07b67ade2bfcf2
This commit is contained in:
@@ -1,6 +1,6 @@
|
||||
B 7a876209a678a34c198b54ceef9e3c041f128a14dc73357f6a57cadadaa6cf7b
|
||||
C Relax\spointless\srestrictions\son\sallowing\stables\sin\sthe\sFROM\sclause\sfrom\ncrossing\sover\sLEFT\sJOINs,\sas\slong\sas\sthe\stable\sbeing\smoved\sis\snot\sthe\nright\stable\sof\sthe\sLEFT\sJOIN.
|
||||
D 2020-07-16T18:55:58.182
|
||||
C Add\sUPDATE\sFROM\scompatible\swith\spostgresql.
|
||||
D 2020-07-18T15:52:15.996
|
||||
F Makefile.in 19374a5db06c3199ec1bab71ab74a103d8abf21053c05e9389255dc58083f806
|
||||
F Makefile.msc 48f5a3fc32672c09ad73795749f6253e406a31526935fbbffd8f021108d54574
|
||||
F autoconf/Makefile.am a8d1d24affe52ebf8d7ddcf91aa973fa0316618ab95bb68c87cabf8faf527dc8
|
||||
@@ -15,36 +15,52 @@ F ext/lsm1/lsm_unix.c 11e0a5c19d754a4e1d93dfad06de8cc201f10f886b8e61a4c599ed34e3
|
||||
F ext/misc/decimal.c c1897f624893d1c12e3c879d97ca7d1c4a36cae10d32afe632779de78c4aaa4f
|
||||
F ext/misc/ieee754.c bb6bd8e9eeeda5a7ac82839fcab5c0b8156b0532165387cc5458a97f60047b5d
|
||||
F main.mk b1cd0bc6aedad7ebb667b7f74f835f932f60ee33be2a5c3051fd93eb465f5c75
|
||||
F src/alter.c c63fb72ae0ca39175996fcf7008d44022a7ea99e03c0af3e1d968505ceff7120
|
||||
F src/attach.c 0b11e00c166b622c84ec176773b1d691c61ad07d247809e3e1635d4e99e71d30
|
||||
F src/btree.c b8b0e80c8bbe4e1fb35ae559e9e9aa009799c20cf12f159ebb503b05be1fab9b
|
||||
F src/btreeInt.h 19267385aa3bc00067d48e0e4ba83ae82dc08b0c15a3b3df20ea653cb462b5bf
|
||||
F src/build.c ba1bbe563a3dc02d5fed20537603181e5289c13ea30ae5e775f552e7557adbfa
|
||||
F src/build.c 45d912640987426442eb9eeec695c4dd45dd440b4cd27e8c13a42eed2fa87dcd
|
||||
F src/delete.c 410c771c25afc113c273d9efad6ab6881bda28c75a1838b9d2c52ba20d1dc704
|
||||
F src/expr.c 90039a043658ce78c3237ba5064c0934b7294120f6adc387f8d0fba306028154
|
||||
F src/malloc.c 22d5bdd9fe88ae4fad1b91a1b9735104b82853ffef868f1f05517d60dc1875f5
|
||||
F src/parse.y b6b4b02f8cc8f94ac1d93a922543e0344dbb30b04877898736c01ec7ec03eaaa
|
||||
F src/mem2.c b93b8762ab999a29ae7751532dadf0a1ac78040308a5fb1d17fcc365171d67eb
|
||||
F src/parse.y ecb9abdd79ec86c8dca7cb126bbdcf322c0e282f87a6d0d734ea5f2c57ced516
|
||||
F src/pragma.c ae499b5ab8f4e833f67e28bf2322500e9aa612aadf12581d1324333f848d8b51
|
||||
F src/pragma.h 8dc78ab7e9ec6ce3ded8332810a2066f1ef6267e2e03cd7356ee00276125c6cf
|
||||
F src/resolve.c 79cee37182fea66703f90365b8b0a646ed7e9bfa9238b91fa90dfc74258b940e
|
||||
F src/select.c 5293c60dd32c87a599b16e6f4acaf2827b7f60fca317b614a7cfccfb0beecba9
|
||||
F src/resolve.c 2dd6821aac2cd27de9fcf6aa6d1f8c41b4b5841c9bc58bf1c9109008009a3a2e
|
||||
F src/select.c ee84981a346ddddf5669db441a68fac763f4266fe83a9cb27e43c67fbcf1b215
|
||||
F src/shell.c.in 81fa23ac1a3d6ac9ed13e9ae711a3d8806396ca7cc12c5d6a2e2536f70b0c7ad
|
||||
F src/sqliteInt.h 8366e482a1330e9c103c9c9053c53894e373daf1fb9dd65bd953ffc0b3ad7a8b
|
||||
F src/sqliteInt.h 9682c3ce6b970b3a997d65c140bdb5b286a04188e4e1c8489b64a525161ecb30
|
||||
F src/test1.c fe56c4bcaa2685ca9aa25d817a0ee9345e189aff4a5a71a3d8ba946c7776feb8
|
||||
F src/update.c 6a0484134635f167594d597a33d186051125d3ef41803a90b246cea6cf7f11f9
|
||||
F src/test_malloc.c 21121ea85b49ec0bdb69995847cef9036ef9beca3ce63bbb776e4ea2ecc44b97
|
||||
F src/trigger.c ef67bde309a831515dc3c2173d792574309f2f42d45f8c078743fae9f7f98c75
|
||||
F src/update.c e917882ce2a8529ab361500b62ff6d3f0839b946f696d2ec3b048774ff11e37f
|
||||
F src/util.c c0bacc165f46169d2b720c37c8719165e383211698fad1de39dd16a8c161815a
|
||||
F src/vdbe.c 981666c49d33039df6dc9fccd40191575586ac4866255b2f57819cc5eb99f572
|
||||
F src/vdbeapi.c c1a9004ac554d8d48794d2ce5f80397f8e419fd28643a543cc1e004c7713c3ef
|
||||
F src/where.c 2ea911238674e9baaeddf105dddabed92692a01996073c4d4983f9a7efe481f9
|
||||
F src/window.c 0dec178bfa541c757d15a2be78f34aea36393a0966600366810e5f8739ccf370
|
||||
F test/altertab.test b8b2104212e8ea87c75c3cbe3cb78ed7236a6c828ee2e59ed09d3dbe9812d002
|
||||
F test/altertab3.test d0d51e652aaa11e37de1f1215181d88334fefcb185f3b9bd91e06e98260c4694
|
||||
F test/busy2.test 415364312743992641f9bf679c84918327296067f85a5d00012b339dc35acbd7
|
||||
F test/corruptL.test 01cfda6b28f463d1713ac72a101e65549250568129ce5317ec6729729ecaf477
|
||||
F test/decimal.test fcf403fd5585f47342234e153c4a4338cd737b8e0884ac66fc484df47dbcf1a7
|
||||
F test/filter1.test 6c483ecf7886c8843a8612c021aa23f33c581f584151f251842b3a3592c95ac8
|
||||
F test/fkey5.test 321fd41e8754389526b2b8e8769348dc9ff23a65d4d48b19c27df17459e82ec5
|
||||
F test/fts3corrupt4.test b77dcdfa207c11d7966e71837c518cb0639c78fd109dec89c65d45a3bfd36701
|
||||
F test/fts4upfrom.test 8df5acb6e10ad73f393d1add082b042ab1db72567888847d098152121e507b34
|
||||
F test/fuzzdata8.db 281cbc8166a8bc5843f4a913e803ba76e27905eb02fb9d5cfd581c2429f29855
|
||||
F test/gencol1.test b05e6c5edb9b10d48efb634ed07342441bddc89d225043e17095c36e567521a0
|
||||
F test/ieee754.test b0945d12be7d255f3dfa18e2511b17ca37e0edd2b803231c52d05b86c04ab26e
|
||||
F test/pg_common.tcl 3b27542224db1e713ae387459b5d117c836a5f6e328846922993b6d2b7640d9f
|
||||
F test/speedtest1.c a8b5afe72d78ff365012aba48d3f0c579e957facb7630f765f58a6ae4656d20d
|
||||
F test/tester.tcl 174f668fcb4569a775bf24534ac8e59ce47d3a56d37c3465d1857f027e7ec136
|
||||
F test/triggerupfrom.test d25961fa70a99b6736193da7b49a36d8c1d28d56188f0be6406d4366315cd6e4
|
||||
F test/upfrom1.tcl 8859d9d437f03b44174c4524a7a734a391fd4526fcff65be08285dafc9dc9041
|
||||
F test/upfrom1.test c0a99a3f44b42beaca37c62e05332d64768c326c75b4edf976533a2d1ef76895
|
||||
F test/upfrom2.test 6ebd3be8c3fac984e89a177d823686f04605b512fc167392bce6d8ba2ba63325
|
||||
F test/upfrom3.test 7dab379d128e8dd7beb2055b295fb113c7ba93e8c2038f5ddb7a4a10f0ebb348
|
||||
F test/upfromfault.test 70ecf8eb85559727a487283f69374e3ae39879e994d8a2437c49d7c05ecb70c9
|
||||
F test/window1.test e52b81fff0c3cb122a1240f336688eb81bea2967a99c4ddb78969adec7aadc2a
|
||||
F tool/lemon.c 600a58b9d1b8ec5419373982428e927ca208826edacb91ca42ab94514d006039
|
||||
F tool/mkautoconfamal.sh f62353eb6c06ab264da027fd4507d09914433dbdcab9cb011cdc18016f1ab3b8
|
||||
@@ -53,7 +69,8 @@ F tool/mksqlite3c.tcl f4ef476510eca4124c874a72029f1e01bc54a896b1724e8f9eef0d8bfa
|
||||
F tool/mksqlite3h.tcl 1f5e4a1dbbbc43c83cc6e74fe32c6c620502240b66c7c0f33a51378e78fc4edf
|
||||
F tool/showlocks.c 9cc5e66d4ebbf2d194f39db2527ece92077e86ae627ddd233ee48e16e8142564
|
||||
F tool/speed-check.sh 615cbdf50f1409ef3bbf9f682e396df80f49d97ed93ed3e61c8e91fae6afde58
|
||||
P 35cd87063d1933b87bc2176f957ecd758d7d167e9473fa615e33caec3be14783
|
||||
R 746d9475007e84ed494c6df8218f252e
|
||||
P c1ea064948ba08c4be209ad6efc2126a7367bcb06266ea35eb957bf2d4e2cb9f 270e17bba1d35f8c300844e75b2aa15f79a1ab62e40bc5e6bc9694902f8f7dde
|
||||
R 1546768fbbda9cf26d0f2836127121bd
|
||||
T +closed 270e17bba1d35f8c300844e75b2aa15f79a1ab62e40bc5e6bc9694902f8f7dde
|
||||
U drh
|
||||
Z e8621449358c788389d3aef6e8aa26e8
|
||||
Z 8bd06bc7fc2942f7b1a3d5039b41b801
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
c1ea064948ba08c4be209ad6efc2126a7367bcb06266ea35eb957bf2d4e2cb9f
|
||||
88baf1eb0706503214012520be4d872594ccc5b4c9674c44cc07b67ade2bfcf2
|
||||
+20
-12
@@ -1191,17 +1191,22 @@ static int renameResolveTrigger(Parse *pParse, const char *zDb){
|
||||
if( pParse->nErr ) rc = pParse->rc;
|
||||
}
|
||||
if( rc==SQLITE_OK && pStep->zTarget ){
|
||||
Table *pTarget = sqlite3LocateTable(pParse, 0, pStep->zTarget, zDb);
|
||||
if( pTarget==0 ){
|
||||
rc = SQLITE_ERROR;
|
||||
}else if( SQLITE_OK==(rc = sqlite3ViewGetColumnNames(pParse, pTarget)) ){
|
||||
SrcList sSrc;
|
||||
memset(&sSrc, 0, sizeof(sSrc));
|
||||
sSrc.nSrc = 1;
|
||||
sSrc.a[0].zName = pStep->zTarget;
|
||||
sSrc.a[0].pTab = pTarget;
|
||||
sNC.pSrcList = &sSrc;
|
||||
if( pStep->pWhere ){
|
||||
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 ){
|
||||
@@ -1211,7 +1216,7 @@ static int renameResolveTrigger(Parse *pParse, const char *zDb){
|
||||
if( pStep->pUpsert ){
|
||||
Upsert *pUpsert = pStep->pUpsert;
|
||||
assert( rc==SQLITE_OK );
|
||||
pUpsert->pUpsertSrc = &sSrc;
|
||||
pUpsert->pUpsertSrc = pSrc;
|
||||
sNC.uNC.pUpsert = pUpsert;
|
||||
sNC.ncFlags = NC_UUpsert;
|
||||
rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
|
||||
@@ -1228,6 +1233,9 @@ static int renameResolveTrigger(Parse *pParse, const char *zDb){
|
||||
sNC.ncFlags = 0;
|
||||
}
|
||||
sNC.pSrcList = 0;
|
||||
sqlite3SrcListDelete(db, pSrc);
|
||||
}else{
|
||||
rc = SQLITE_NOMEM;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -599,6 +599,9 @@ int sqlite3FixTriggerStep(
|
||||
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;
|
||||
|
||||
+20
@@ -4569,6 +4569,26 @@ void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** 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.
|
||||
|
||||
+1
-1
@@ -31,7 +31,7 @@
|
||||
Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
|
||||
struct SrcList_item *pItem = pSrc->a;
|
||||
Table *pTab;
|
||||
assert( pItem && pSrc->nSrc==1 );
|
||||
assert( pItem && pSrc->nSrc>=1 );
|
||||
pTab = sqlite3LocateTableItem(pParse, 0, pItem);
|
||||
sqlite3DeleteTable(pParse->db, pItem->pTab);
|
||||
pItem->pTab = pTab;
|
||||
|
||||
+3
-3
@@ -379,7 +379,7 @@ void sqlite3MemSetDefault(void){
|
||||
** Set the "type" of an allocation.
|
||||
*/
|
||||
void sqlite3MemdebugSetType(void *p, u8 eType){
|
||||
if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
|
||||
if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){
|
||||
struct MemBlockHdr *pHdr;
|
||||
pHdr = sqlite3MemsysGetHeader(p);
|
||||
assert( pHdr->iForeGuard==FOREGUARD );
|
||||
@@ -398,7 +398,7 @@ void sqlite3MemdebugSetType(void *p, u8 eType){
|
||||
*/
|
||||
int sqlite3MemdebugHasType(void *p, u8 eType){
|
||||
int rc = 1;
|
||||
if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
|
||||
if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){
|
||||
struct MemBlockHdr *pHdr;
|
||||
pHdr = sqlite3MemsysGetHeader(p);
|
||||
assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
|
||||
@@ -420,7 +420,7 @@ int sqlite3MemdebugHasType(void *p, u8 eType){
|
||||
*/
|
||||
int sqlite3MemdebugNoType(void *p, u8 eType){
|
||||
int rc = 1;
|
||||
if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
|
||||
if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){
|
||||
struct MemBlockHdr *pHdr;
|
||||
pHdr = sqlite3MemsysGetHeader(p);
|
||||
assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
|
||||
|
||||
+7
-5
@@ -658,7 +658,7 @@ as(X) ::= . {X.n = 0; X.z = 0;}
|
||||
|
||||
// A complete FROM clause.
|
||||
//
|
||||
from(A) ::= . {A = sqlite3DbMallocZero(pParse->db, sizeof(*A));}
|
||||
from(A) ::= . {A = 0;}
|
||||
from(A) ::= FROM seltablist(X). {
|
||||
A = X;
|
||||
sqlite3SrcListShiftJoinType(A);
|
||||
@@ -890,9 +890,10 @@ 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)
|
||||
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 ){
|
||||
@@ -904,10 +905,11 @@ cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y)
|
||||
sqlite3Update(pParse,X,Y,W,R,O,L,0);
|
||||
}
|
||||
%else
|
||||
cmd ::= with UPDATE orconf(R) xfullname(X) indexed_opt(I) SET setlist(Y)
|
||||
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
|
||||
@@ -1515,8 +1517,8 @@ tridxby ::= NOT INDEXED. {
|
||||
%destructor trigger_cmd {sqlite3DeleteTriggerStep(pParse->db, $$);}
|
||||
// UPDATE
|
||||
trigger_cmd(A) ::=
|
||||
UPDATE(B) orconf(R) trnm(X) tridxby SET setlist(Y) where_opt(Z) scanpt(E).
|
||||
{A = sqlite3TriggerUpdateStep(pParse, &X, Y, Z, R, B.z, E);}
|
||||
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
|
||||
|
||||
+4
-7
@@ -756,26 +756,23 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
|
||||
#endif
|
||||
switch( pExpr->op ){
|
||||
|
||||
#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
|
||||
/* 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.
|
||||
** 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 );
|
||||
assert( pSrcList && pSrcList->nSrc>=1 );
|
||||
pItem = pSrcList->a;
|
||||
assert( HasRowid(pItem->pTab) && pItem->pTab->pSelect==0 );
|
||||
pExpr->op = TK_COLUMN;
|
||||
pExpr->y.pTab = pItem->pTab;
|
||||
pExpr->iTable = pItem->iCursor;
|
||||
pExpr->iColumn = -1;
|
||||
pExpr->iColumn--;
|
||||
pExpr->affExpr = SQLITE_AFF_INTEGER;
|
||||
break;
|
||||
}
|
||||
#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
|
||||
&& !defined(SQLITE_OMIT_SUBQUERY) */
|
||||
|
||||
/* A column name: ID
|
||||
** Or table name and column name: ID.ID
|
||||
|
||||
+57
-3
@@ -103,6 +103,7 @@ static void clearSelect(sqlite3 *db, Select *p, int bFree){
|
||||
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;
|
||||
@@ -975,7 +976,8 @@ static void selectInnerLoop(
|
||||
testcase( eDest==SRT_Coroutine );
|
||||
testcase( eDest==SRT_Output );
|
||||
assert( eDest==SRT_Set || eDest==SRT_Mem
|
||||
|| eDest==SRT_Coroutine || eDest==SRT_Output );
|
||||
|| eDest==SRT_Coroutine || eDest==SRT_Output
|
||||
|| eDest==SRT_Upfrom );
|
||||
}
|
||||
sRowLoadInfo.regResult = regResult;
|
||||
sRowLoadInfo.ecelFlags = ecelFlags;
|
||||
@@ -1124,6 +1126,26 @@ static void selectInnerLoop(
|
||||
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
|
||||
@@ -1148,6 +1170,7 @@ static void selectInnerLoop(
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* If any row exist in the result set, record that fact and abort.
|
||||
*/
|
||||
case SRT_Exists: {
|
||||
@@ -1554,6 +1577,19 @@ static void generateSortTail(
|
||||
/* 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 );
|
||||
@@ -4969,8 +5005,8 @@ static int selectExpander(Walker *pWalker, Select *p){
|
||||
for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
|
||||
Table *pTab;
|
||||
assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
|
||||
if( pFrom->fg.isRecursive ) continue;
|
||||
assert( 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
|
||||
@@ -5792,6 +5828,24 @@ int sqlite3Select(
|
||||
}
|
||||
#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);
|
||||
}
|
||||
|
||||
+18
-3
@@ -3126,6 +3126,7 @@ struct Select {
|
||||
#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
|
||||
@@ -3190,6 +3191,14 @@ struct Select {
|
||||
** 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 */
|
||||
@@ -3209,14 +3218,16 @@ struct Select {
|
||||
#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. On of SRT_* above. */
|
||||
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 */
|
||||
@@ -3562,6 +3573,7 @@ struct TriggerStep {
|
||||
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 */
|
||||
@@ -4230,6 +4242,7 @@ 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*);
|
||||
@@ -4399,13 +4412,14 @@ void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int);
|
||||
TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*,
|
||||
Select*,u8,Upsert*,
|
||||
const char*,const char*);
|
||||
TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,ExprList*, Expr*, u8,
|
||||
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
|
||||
@@ -4419,6 +4433,7 @@ void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int);
|
||||
# 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*);
|
||||
|
||||
+3
-36
@@ -112,32 +112,6 @@ static void *faultsimRealloc(void *pOld, int n){
|
||||
return p;
|
||||
}
|
||||
|
||||
/*
|
||||
** The following method calls are passed directly through to the underlying
|
||||
** malloc system:
|
||||
**
|
||||
** xFree
|
||||
** xSize
|
||||
** xRoundup
|
||||
** xInit
|
||||
** xShutdown
|
||||
*/
|
||||
static void faultsimFree(void *p){
|
||||
memfault.m.xFree(p);
|
||||
}
|
||||
static int faultsimSize(void *p){
|
||||
return memfault.m.xSize(p);
|
||||
}
|
||||
static int faultsimRoundup(int n){
|
||||
return memfault.m.xRoundup(n);
|
||||
}
|
||||
static int faultsimInit(void *p){
|
||||
return memfault.m.xInit(memfault.m.pAppData);
|
||||
}
|
||||
static void faultsimShutdown(void *p){
|
||||
memfault.m.xShutdown(memfault.m.pAppData);
|
||||
}
|
||||
|
||||
/*
|
||||
** This routine configures the malloc failure simulation. After
|
||||
** calling this routine, the next nDelay mallocs will succeed, followed
|
||||
@@ -204,16 +178,6 @@ static void faultsimEndBenign(void){
|
||||
** the argument is non-zero, the
|
||||
*/
|
||||
static int faultsimInstall(int install){
|
||||
static struct sqlite3_mem_methods m = {
|
||||
faultsimMalloc, /* xMalloc */
|
||||
faultsimFree, /* xFree */
|
||||
faultsimRealloc, /* xRealloc */
|
||||
faultsimSize, /* xSize */
|
||||
faultsimRoundup, /* xRoundup */
|
||||
faultsimInit, /* xInit */
|
||||
faultsimShutdown, /* xShutdown */
|
||||
0 /* pAppData */
|
||||
};
|
||||
int rc;
|
||||
|
||||
install = (install ? 1 : 0);
|
||||
@@ -227,6 +191,9 @@ static int faultsimInstall(int 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,
|
||||
|
||||
+24
-15
@@ -26,6 +26,7 @@ void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
|
||||
sqlite3SelectDelete(db, pTmp->pSelect);
|
||||
sqlite3IdListDelete(db, pTmp->pIdList);
|
||||
sqlite3UpsertDelete(db, pTmp->pUpsert);
|
||||
sqlite3SrcListDelete(db, pTmp->pFrom);
|
||||
sqlite3DbFree(db, pTmp->zSpan);
|
||||
|
||||
sqlite3DbFree(db, pTmp);
|
||||
@@ -486,6 +487,7 @@ TriggerStep *sqlite3TriggerInsertStep(
|
||||
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) */
|
||||
@@ -500,16 +502,20 @@ TriggerStep *sqlite3TriggerUpdateStep(
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -736,25 +742,28 @@ Trigger *sqlite3TriggersExist(
|
||||
** trigger is in TEMP in which case it can refer to any other database it
|
||||
** wants.
|
||||
*/
|
||||
static SrcList *targetSrcList(
|
||||
SrcList *sqlite3TriggerStepSrc(
|
||||
Parse *pParse, /* The parsing context */
|
||||
TriggerStep *pStep /* The trigger containing the target token */
|
||||
){
|
||||
sqlite3 *db = pParse->db;
|
||||
int iDb; /* Index of the database to use */
|
||||
SrcList *pSrc; /* SrcList to be returned */
|
||||
|
||||
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 ){
|
||||
assert( pSrc->nSrc>0 );
|
||||
pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
|
||||
iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);
|
||||
if( iDb==0 || iDb>=2 ){
|
||||
const char *zDb;
|
||||
assert( iDb<db->nDb );
|
||||
zDb = db->aDb[iDb].zDbSName;
|
||||
pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, zDb);
|
||||
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;
|
||||
}
|
||||
@@ -803,7 +812,7 @@ static int codeTriggerProgram(
|
||||
switch( pStep->op ){
|
||||
case TK_UPDATE: {
|
||||
sqlite3Update(pParse,
|
||||
targetSrcList(pParse, pStep),
|
||||
sqlite3TriggerStepSrc(pParse, pStep),
|
||||
sqlite3ExprListDup(db, pStep->pExprList, 0),
|
||||
sqlite3ExprDup(db, pStep->pWhere, 0),
|
||||
pParse->eOrconf, 0, 0, 0
|
||||
@@ -812,7 +821,7 @@ static int codeTriggerProgram(
|
||||
}
|
||||
case TK_INSERT: {
|
||||
sqlite3Insert(pParse,
|
||||
targetSrcList(pParse, pStep),
|
||||
sqlite3TriggerStepSrc(pParse, pStep),
|
||||
sqlite3SelectDup(db, pStep->pSelect, 0),
|
||||
sqlite3IdListDup(db, pStep->pIdList),
|
||||
pParse->eOrconf,
|
||||
@@ -822,7 +831,7 @@ static int codeTriggerProgram(
|
||||
}
|
||||
case TK_DELETE: {
|
||||
sqlite3DeleteFrom(pParse,
|
||||
targetSrcList(pParse, pStep),
|
||||
sqlite3TriggerStepSrc(pParse, pStep),
|
||||
sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0
|
||||
);
|
||||
break;
|
||||
|
||||
+408
-180
@@ -130,12 +130,146 @@ static int indexWhereClauseMightChange(
|
||||
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 table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
|
||||
** \_______/ \________/ \______/ \________________/
|
||||
* onError pTabList pChanges pWhere
|
||||
** 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 */
|
||||
@@ -169,6 +303,7 @@ void sqlite3Update(
|
||||
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 */
|
||||
@@ -192,6 +327,7 @@ void sqlite3Update(
|
||||
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 */
|
||||
@@ -207,7 +343,6 @@ void sqlite3Update(
|
||||
if( pParse->nErr || db->mallocFailed ){
|
||||
goto update_cleanup;
|
||||
}
|
||||
assert( pTabList->nSrc==1 );
|
||||
|
||||
/* Locate the table which we want to update.
|
||||
*/
|
||||
@@ -232,8 +367,15 @@ void sqlite3Update(
|
||||
# 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 ){
|
||||
if( !isView && nChangeFrom==0 ){
|
||||
pWhere = sqlite3LimitWhere(
|
||||
pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE"
|
||||
);
|
||||
@@ -302,7 +444,9 @@ void sqlite3Update(
|
||||
*/
|
||||
chngRowid = chngPk = 0;
|
||||
for(i=0; i<pChanges->nExpr; i++){
|
||||
if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
|
||||
/* 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++){
|
||||
@@ -310,6 +454,7 @@ void sqlite3Update(
|
||||
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;
|
||||
}
|
||||
@@ -332,6 +477,7 @@ void sqlite3Update(
|
||||
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;
|
||||
@@ -461,7 +607,7 @@ void sqlite3Update(
|
||||
** an ephemeral table.
|
||||
*/
|
||||
#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
|
||||
if( isView ){
|
||||
if( nChangeFrom==0 && isView ){
|
||||
sqlite3MaterializeView(pParse, pTab,
|
||||
pWhere, pOrderBy, pLimit, iDataCur
|
||||
);
|
||||
@@ -473,7 +619,7 @@ void sqlite3Update(
|
||||
/* Resolve the column names in all the expressions in the
|
||||
** WHERE clause.
|
||||
*/
|
||||
if( sqlite3ResolveExprNames(&sNC, pWhere) ){
|
||||
if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){
|
||||
goto update_cleanup;
|
||||
}
|
||||
|
||||
@@ -500,105 +646,128 @@ void sqlite3Update(
|
||||
sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
|
||||
}
|
||||
|
||||
if( HasRowid(pTab) ){
|
||||
if( nChangeFrom==0 && HasRowid(pTab) ){
|
||||
sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
|
||||
}else{
|
||||
assert( pPk!=0 );
|
||||
nPk = pPk->nKeyCol;
|
||||
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++;
|
||||
sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
|
||||
addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk);
|
||||
sqlite3VdbeSetP4KeyInfo(pParse, pPk);
|
||||
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( 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;
|
||||
if( nChangeFrom ){
|
||||
sqlite3MultiWrite(pParse);
|
||||
eOnePass = ONEPASS_OFF;
|
||||
nKey = nPk;
|
||||
regKey = iPk;
|
||||
}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;
|
||||
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) );
|
||||
}
|
||||
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( 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( eOnePass!=ONEPASS_MULTI ){
|
||||
if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){
|
||||
sqlite3WhereEnd(pWInfo);
|
||||
}
|
||||
|
||||
@@ -634,12 +803,31 @@ void sqlite3Update(
|
||||
sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
|
||||
VdbeCoverageIf(v, pPk==0);
|
||||
VdbeCoverageIf(v, pPk!=0);
|
||||
}else if( pPk ){
|
||||
}else if( pPk || nChangeFrom ){
|
||||
labelContinue = sqlite3VdbeMakeLabel(pParse);
|
||||
sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
|
||||
addrTop = sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
|
||||
sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0);
|
||||
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);
|
||||
@@ -655,7 +843,12 @@ void sqlite3Update(
|
||||
** already populated. */
|
||||
assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
|
||||
if( chngRowid ){
|
||||
sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
|
||||
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);
|
||||
}
|
||||
|
||||
@@ -708,7 +901,13 @@ void sqlite3Update(
|
||||
}else{
|
||||
j = aXRef[i];
|
||||
if( j>=0 ){
|
||||
sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
|
||||
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
|
||||
@@ -740,43 +939,45 @@ void sqlite3Update(
|
||||
sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
|
||||
TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
|
||||
|
||||
/* 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);
|
||||
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);
|
||||
}
|
||||
if( pTab->tabFlags & TF_HasGenerated ){
|
||||
testcase( pTab->tabFlags & TF_HasVirtual );
|
||||
testcase( pTab->tabFlags & TF_HasStored );
|
||||
sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
if( !isView ){
|
||||
@@ -879,7 +1080,7 @@ void sqlite3Update(
|
||||
}else if( eOnePass==ONEPASS_MULTI ){
|
||||
sqlite3VdbeResolveLabel(v, labelContinue);
|
||||
sqlite3WhereEnd(pWInfo);
|
||||
}else if( pPk ){
|
||||
}else if( pPk || nChangeFrom ){
|
||||
sqlite3VdbeResolveLabel(v, labelContinue);
|
||||
sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
|
||||
}else{
|
||||
@@ -982,69 +1183,96 @@ static void updateVirtualTable(
|
||||
addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
|
||||
regArg = pParse->nMem + 1;
|
||||
pParse->nMem += nArg;
|
||||
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);/* Enable sqlite3_vtab_nochange() */
|
||||
}
|
||||
}
|
||||
if( HasRowid(pTab) ){
|
||||
sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
|
||||
if( pSrc->nSrc>1 ){
|
||||
Expr *pRow;
|
||||
ExprList *pList;
|
||||
if( pRowid ){
|
||||
sqlite3ExprCode(pParse, pRowid, regArg+1);
|
||||
pRow = sqlite3ExprDup(db, pRowid, 0);
|
||||
}else{
|
||||
sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
|
||||
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{
|
||||
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);
|
||||
}
|
||||
regRec = ++pParse->nMem;
|
||||
regRowid = ++pParse->nMem;
|
||||
|
||||
eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy);
|
||||
/* Start scanning the virtual table */
|
||||
pWInfo = sqlite3WhereBegin(pParse, pSrc,pWhere,0,0,WHERE_ONEPASS_DESIRED,0);
|
||||
if( pWInfo==0 ) return;
|
||||
|
||||
/* There is no ONEPASS_MULTI on virtual tables */
|
||||
assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
|
||||
/* 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);
|
||||
}
|
||||
|
||||
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);
|
||||
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);
|
||||
/* 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);
|
||||
sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
|
||||
sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if( eOnePass==ONEPASS_OFF ){
|
||||
/* End the virtual table scan */
|
||||
sqlite3WhereEnd(pWInfo);
|
||||
if( pSrc->nSrc==1 ){
|
||||
sqlite3WhereEnd(pWInfo);
|
||||
}
|
||||
|
||||
/* Begin scannning through the ephemeral table. */
|
||||
addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
|
||||
|
||||
@@ -586,5 +586,19 @@ do_execsql_test 24.4 {
|
||||
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
|
||||
|
||||
|
||||
@@ -0,0 +1,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
|
||||
|
||||
@@ -18,6 +18,8 @@ sqlite3 sqlite ""
|
||||
|
||||
proc execsql {sql} {
|
||||
|
||||
set sql [string map {{WITHOUT ROWID} {}} $sql]
|
||||
|
||||
set lSql [list]
|
||||
set frag ""
|
||||
while {[string length $sql]>0} {
|
||||
|
||||
@@ -129,6 +129,7 @@ if {[info command sqlite_orig]==""} {
|
||||
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
|
||||
|
||||
@@ -0,0 +1,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
|
||||
|
||||
@@ -0,0 +1,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
|
||||
|
||||
@@ -0,0 +1,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
|
||||
@@ -0,0 +1,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
|
||||
|
||||
|
||||
@@ -0,0 +1,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
|
||||
|
||||
@@ -0,0 +1,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
|
||||
|
||||
Reference in New Issue
Block a user