1 /*
2 ** 2003 April 6
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** This file contains code used to implement the ATTACH and DETACH commands.
13 */
14 #include "sqliteInt.h"
15
16 #ifndef SQLITE_OMIT_ATTACH
17 /*
18 ** Resolve an expression that was part of an ATTACH or DETACH statement. This
19 ** is slightly different from resolving a normal SQL expression, because simple
20 ** identifiers are treated as strings, not possible column names or aliases.
21 **
22 ** i.e. if the parser sees:
23 **
24 ** ATTACH DATABASE abc AS def
25 **
26 ** it treats the two expressions as literal strings 'abc' and 'def' instead of
27 ** looking for columns of the same name.
28 **
29 ** This only applies to the root node of pExpr, so the statement:
30 **
31 ** ATTACH DATABASE abc||def AS 'db2'
32 **
33 ** will fail because neither abc or def can be resolved.
34 */
resolveAttachExpr(NameContext * pName,Expr * pExpr)35 static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
36 {
37 int rc = SQLITE_OK;
38 if( pExpr ){
39 if( pExpr->op!=TK_ID ){
40 rc = sqlite3ResolveExprNames(pName, pExpr);
41 }else{
42 pExpr->op = TK_STRING;
43 }
44 }
45 return rc;
46 }
47
48 /*
49 ** An SQL user-function registered to do the work of an ATTACH statement. The
50 ** three arguments to the function come directly from an attach statement:
51 **
52 ** ATTACH DATABASE x AS y KEY z
53 **
54 ** SELECT sqlite_attach(x, y, z)
55 **
56 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
57 ** third argument.
58 **
59 ** If the db->init.reopenMemdb flags is set, then instead of attaching a
60 ** new database, close the database on db->init.iDb and reopen it as an
61 ** empty MemDB.
62 */
attachFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** argv)63 static void attachFunc(
64 sqlite3_context *context,
65 int NotUsed,
66 sqlite3_value **argv
67 ){
68 int i;
69 int rc = 0;
70 sqlite3 *db = sqlite3_context_db_handle(context);
71 const char *zName;
72 const char *zFile;
73 char *zPath = 0;
74 char *zErr = 0;
75 unsigned int flags;
76 Db *aNew; /* New array of Db pointers */
77 Db *pNew; /* Db object for the newly attached database */
78 char *zErrDyn = 0;
79 sqlite3_vfs *pVfs;
80
81 UNUSED_PARAMETER(NotUsed);
82 zFile = (const char *)sqlite3_value_text(argv[0]);
83 zName = (const char *)sqlite3_value_text(argv[1]);
84 if( zFile==0 ) zFile = "";
85 if( zName==0 ) zName = "";
86
87 #ifdef SQLITE_ENABLE_DESERIALIZE
88 # define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb)
89 #else
90 # define REOPEN_AS_MEMDB(db) (0)
91 #endif
92
93 if( REOPEN_AS_MEMDB(db) ){
94 /* This is not a real ATTACH. Instead, this routine is being called
95 ** from sqlite3_deserialize() to close database db->init.iDb and
96 ** reopen it as a MemDB */
97 pVfs = sqlite3_vfs_find("memdb");
98 if( pVfs==0 ) return;
99 pNew = &db->aDb[db->init.iDb];
100 if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
101 pNew->pBt = 0;
102 pNew->pSchema = 0;
103 rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
104 }else{
105 /* This is a real ATTACH
106 **
107 ** Check for the following errors:
108 **
109 ** * Too many attached databases,
110 ** * Transaction currently open
111 ** * Specified database name already being used.
112 */
113 if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
114 zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
115 db->aLimit[SQLITE_LIMIT_ATTACHED]
116 );
117 goto attach_error;
118 }
119 for(i=0; i<db->nDb; i++){
120 char *z = db->aDb[i].zDbSName;
121 assert( z && zName );
122 if( sqlite3StrICmp(z, zName)==0 ){
123 zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
124 goto attach_error;
125 }
126 }
127
128 /* Allocate the new entry in the db->aDb[] array and initialize the schema
129 ** hash tables.
130 */
131 if( db->aDb==db->aDbStatic ){
132 aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
133 if( aNew==0 ) return;
134 memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
135 }else{
136 aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
137 if( aNew==0 ) return;
138 }
139 db->aDb = aNew;
140 pNew = &db->aDb[db->nDb];
141 memset(pNew, 0, sizeof(*pNew));
142
143 /* Open the database file. If the btree is successfully opened, use
144 ** it to obtain the database schema. At this point the schema may
145 ** or may not be initialized.
146 */
147 flags = db->openFlags;
148 rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
149 if( rc!=SQLITE_OK ){
150 if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
151 sqlite3_result_error(context, zErr, -1);
152 sqlite3_free(zErr);
153 return;
154 }
155 assert( pVfs );
156 flags |= SQLITE_OPEN_MAIN_DB;
157 rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
158 db->nDb++;
159 pNew->zDbSName = sqlite3DbStrDup(db, zName);
160 }
161 db->noSharedCache = 0;
162 if( rc==SQLITE_CONSTRAINT ){
163 rc = SQLITE_ERROR;
164 zErrDyn = sqlite3MPrintf(db, "database is already attached");
165 }else if( rc==SQLITE_OK ){
166 Pager *pPager;
167 pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt);
168 if( !pNew->pSchema ){
169 rc = SQLITE_NOMEM_BKPT;
170 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
171 zErrDyn = sqlite3MPrintf(db,
172 "attached databases must use the same text encoding as main database");
173 rc = SQLITE_ERROR;
174 }
175 sqlite3BtreeEnter(pNew->pBt);
176 pPager = sqlite3BtreePager(pNew->pBt);
177 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
178 sqlite3BtreeSecureDelete(pNew->pBt,
179 sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
180 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
181 sqlite3BtreeSetPagerFlags(pNew->pBt,
182 PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
183 #endif
184 sqlite3BtreeLeave(pNew->pBt);
185 }
186 pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
187 if( rc==SQLITE_OK && pNew->zDbSName==0 ){
188 rc = SQLITE_NOMEM_BKPT;
189 }
190
191
192 #ifdef SQLITE_HAS_CODEC
193 if( rc==SQLITE_OK ){
194 extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
195 extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
196 int nKey;
197 char *zKey;
198 int t = sqlite3_value_type(argv[2]);
199 switch( t ){
200 case SQLITE_INTEGER:
201 case SQLITE_FLOAT:
202 zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
203 rc = SQLITE_ERROR;
204 break;
205
206 case SQLITE_TEXT:
207 case SQLITE_BLOB:
208 nKey = sqlite3_value_bytes(argv[2]);
209 zKey = (char *)sqlite3_value_blob(argv[2]);
210 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
211 break;
212
213 case SQLITE_NULL:
214 /* No key specified. Use the key from URI filename, or if none,
215 ** use the key from the main database. */
216 if( sqlite3CodecQueryParameters(db, zName, zPath)==0 ){
217 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
218 if( nKey || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){
219 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
220 }
221 }
222 break;
223 }
224 }
225 #endif
226 sqlite3_free( zPath );
227
228 /* If the file was opened successfully, read the schema for the new database.
229 ** If this fails, or if opening the file failed, then close the file and
230 ** remove the entry from the db->aDb[] array. i.e. put everything back the
231 ** way we found it.
232 */
233 if( rc==SQLITE_OK ){
234 sqlite3BtreeEnterAll(db);
235 db->init.iDb = 0;
236 db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
237 if( !REOPEN_AS_MEMDB(db) ){
238 rc = sqlite3Init(db, &zErrDyn);
239 }
240 sqlite3BtreeLeaveAll(db);
241 assert( zErrDyn==0 || rc!=SQLITE_OK );
242 }
243 #ifdef SQLITE_USER_AUTHENTICATION
244 if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
245 u8 newAuth = 0;
246 rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
247 if( newAuth<db->auth.authLevel ){
248 rc = SQLITE_AUTH_USER;
249 }
250 }
251 #endif
252 if( rc ){
253 if( !REOPEN_AS_MEMDB(db) ){
254 int iDb = db->nDb - 1;
255 assert( iDb>=2 );
256 if( db->aDb[iDb].pBt ){
257 sqlite3BtreeClose(db->aDb[iDb].pBt);
258 db->aDb[iDb].pBt = 0;
259 db->aDb[iDb].pSchema = 0;
260 }
261 sqlite3ResetAllSchemasOfConnection(db);
262 db->nDb = iDb;
263 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
264 sqlite3OomFault(db);
265 sqlite3DbFree(db, zErrDyn);
266 zErrDyn = sqlite3MPrintf(db, "out of memory");
267 }else if( zErrDyn==0 ){
268 zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
269 }
270 }
271 goto attach_error;
272 }
273
274 return;
275
276 attach_error:
277 /* Return an error if we get here */
278 if( zErrDyn ){
279 sqlite3_result_error(context, zErrDyn, -1);
280 sqlite3DbFree(db, zErrDyn);
281 }
282 if( rc ) sqlite3_result_error_code(context, rc);
283 }
284
285 /*
286 ** An SQL user-function registered to do the work of an DETACH statement. The
287 ** three arguments to the function come directly from a detach statement:
288 **
289 ** DETACH DATABASE x
290 **
291 ** SELECT sqlite_detach(x)
292 */
detachFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** argv)293 static void detachFunc(
294 sqlite3_context *context,
295 int NotUsed,
296 sqlite3_value **argv
297 ){
298 const char *zName = (const char *)sqlite3_value_text(argv[0]);
299 sqlite3 *db = sqlite3_context_db_handle(context);
300 int i;
301 Db *pDb = 0;
302 HashElem *pEntry;
303 char zErr[128];
304
305 UNUSED_PARAMETER(NotUsed);
306
307 if( zName==0 ) zName = "";
308 for(i=0; i<db->nDb; i++){
309 pDb = &db->aDb[i];
310 if( pDb->pBt==0 ) continue;
311 if( sqlite3StrICmp(pDb->zDbSName, zName)==0 ) break;
312 }
313
314 if( i>=db->nDb ){
315 sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
316 goto detach_error;
317 }
318 if( i<2 ){
319 sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
320 goto detach_error;
321 }
322 if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
323 sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
324 goto detach_error;
325 }
326
327 /* If any TEMP triggers reference the schema being detached, move those
328 ** triggers to reference the TEMP schema itself. */
329 assert( db->aDb[1].pSchema );
330 pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
331 while( pEntry ){
332 Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);
333 if( pTrig->pTabSchema==pDb->pSchema ){
334 pTrig->pTabSchema = pTrig->pSchema;
335 }
336 pEntry = sqliteHashNext(pEntry);
337 }
338
339 sqlite3BtreeClose(pDb->pBt);
340 pDb->pBt = 0;
341 pDb->pSchema = 0;
342 sqlite3CollapseDatabaseArray(db);
343 return;
344
345 detach_error:
346 sqlite3_result_error(context, zErr, -1);
347 }
348
349 /*
350 ** This procedure generates VDBE code for a single invocation of either the
351 ** sqlite_detach() or sqlite_attach() SQL user functions.
352 */
codeAttach(Parse * pParse,int type,FuncDef const * pFunc,Expr * pAuthArg,Expr * pFilename,Expr * pDbname,Expr * pKey)353 static void codeAttach(
354 Parse *pParse, /* The parser context */
355 int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */
356 FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
357 Expr *pAuthArg, /* Expression to pass to authorization callback */
358 Expr *pFilename, /* Name of database file */
359 Expr *pDbname, /* Name of the database to use internally */
360 Expr *pKey /* Database key for encryption extension */
361 ){
362 int rc;
363 NameContext sName;
364 Vdbe *v;
365 sqlite3* db = pParse->db;
366 int regArgs;
367
368 if( pParse->nErr ) goto attach_end;
369 memset(&sName, 0, sizeof(NameContext));
370 sName.pParse = pParse;
371
372 if(
373 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
374 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
375 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
376 ){
377 goto attach_end;
378 }
379
380 #ifndef SQLITE_OMIT_AUTHORIZATION
381 if( pAuthArg ){
382 char *zAuthArg;
383 if( pAuthArg->op==TK_STRING ){
384 zAuthArg = pAuthArg->u.zToken;
385 }else{
386 zAuthArg = 0;
387 }
388 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
389 if(rc!=SQLITE_OK ){
390 goto attach_end;
391 }
392 }
393 #endif /* SQLITE_OMIT_AUTHORIZATION */
394
395
396 v = sqlite3GetVdbe(pParse);
397 regArgs = sqlite3GetTempRange(pParse, 4);
398 sqlite3ExprCode(pParse, pFilename, regArgs);
399 sqlite3ExprCode(pParse, pDbname, regArgs+1);
400 sqlite3ExprCode(pParse, pKey, regArgs+2);
401
402 assert( v || db->mallocFailed );
403 if( v ){
404 sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
405 pFunc->nArg, pFunc, 0);
406 /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
407 ** statement only). For DETACH, set it to false (expire all existing
408 ** statements).
409 */
410 sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
411 }
412
413 attach_end:
414 sqlite3ExprDelete(db, pFilename);
415 sqlite3ExprDelete(db, pDbname);
416 sqlite3ExprDelete(db, pKey);
417 }
418
419 /*
420 ** Called by the parser to compile a DETACH statement.
421 **
422 ** DETACH pDbname
423 */
sqlite3Detach(Parse * pParse,Expr * pDbname)424 void sqlite3Detach(Parse *pParse, Expr *pDbname){
425 static const FuncDef detach_func = {
426 1, /* nArg */
427 SQLITE_UTF8, /* funcFlags */
428 0, /* pUserData */
429 0, /* pNext */
430 detachFunc, /* xSFunc */
431 0, /* xFinalize */
432 0, 0, /* xValue, xInverse */
433 "sqlite_detach", /* zName */
434 {0}
435 };
436 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
437 }
438
439 /*
440 ** Called by the parser to compile an ATTACH statement.
441 **
442 ** ATTACH p AS pDbname KEY pKey
443 */
sqlite3Attach(Parse * pParse,Expr * p,Expr * pDbname,Expr * pKey)444 void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
445 static const FuncDef attach_func = {
446 3, /* nArg */
447 SQLITE_UTF8, /* funcFlags */
448 0, /* pUserData */
449 0, /* pNext */
450 attachFunc, /* xSFunc */
451 0, /* xFinalize */
452 0, 0, /* xValue, xInverse */
453 "sqlite_attach", /* zName */
454 {0}
455 };
456 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
457 }
458 #endif /* SQLITE_OMIT_ATTACH */
459
460 /*
461 ** Initialize a DbFixer structure. This routine must be called prior
462 ** to passing the structure to one of the sqliteFixAAAA() routines below.
463 */
sqlite3FixInit(DbFixer * pFix,Parse * pParse,int iDb,const char * zType,const Token * pName)464 void sqlite3FixInit(
465 DbFixer *pFix, /* The fixer to be initialized */
466 Parse *pParse, /* Error messages will be written here */
467 int iDb, /* This is the database that must be used */
468 const char *zType, /* "view", "trigger", or "index" */
469 const Token *pName /* Name of the view, trigger, or index */
470 ){
471 sqlite3 *db;
472
473 db = pParse->db;
474 assert( db->nDb>iDb );
475 pFix->pParse = pParse;
476 pFix->zDb = db->aDb[iDb].zDbSName;
477 pFix->pSchema = db->aDb[iDb].pSchema;
478 pFix->zType = zType;
479 pFix->pName = pName;
480 pFix->bTemp = (iDb==1);
481 }
482
483 /*
484 ** The following set of routines walk through the parse tree and assign
485 ** a specific database to all table references where the database name
486 ** was left unspecified in the original SQL statement. The pFix structure
487 ** must have been initialized by a prior call to sqlite3FixInit().
488 **
489 ** These routines are used to make sure that an index, trigger, or
490 ** view in one database does not refer to objects in a different database.
491 ** (Exception: indices, triggers, and views in the TEMP database are
492 ** allowed to refer to anything.) If a reference is explicitly made
493 ** to an object in a different database, an error message is added to
494 ** pParse->zErrMsg and these routines return non-zero. If everything
495 ** checks out, these routines return 0.
496 */
sqlite3FixSrcList(DbFixer * pFix,SrcList * pList)497 int sqlite3FixSrcList(
498 DbFixer *pFix, /* Context of the fixation */
499 SrcList *pList /* The Source list to check and modify */
500 ){
501 int i;
502 const char *zDb;
503 struct SrcList_item *pItem;
504
505 if( NEVER(pList==0) ) return 0;
506 zDb = pFix->zDb;
507 for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
508 if( pFix->bTemp==0 ){
509 if( pItem->zDatabase && sqlite3StrICmp(pItem->zDatabase, zDb) ){
510 sqlite3ErrorMsg(pFix->pParse,
511 "%s %T cannot reference objects in database %s",
512 pFix->zType, pFix->pName, pItem->zDatabase);
513 return 1;
514 }
515 sqlite3DbFree(pFix->pParse->db, pItem->zDatabase);
516 pItem->zDatabase = 0;
517 pItem->pSchema = pFix->pSchema;
518 pItem->fg.fromDDL = 1;
519 }
520 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
521 if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
522 if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
523 #endif
524 if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){
525 return 1;
526 }
527 }
528 return 0;
529 }
530 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
sqlite3FixSelect(DbFixer * pFix,Select * pSelect)531 int sqlite3FixSelect(
532 DbFixer *pFix, /* Context of the fixation */
533 Select *pSelect /* The SELECT statement to be fixed to one database */
534 ){
535 while( pSelect ){
536 if( sqlite3FixExprList(pFix, pSelect->pEList) ){
537 return 1;
538 }
539 if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
540 return 1;
541 }
542 if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
543 return 1;
544 }
545 if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
546 return 1;
547 }
548 if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
549 return 1;
550 }
551 if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
552 return 1;
553 }
554 if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
555 return 1;
556 }
557 if( pSelect->pWith ){
558 int i;
559 for(i=0; i<pSelect->pWith->nCte; i++){
560 if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
561 return 1;
562 }
563 }
564 }
565 pSelect = pSelect->pPrior;
566 }
567 return 0;
568 }
sqlite3FixExpr(DbFixer * pFix,Expr * pExpr)569 int sqlite3FixExpr(
570 DbFixer *pFix, /* Context of the fixation */
571 Expr *pExpr /* The expression to be fixed to one database */
572 ){
573 while( pExpr ){
574 if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL);
575 if( pExpr->op==TK_VARIABLE ){
576 if( pFix->pParse->db->init.busy ){
577 pExpr->op = TK_NULL;
578 }else{
579 sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
580 return 1;
581 }
582 }
583 if( ExprHasProperty(pExpr, EP_TokenOnly|EP_Leaf) ) break;
584 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
585 if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
586 }else{
587 if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
588 }
589 if( sqlite3FixExpr(pFix, pExpr->pRight) ){
590 return 1;
591 }
592 pExpr = pExpr->pLeft;
593 }
594 return 0;
595 }
sqlite3FixExprList(DbFixer * pFix,ExprList * pList)596 int sqlite3FixExprList(
597 DbFixer *pFix, /* Context of the fixation */
598 ExprList *pList /* The expression to be fixed to one database */
599 ){
600 int i;
601 struct ExprList_item *pItem;
602 if( pList==0 ) return 0;
603 for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
604 if( sqlite3FixExpr(pFix, pItem->pExpr) ){
605 return 1;
606 }
607 }
608 return 0;
609 }
610 #endif
611
612 #ifndef SQLITE_OMIT_TRIGGER
sqlite3FixTriggerStep(DbFixer * pFix,TriggerStep * pStep)613 int sqlite3FixTriggerStep(
614 DbFixer *pFix, /* Context of the fixation */
615 TriggerStep *pStep /* The trigger step be fixed to one database */
616 ){
617 while( pStep ){
618 if( sqlite3FixSelect(pFix, pStep->pSelect) ){
619 return 1;
620 }
621 if( sqlite3FixExpr(pFix, pStep->pWhere) ){
622 return 1;
623 }
624 if( sqlite3FixExprList(pFix, pStep->pExprList) ){
625 return 1;
626 }
627 #ifndef SQLITE_OMIT_UPSERT
628 if( pStep->pUpsert ){
629 Upsert *pUp = pStep->pUpsert;
630 if( sqlite3FixExprList(pFix, pUp->pUpsertTarget)
631 || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere)
632 || sqlite3FixExprList(pFix, pUp->pUpsertSet)
633 || sqlite3FixExpr(pFix, pUp->pUpsertWhere)
634 ){
635 return 1;
636 }
637 }
638 #endif
639 pStep = pStep->pNext;
640 }
641 return 0;
642 }
643 #endif
644