Annotation of embedaddon/sqlite3/src/pragma.c, revision 1.1.1.1
1.1 misho 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 PRAGMA command.
13: */
14: #include "sqliteInt.h"
15:
16: /*
17: ** Interpret the given string as a safety level. Return 0 for OFF,
18: ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or
19: ** unrecognized string argument.
20: **
21: ** Note that the values returned are one less that the values that
22: ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done
23: ** to support legacy SQL code. The safety level used to be boolean
24: ** and older scripts may have used numbers 0 for OFF and 1 for ON.
25: */
26: static u8 getSafetyLevel(const char *z){
27: /* 123456789 123456789 */
28: static const char zText[] = "onoffalseyestruefull";
29: static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
30: static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
31: static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};
32: int i, n;
33: if( sqlite3Isdigit(*z) ){
34: return (u8)sqlite3Atoi(z);
35: }
36: n = sqlite3Strlen30(z);
37: for(i=0; i<ArraySize(iLength); i++){
38: if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
39: return iValue[i];
40: }
41: }
42: return 1;
43: }
44:
45: /*
46: ** Interpret the given string as a boolean value.
47: */
48: u8 sqlite3GetBoolean(const char *z){
49: return getSafetyLevel(z)&1;
50: }
51:
52: /* The sqlite3GetBoolean() function is used by other modules but the
53: ** remainder of this file is specific to PRAGMA processing. So omit
54: ** the rest of the file if PRAGMAs are omitted from the build.
55: */
56: #if !defined(SQLITE_OMIT_PRAGMA)
57:
58: /*
59: ** Interpret the given string as a locking mode value.
60: */
61: static int getLockingMode(const char *z){
62: if( z ){
63: if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
64: if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
65: }
66: return PAGER_LOCKINGMODE_QUERY;
67: }
68:
69: #ifndef SQLITE_OMIT_AUTOVACUUM
70: /*
71: ** Interpret the given string as an auto-vacuum mode value.
72: **
73: ** The following strings, "none", "full" and "incremental" are
74: ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
75: */
76: static int getAutoVacuum(const char *z){
77: int i;
78: if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
79: if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
80: if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
81: i = sqlite3Atoi(z);
82: return (u8)((i>=0&&i<=2)?i:0);
83: }
84: #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
85:
86: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
87: /*
88: ** Interpret the given string as a temp db location. Return 1 for file
89: ** backed temporary databases, 2 for the Red-Black tree in memory database
90: ** and 0 to use the compile-time default.
91: */
92: static int getTempStore(const char *z){
93: if( z[0]>='0' && z[0]<='2' ){
94: return z[0] - '0';
95: }else if( sqlite3StrICmp(z, "file")==0 ){
96: return 1;
97: }else if( sqlite3StrICmp(z, "memory")==0 ){
98: return 2;
99: }else{
100: return 0;
101: }
102: }
103: #endif /* SQLITE_PAGER_PRAGMAS */
104:
105: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
106: /*
107: ** Invalidate temp storage, either when the temp storage is changed
108: ** from default, or when 'file' and the temp_store_directory has changed
109: */
110: static int invalidateTempStorage(Parse *pParse){
111: sqlite3 *db = pParse->db;
112: if( db->aDb[1].pBt!=0 ){
113: if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
114: sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
115: "from within a transaction");
116: return SQLITE_ERROR;
117: }
118: sqlite3BtreeClose(db->aDb[1].pBt);
119: db->aDb[1].pBt = 0;
120: sqlite3ResetInternalSchema(db, -1);
121: }
122: return SQLITE_OK;
123: }
124: #endif /* SQLITE_PAGER_PRAGMAS */
125:
126: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
127: /*
128: ** If the TEMP database is open, close it and mark the database schema
129: ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
130: ** or DEFAULT_TEMP_STORE pragmas.
131: */
132: static int changeTempStorage(Parse *pParse, const char *zStorageType){
133: int ts = getTempStore(zStorageType);
134: sqlite3 *db = pParse->db;
135: if( db->temp_store==ts ) return SQLITE_OK;
136: if( invalidateTempStorage( pParse ) != SQLITE_OK ){
137: return SQLITE_ERROR;
138: }
139: db->temp_store = (u8)ts;
140: return SQLITE_OK;
141: }
142: #endif /* SQLITE_PAGER_PRAGMAS */
143:
144: /*
145: ** Generate code to return a single integer value.
146: */
147: static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
148: Vdbe *v = sqlite3GetVdbe(pParse);
149: int mem = ++pParse->nMem;
150: i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
151: if( pI64 ){
152: memcpy(pI64, &value, sizeof(value));
153: }
154: sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
155: sqlite3VdbeSetNumCols(v, 1);
156: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);
157: sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
158: }
159:
160: #ifndef SQLITE_OMIT_FLAG_PRAGMAS
161: /*
162: ** Check to see if zRight and zLeft refer to a pragma that queries
163: ** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
164: ** Also, implement the pragma.
165: */
166: static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
167: static const struct sPragmaType {
168: const char *zName; /* Name of the pragma */
169: int mask; /* Mask for the db->flags value */
170: } aPragma[] = {
171: { "full_column_names", SQLITE_FullColNames },
172: { "short_column_names", SQLITE_ShortColNames },
173: { "count_changes", SQLITE_CountRows },
174: { "empty_result_callbacks", SQLITE_NullCallback },
175: { "legacy_file_format", SQLITE_LegacyFileFmt },
176: { "fullfsync", SQLITE_FullFSync },
177: { "checkpoint_fullfsync", SQLITE_CkptFullFSync },
178: { "reverse_unordered_selects", SQLITE_ReverseOrder },
179: #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
180: { "automatic_index", SQLITE_AutoIndex },
181: #endif
182: #ifdef SQLITE_DEBUG
183: { "sql_trace", SQLITE_SqlTrace },
184: { "vdbe_listing", SQLITE_VdbeListing },
185: { "vdbe_trace", SQLITE_VdbeTrace },
186: #endif
187: #ifndef SQLITE_OMIT_CHECK
188: { "ignore_check_constraints", SQLITE_IgnoreChecks },
189: #endif
190: /* The following is VERY experimental */
191: { "writable_schema", SQLITE_WriteSchema|SQLITE_RecoveryMode },
192: { "omit_readlock", SQLITE_NoReadlock },
193:
194: /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
195: ** flag if there are any active statements. */
196: { "read_uncommitted", SQLITE_ReadUncommitted },
197: { "recursive_triggers", SQLITE_RecTriggers },
198:
199: /* This flag may only be set if both foreign-key and trigger support
200: ** are present in the build. */
201: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
202: { "foreign_keys", SQLITE_ForeignKeys },
203: #endif
204: };
205: int i;
206: const struct sPragmaType *p;
207: for(i=0, p=aPragma; i<ArraySize(aPragma); i++, p++){
208: if( sqlite3StrICmp(zLeft, p->zName)==0 ){
209: sqlite3 *db = pParse->db;
210: Vdbe *v;
211: v = sqlite3GetVdbe(pParse);
212: assert( v!=0 ); /* Already allocated by sqlite3Pragma() */
213: if( ALWAYS(v) ){
214: if( zRight==0 ){
215: returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
216: }else{
217: int mask = p->mask; /* Mask of bits to set or clear. */
218: if( db->autoCommit==0 ){
219: /* Foreign key support may not be enabled or disabled while not
220: ** in auto-commit mode. */
221: mask &= ~(SQLITE_ForeignKeys);
222: }
223:
224: if( sqlite3GetBoolean(zRight) ){
225: db->flags |= mask;
226: }else{
227: db->flags &= ~mask;
228: }
229:
230: /* Many of the flag-pragmas modify the code generated by the SQL
231: ** compiler (eg. count_changes). So add an opcode to expire all
232: ** compiled SQL statements after modifying a pragma value.
233: */
234: sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
235: }
236: }
237:
238: return 1;
239: }
240: }
241: return 0;
242: }
243: #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
244:
245: /*
246: ** Return a human-readable name for a constraint resolution action.
247: */
248: #ifndef SQLITE_OMIT_FOREIGN_KEY
249: static const char *actionName(u8 action){
250: const char *zName;
251: switch( action ){
252: case OE_SetNull: zName = "SET NULL"; break;
253: case OE_SetDflt: zName = "SET DEFAULT"; break;
254: case OE_Cascade: zName = "CASCADE"; break;
255: case OE_Restrict: zName = "RESTRICT"; break;
256: default: zName = "NO ACTION";
257: assert( action==OE_None ); break;
258: }
259: return zName;
260: }
261: #endif
262:
263:
264: /*
265: ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
266: ** defined in pager.h. This function returns the associated lowercase
267: ** journal-mode name.
268: */
269: const char *sqlite3JournalModename(int eMode){
270: static char * const azModeName[] = {
271: "delete", "persist", "off", "truncate", "memory"
272: #ifndef SQLITE_OMIT_WAL
273: , "wal"
274: #endif
275: };
276: assert( PAGER_JOURNALMODE_DELETE==0 );
277: assert( PAGER_JOURNALMODE_PERSIST==1 );
278: assert( PAGER_JOURNALMODE_OFF==2 );
279: assert( PAGER_JOURNALMODE_TRUNCATE==3 );
280: assert( PAGER_JOURNALMODE_MEMORY==4 );
281: assert( PAGER_JOURNALMODE_WAL==5 );
282: assert( eMode>=0 && eMode<=ArraySize(azModeName) );
283:
284: if( eMode==ArraySize(azModeName) ) return 0;
285: return azModeName[eMode];
286: }
287:
288: /*
289: ** Process a pragma statement.
290: **
291: ** Pragmas are of this form:
292: **
293: ** PRAGMA [database.]id [= value]
294: **
295: ** The identifier might also be a string. The value is a string, and
296: ** identifier, or a number. If minusFlag is true, then the value is
297: ** a number that was preceded by a minus sign.
298: **
299: ** If the left side is "database.id" then pId1 is the database name
300: ** and pId2 is the id. If the left side is just "id" then pId1 is the
301: ** id and pId2 is any empty string.
302: */
303: void sqlite3Pragma(
304: Parse *pParse,
305: Token *pId1, /* First part of [database.]id field */
306: Token *pId2, /* Second part of [database.]id field, or NULL */
307: Token *pValue, /* Token for <value>, or NULL */
308: int minusFlag /* True if a '-' sign preceded <value> */
309: ){
310: char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
311: char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
312: const char *zDb = 0; /* The database name */
313: Token *pId; /* Pointer to <id> token */
314: int iDb; /* Database index for <database> */
315: sqlite3 *db = pParse->db;
316: Db *pDb;
317: Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
318: if( v==0 ) return;
319: sqlite3VdbeRunOnlyOnce(v);
320: pParse->nMem = 2;
321:
322: /* Interpret the [database.] part of the pragma statement. iDb is the
323: ** index of the database this pragma is being applied to in db.aDb[]. */
324: iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
325: if( iDb<0 ) return;
326: pDb = &db->aDb[iDb];
327:
328: /* If the temp database has been explicitly named as part of the
329: ** pragma, make sure it is open.
330: */
331: if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
332: return;
333: }
334:
335: zLeft = sqlite3NameFromToken(db, pId);
336: if( !zLeft ) return;
337: if( minusFlag ){
338: zRight = sqlite3MPrintf(db, "-%T", pValue);
339: }else{
340: zRight = sqlite3NameFromToken(db, pValue);
341: }
342:
343: assert( pId2 );
344: zDb = pId2->n>0 ? pDb->zName : 0;
345: if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
346: goto pragma_out;
347: }
348:
349: #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
350: /*
351: ** PRAGMA [database.]default_cache_size
352: ** PRAGMA [database.]default_cache_size=N
353: **
354: ** The first form reports the current persistent setting for the
355: ** page cache size. The value returned is the maximum number of
356: ** pages in the page cache. The second form sets both the current
357: ** page cache size value and the persistent page cache size value
358: ** stored in the database file.
359: **
360: ** Older versions of SQLite would set the default cache size to a
361: ** negative number to indicate synchronous=OFF. These days, synchronous
362: ** is always on by default regardless of the sign of the default cache
363: ** size. But continue to take the absolute value of the default cache
364: ** size of historical compatibility.
365: */
366: if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
367: static const VdbeOpList getCacheSize[] = {
368: { OP_Transaction, 0, 0, 0}, /* 0 */
369: { OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */
370: { OP_IfPos, 1, 7, 0},
371: { OP_Integer, 0, 2, 0},
372: { OP_Subtract, 1, 2, 1},
373: { OP_IfPos, 1, 7, 0},
374: { OP_Integer, 0, 1, 0}, /* 6 */
375: { OP_ResultRow, 1, 1, 0},
376: };
377: int addr;
378: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
379: sqlite3VdbeUsesBtree(v, iDb);
380: if( !zRight ){
381: sqlite3VdbeSetNumCols(v, 1);
382: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLITE_STATIC);
383: pParse->nMem += 2;
384: addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
385: sqlite3VdbeChangeP1(v, addr, iDb);
386: sqlite3VdbeChangeP1(v, addr+1, iDb);
387: sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);
388: }else{
389: int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
390: sqlite3BeginWriteOperation(pParse, 0, iDb);
391: sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
392: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
393: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
394: pDb->pSchema->cache_size = size;
395: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
396: }
397: }else
398: #endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */
399:
400: #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
401: /*
402: ** PRAGMA [database.]page_size
403: ** PRAGMA [database.]page_size=N
404: **
405: ** The first form reports the current setting for the
406: ** database page size in bytes. The second form sets the
407: ** database page size value. The value can only be set if
408: ** the database has not yet been created.
409: */
410: if( sqlite3StrICmp(zLeft,"page_size")==0 ){
411: Btree *pBt = pDb->pBt;
412: assert( pBt!=0 );
413: if( !zRight ){
414: int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
415: returnSingleInt(pParse, "page_size", size);
416: }else{
417: /* Malloc may fail when setting the page-size, as there is an internal
418: ** buffer that the pager module resizes using sqlite3_realloc().
419: */
420: db->nextPagesize = sqlite3Atoi(zRight);
421: if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
422: db->mallocFailed = 1;
423: }
424: }
425: }else
426:
427: /*
428: ** PRAGMA [database.]secure_delete
429: ** PRAGMA [database.]secure_delete=ON/OFF
430: **
431: ** The first form reports the current setting for the
432: ** secure_delete flag. The second form changes the secure_delete
433: ** flag setting and reports thenew value.
434: */
435: if( sqlite3StrICmp(zLeft,"secure_delete")==0 ){
436: Btree *pBt = pDb->pBt;
437: int b = -1;
438: assert( pBt!=0 );
439: if( zRight ){
440: b = sqlite3GetBoolean(zRight);
441: }
442: if( pId2->n==0 && b>=0 ){
443: int ii;
444: for(ii=0; ii<db->nDb; ii++){
445: sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
446: }
447: }
448: b = sqlite3BtreeSecureDelete(pBt, b);
449: returnSingleInt(pParse, "secure_delete", b);
450: }else
451:
452: /*
453: ** PRAGMA [database.]max_page_count
454: ** PRAGMA [database.]max_page_count=N
455: **
456: ** The first form reports the current setting for the
457: ** maximum number of pages in the database file. The
458: ** second form attempts to change this setting. Both
459: ** forms return the current setting.
460: **
461: ** The absolute value of N is used. This is undocumented and might
462: ** change. The only purpose is to provide an easy way to test
463: ** the sqlite3AbsInt32() function.
464: **
465: ** PRAGMA [database.]page_count
466: **
467: ** Return the number of pages in the specified database.
468: */
469: if( sqlite3StrICmp(zLeft,"page_count")==0
470: || sqlite3StrICmp(zLeft,"max_page_count")==0
471: ){
472: int iReg;
473: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
474: sqlite3CodeVerifySchema(pParse, iDb);
475: iReg = ++pParse->nMem;
476: if( sqlite3Tolower(zLeft[0])=='p' ){
477: sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
478: }else{
479: sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg,
480: sqlite3AbsInt32(sqlite3Atoi(zRight)));
481: }
482: sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
483: sqlite3VdbeSetNumCols(v, 1);
484: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
485: }else
486:
487: /*
488: ** PRAGMA [database.]locking_mode
489: ** PRAGMA [database.]locking_mode = (normal|exclusive)
490: */
491: if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){
492: const char *zRet = "normal";
493: int eMode = getLockingMode(zRight);
494:
495: if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
496: /* Simple "PRAGMA locking_mode;" statement. This is a query for
497: ** the current default locking mode (which may be different to
498: ** the locking-mode of the main database).
499: */
500: eMode = db->dfltLockMode;
501: }else{
502: Pager *pPager;
503: if( pId2->n==0 ){
504: /* This indicates that no database name was specified as part
505: ** of the PRAGMA command. In this case the locking-mode must be
506: ** set on all attached databases, as well as the main db file.
507: **
508: ** Also, the sqlite3.dfltLockMode variable is set so that
509: ** any subsequently attached databases also use the specified
510: ** locking mode.
511: */
512: int ii;
513: assert(pDb==&db->aDb[0]);
514: for(ii=2; ii<db->nDb; ii++){
515: pPager = sqlite3BtreePager(db->aDb[ii].pBt);
516: sqlite3PagerLockingMode(pPager, eMode);
517: }
518: db->dfltLockMode = (u8)eMode;
519: }
520: pPager = sqlite3BtreePager(pDb->pBt);
521: eMode = sqlite3PagerLockingMode(pPager, eMode);
522: }
523:
524: assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
525: if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
526: zRet = "exclusive";
527: }
528: sqlite3VdbeSetNumCols(v, 1);
529: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", SQLITE_STATIC);
530: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
531: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
532: }else
533:
534: /*
535: ** PRAGMA [database.]journal_mode
536: ** PRAGMA [database.]journal_mode =
537: ** (delete|persist|off|truncate|memory|wal|off)
538: */
539: if( sqlite3StrICmp(zLeft,"journal_mode")==0 ){
540: int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */
541: int ii; /* Loop counter */
542:
543: /* Force the schema to be loaded on all databases. This causes all
544: ** database files to be opened and the journal_modes set. This is
545: ** necessary because subsequent processing must know if the databases
546: ** are in WAL mode. */
547: if( sqlite3ReadSchema(pParse) ){
548: goto pragma_out;
549: }
550:
551: sqlite3VdbeSetNumCols(v, 1);
552: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", SQLITE_STATIC);
553:
554: if( zRight==0 ){
555: /* If there is no "=MODE" part of the pragma, do a query for the
556: ** current mode */
557: eMode = PAGER_JOURNALMODE_QUERY;
558: }else{
559: const char *zMode;
560: int n = sqlite3Strlen30(zRight);
561: for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){
562: if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;
563: }
564: if( !zMode ){
565: /* If the "=MODE" part does not match any known journal mode,
566: ** then do a query */
567: eMode = PAGER_JOURNALMODE_QUERY;
568: }
569: }
570: if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
571: /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
572: iDb = 0;
573: pId2->n = 1;
574: }
575: for(ii=db->nDb-1; ii>=0; ii--){
576: if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
577: sqlite3VdbeUsesBtree(v, ii);
578: sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
579: }
580: }
581: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
582: }else
583:
584: /*
585: ** PRAGMA [database.]journal_size_limit
586: ** PRAGMA [database.]journal_size_limit=N
587: **
588: ** Get or set the size limit on rollback journal files.
589: */
590: if( sqlite3StrICmp(zLeft,"journal_size_limit")==0 ){
591: Pager *pPager = sqlite3BtreePager(pDb->pBt);
592: i64 iLimit = -2;
593: if( zRight ){
594: sqlite3Atoi64(zRight, &iLimit, 1000000, SQLITE_UTF8);
595: if( iLimit<-1 ) iLimit = -1;
596: }
597: iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
598: returnSingleInt(pParse, "journal_size_limit", iLimit);
599: }else
600:
601: #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
602:
603: /*
604: ** PRAGMA [database.]auto_vacuum
605: ** PRAGMA [database.]auto_vacuum=N
606: **
607: ** Get or set the value of the database 'auto-vacuum' parameter.
608: ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL
609: */
610: #ifndef SQLITE_OMIT_AUTOVACUUM
611: if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
612: Btree *pBt = pDb->pBt;
613: assert( pBt!=0 );
614: if( sqlite3ReadSchema(pParse) ){
615: goto pragma_out;
616: }
617: if( !zRight ){
618: int auto_vacuum;
619: if( ALWAYS(pBt) ){
620: auto_vacuum = sqlite3BtreeGetAutoVacuum(pBt);
621: }else{
622: auto_vacuum = SQLITE_DEFAULT_AUTOVACUUM;
623: }
624: returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
625: }else{
626: int eAuto = getAutoVacuum(zRight);
627: assert( eAuto>=0 && eAuto<=2 );
628: db->nextAutovac = (u8)eAuto;
629: if( ALWAYS(eAuto>=0) ){
630: /* Call SetAutoVacuum() to set initialize the internal auto and
631: ** incr-vacuum flags. This is required in case this connection
632: ** creates the database file. It is important that it is created
633: ** as an auto-vacuum capable db.
634: */
635: int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
636: if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
637: /* When setting the auto_vacuum mode to either "full" or
638: ** "incremental", write the value of meta[6] in the database
639: ** file. Before writing to meta[6], check that meta[3] indicates
640: ** that this really is an auto-vacuum capable database.
641: */
642: static const VdbeOpList setMeta6[] = {
643: { OP_Transaction, 0, 1, 0}, /* 0 */
644: { OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE},
645: { OP_If, 1, 0, 0}, /* 2 */
646: { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
647: { OP_Integer, 0, 1, 0}, /* 4 */
648: { OP_SetCookie, 0, BTREE_INCR_VACUUM, 1}, /* 5 */
649: };
650: int iAddr;
651: iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
652: sqlite3VdbeChangeP1(v, iAddr, iDb);
653: sqlite3VdbeChangeP1(v, iAddr+1, iDb);
654: sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
655: sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
656: sqlite3VdbeChangeP1(v, iAddr+5, iDb);
657: sqlite3VdbeUsesBtree(v, iDb);
658: }
659: }
660: }
661: }else
662: #endif
663:
664: /*
665: ** PRAGMA [database.]incremental_vacuum(N)
666: **
667: ** Do N steps of incremental vacuuming on a database.
668: */
669: #ifndef SQLITE_OMIT_AUTOVACUUM
670: if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){
671: int iLimit, addr;
672: if( sqlite3ReadSchema(pParse) ){
673: goto pragma_out;
674: }
675: if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
676: iLimit = 0x7fffffff;
677: }
678: sqlite3BeginWriteOperation(pParse, 0, iDb);
679: sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
680: addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
681: sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
682: sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
683: sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
684: sqlite3VdbeJumpHere(v, addr);
685: }else
686: #endif
687:
688: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
689: /*
690: ** PRAGMA [database.]cache_size
691: ** PRAGMA [database.]cache_size=N
692: **
693: ** The first form reports the current local setting for the
694: ** page cache size. The second form sets the local
695: ** page cache size value. If N is positive then that is the
696: ** number of pages in the cache. If N is negative, then the
697: ** number of pages is adjusted so that the cache uses -N kibibytes
698: ** of memory.
699: */
700: if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
701: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
702: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
703: if( !zRight ){
704: returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
705: }else{
706: int size = sqlite3Atoi(zRight);
707: pDb->pSchema->cache_size = size;
708: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
709: }
710: }else
711:
712: /*
713: ** PRAGMA temp_store
714: ** PRAGMA temp_store = "default"|"memory"|"file"
715: **
716: ** Return or set the local value of the temp_store flag. Changing
717: ** the local value does not make changes to the disk file and the default
718: ** value will be restored the next time the database is opened.
719: **
720: ** Note that it is possible for the library compile-time options to
721: ** override this setting
722: */
723: if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
724: if( !zRight ){
725: returnSingleInt(pParse, "temp_store", db->temp_store);
726: }else{
727: changeTempStorage(pParse, zRight);
728: }
729: }else
730:
731: /*
732: ** PRAGMA temp_store_directory
733: ** PRAGMA temp_store_directory = ""|"directory_name"
734: **
735: ** Return or set the local value of the temp_store_directory flag. Changing
736: ** the value sets a specific directory to be used for temporary files.
737: ** Setting to a null string reverts to the default temporary directory search.
738: ** If temporary directory is changed, then invalidateTempStorage.
739: **
740: */
741: if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
742: if( !zRight ){
743: if( sqlite3_temp_directory ){
744: sqlite3VdbeSetNumCols(v, 1);
745: sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
746: "temp_store_directory", SQLITE_STATIC);
747: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
748: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
749: }
750: }else{
751: #ifndef SQLITE_OMIT_WSD
752: if( zRight[0] ){
753: int rc;
754: int res;
755: rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
756: if( rc!=SQLITE_OK || res==0 ){
757: sqlite3ErrorMsg(pParse, "not a writable directory");
758: goto pragma_out;
759: }
760: }
761: if( SQLITE_TEMP_STORE==0
762: || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
763: || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
764: ){
765: invalidateTempStorage(pParse);
766: }
767: sqlite3_free(sqlite3_temp_directory);
768: if( zRight[0] ){
769: sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);
770: }else{
771: sqlite3_temp_directory = 0;
772: }
773: #endif /* SQLITE_OMIT_WSD */
774: }
775: }else
776:
777: #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
778: # if defined(__APPLE__)
779: # define SQLITE_ENABLE_LOCKING_STYLE 1
780: # else
781: # define SQLITE_ENABLE_LOCKING_STYLE 0
782: # endif
783: #endif
784: #if SQLITE_ENABLE_LOCKING_STYLE
785: /*
786: ** PRAGMA [database.]lock_proxy_file
787: ** PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"
788: **
789: ** Return or set the value of the lock_proxy_file flag. Changing
790: ** the value sets a specific file to be used for database access locks.
791: **
792: */
793: if( sqlite3StrICmp(zLeft, "lock_proxy_file")==0 ){
794: if( !zRight ){
795: Pager *pPager = sqlite3BtreePager(pDb->pBt);
796: char *proxy_file_path = NULL;
797: sqlite3_file *pFile = sqlite3PagerFile(pPager);
798: sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
799: &proxy_file_path);
800:
801: if( proxy_file_path ){
802: sqlite3VdbeSetNumCols(v, 1);
803: sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
804: "lock_proxy_file", SQLITE_STATIC);
805: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, proxy_file_path, 0);
806: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
807: }
808: }else{
809: Pager *pPager = sqlite3BtreePager(pDb->pBt);
810: sqlite3_file *pFile = sqlite3PagerFile(pPager);
811: int res;
812: if( zRight[0] ){
813: res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
814: zRight);
815: } else {
816: res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
817: NULL);
818: }
819: if( res!=SQLITE_OK ){
820: sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
821: goto pragma_out;
822: }
823: }
824: }else
825: #endif /* SQLITE_ENABLE_LOCKING_STYLE */
826:
827: /*
828: ** PRAGMA [database.]synchronous
829: ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
830: **
831: ** Return or set the local value of the synchronous flag. Changing
832: ** the local value does not make changes to the disk file and the
833: ** default value will be restored the next time the database is
834: ** opened.
835: */
836: if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
837: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
838: if( !zRight ){
839: returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
840: }else{
841: if( !db->autoCommit ){
842: sqlite3ErrorMsg(pParse,
843: "Safety level may not be changed inside a transaction");
844: }else{
845: pDb->safety_level = getSafetyLevel(zRight)+1;
846: }
847: }
848: }else
849: #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
850:
851: #ifndef SQLITE_OMIT_FLAG_PRAGMAS
852: if( flagPragma(pParse, zLeft, zRight) ){
853: /* The flagPragma() subroutine also generates any necessary code
854: ** there is nothing more to do here */
855: }else
856: #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
857:
858: #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
859: /*
860: ** PRAGMA table_info(<table>)
861: **
862: ** Return a single row for each column of the named table. The columns of
863: ** the returned data set are:
864: **
865: ** cid: Column id (numbered from left to right, starting at 0)
866: ** name: Column name
867: ** type: Column declaration type.
868: ** notnull: True if 'NOT NULL' is part of column declaration
869: ** dflt_value: The default value for the column, if any.
870: */
871: if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
872: Table *pTab;
873: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
874: pTab = sqlite3FindTable(db, zRight, zDb);
875: if( pTab ){
876: int i;
877: int nHidden = 0;
878: Column *pCol;
879: sqlite3VdbeSetNumCols(v, 6);
880: pParse->nMem = 6;
881: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", SQLITE_STATIC);
882: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
883: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", SQLITE_STATIC);
884: sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", SQLITE_STATIC);
885: sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", SQLITE_STATIC);
886: sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", SQLITE_STATIC);
887: sqlite3ViewGetColumnNames(pParse, pTab);
888: for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
889: if( IsHiddenColumn(pCol) ){
890: nHidden++;
891: continue;
892: }
893: sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
894: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
895: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
896: pCol->zType ? pCol->zType : "", 0);
897: sqlite3VdbeAddOp2(v, OP_Integer, (pCol->notNull ? 1 : 0), 4);
898: if( pCol->zDflt ){
899: sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pCol->zDflt, 0);
900: }else{
901: sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
902: }
903: sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
904: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
905: }
906: }
907: }else
908:
909: if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
910: Index *pIdx;
911: Table *pTab;
912: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
913: pIdx = sqlite3FindIndex(db, zRight, zDb);
914: if( pIdx ){
915: int i;
916: pTab = pIdx->pTable;
917: sqlite3VdbeSetNumCols(v, 3);
918: pParse->nMem = 3;
919: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLITE_STATIC);
920: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLITE_STATIC);
921: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLITE_STATIC);
922: for(i=0; i<pIdx->nColumn; i++){
923: int cnum = pIdx->aiColumn[i];
924: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
925: sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
926: assert( pTab->nCol>cnum );
927: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
928: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
929: }
930: }
931: }else
932:
933: if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
934: Index *pIdx;
935: Table *pTab;
936: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
937: pTab = sqlite3FindTable(db, zRight, zDb);
938: if( pTab ){
939: v = sqlite3GetVdbe(pParse);
940: pIdx = pTab->pIndex;
941: if( pIdx ){
942: int i = 0;
943: sqlite3VdbeSetNumCols(v, 3);
944: pParse->nMem = 3;
945: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
946: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
947: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", SQLITE_STATIC);
948: while(pIdx){
949: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
950: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
951: sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
952: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
953: ++i;
954: pIdx = pIdx->pNext;
955: }
956: }
957: }
958: }else
959:
960: if( sqlite3StrICmp(zLeft, "database_list")==0 ){
961: int i;
962: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
963: sqlite3VdbeSetNumCols(v, 3);
964: pParse->nMem = 3;
965: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
966: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
967: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", SQLITE_STATIC);
968: for(i=0; i<db->nDb; i++){
969: if( db->aDb[i].pBt==0 ) continue;
970: assert( db->aDb[i].zName!=0 );
971: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
972: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
973: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
974: sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
975: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
976: }
977: }else
978:
979: if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
980: int i = 0;
981: HashElem *p;
982: sqlite3VdbeSetNumCols(v, 2);
983: pParse->nMem = 2;
984: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
985: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
986: for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
987: CollSeq *pColl = (CollSeq *)sqliteHashData(p);
988: sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
989: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
990: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
991: }
992: }else
993: #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
994:
995: #ifndef SQLITE_OMIT_FOREIGN_KEY
996: if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
997: FKey *pFK;
998: Table *pTab;
999: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1000: pTab = sqlite3FindTable(db, zRight, zDb);
1001: if( pTab ){
1002: v = sqlite3GetVdbe(pParse);
1003: pFK = pTab->pFKey;
1004: if( pFK ){
1005: int i = 0;
1006: sqlite3VdbeSetNumCols(v, 8);
1007: pParse->nMem = 8;
1008: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", SQLITE_STATIC);
1009: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", SQLITE_STATIC);
1010: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", SQLITE_STATIC);
1011: sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", SQLITE_STATIC);
1012: sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", SQLITE_STATIC);
1013: sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "on_update", SQLITE_STATIC);
1014: sqlite3VdbeSetColName(v, 6, COLNAME_NAME, "on_delete", SQLITE_STATIC);
1015: sqlite3VdbeSetColName(v, 7, COLNAME_NAME, "match", SQLITE_STATIC);
1016: while(pFK){
1017: int j;
1018: for(j=0; j<pFK->nCol; j++){
1019: char *zCol = pFK->aCol[j].zCol;
1020: char *zOnDelete = (char *)actionName(pFK->aAction[0]);
1021: char *zOnUpdate = (char *)actionName(pFK->aAction[1]);
1022: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1023: sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
1024: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
1025: sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
1026: pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
1027: sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
1028: sqlite3VdbeAddOp4(v, OP_String8, 0, 6, 0, zOnUpdate, 0);
1029: sqlite3VdbeAddOp4(v, OP_String8, 0, 7, 0, zOnDelete, 0);
1030: sqlite3VdbeAddOp4(v, OP_String8, 0, 8, 0, "NONE", 0);
1031: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 8);
1032: }
1033: ++i;
1034: pFK = pFK->pNextFrom;
1035: }
1036: }
1037: }
1038: }else
1039: #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1040:
1041: #ifndef NDEBUG
1042: if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
1043: if( zRight ){
1044: if( sqlite3GetBoolean(zRight) ){
1045: sqlite3ParserTrace(stderr, "parser: ");
1046: }else{
1047: sqlite3ParserTrace(0, 0);
1048: }
1049: }
1050: }else
1051: #endif
1052:
1053: /* Reinstall the LIKE and GLOB functions. The variant of LIKE
1054: ** used will be case sensitive or not depending on the RHS.
1055: */
1056: if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
1057: if( zRight ){
1058: sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight));
1059: }
1060: }else
1061:
1062: #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
1063: # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
1064: #endif
1065:
1066: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
1067: /* Pragma "quick_check" is an experimental reduced version of
1068: ** integrity_check designed to detect most database corruption
1069: ** without most of the overhead of a full integrity-check.
1070: */
1071: if( sqlite3StrICmp(zLeft, "integrity_check")==0
1072: || sqlite3StrICmp(zLeft, "quick_check")==0
1073: ){
1074: int i, j, addr, mxErr;
1075:
1076: /* Code that appears at the end of the integrity check. If no error
1077: ** messages have been generated, output OK. Otherwise output the
1078: ** error message
1079: */
1080: static const VdbeOpList endCode[] = {
1081: { OP_AddImm, 1, 0, 0}, /* 0 */
1082: { OP_IfNeg, 1, 0, 0}, /* 1 */
1083: { OP_String8, 0, 3, 0}, /* 2 */
1084: { OP_ResultRow, 3, 1, 0},
1085: };
1086:
1087: int isQuick = (sqlite3Tolower(zLeft[0])=='q');
1088:
1089: /* Initialize the VDBE program */
1090: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1091: pParse->nMem = 6;
1092: sqlite3VdbeSetNumCols(v, 1);
1093: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", SQLITE_STATIC);
1094:
1095: /* Set the maximum error count */
1096: mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1097: if( zRight ){
1098: sqlite3GetInt32(zRight, &mxErr);
1099: if( mxErr<=0 ){
1100: mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1101: }
1102: }
1103: sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */
1104:
1105: /* Do an integrity check on each database file */
1106: for(i=0; i<db->nDb; i++){
1107: HashElem *x;
1108: Hash *pTbls;
1109: int cnt = 0;
1110:
1111: if( OMIT_TEMPDB && i==1 ) continue;
1112:
1113: sqlite3CodeVerifySchema(pParse, i);
1114: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
1115: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1116: sqlite3VdbeJumpHere(v, addr);
1117:
1118: /* Do an integrity check of the B-Tree
1119: **
1120: ** Begin by filling registers 2, 3, ... with the root pages numbers
1121: ** for all tables and indices in the database.
1122: */
1123: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1124: pTbls = &db->aDb[i].pSchema->tblHash;
1125: for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
1126: Table *pTab = sqliteHashData(x);
1127: Index *pIdx;
1128: sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
1129: cnt++;
1130: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1131: sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
1132: cnt++;
1133: }
1134: }
1135:
1136: /* Make sure sufficient number of registers have been allocated */
1137: if( pParse->nMem < cnt+4 ){
1138: pParse->nMem = cnt+4;
1139: }
1140:
1141: /* Do the b-tree integrity checks */
1142: sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
1143: sqlite3VdbeChangeP5(v, (u8)i);
1144: addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
1145: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1146: sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
1147: P4_DYNAMIC);
1148: sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
1149: sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
1150: sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
1151: sqlite3VdbeJumpHere(v, addr);
1152:
1153: /* Make sure all the indices are constructed correctly.
1154: */
1155: for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
1156: Table *pTab = sqliteHashData(x);
1157: Index *pIdx;
1158: int loopTop;
1159:
1160: if( pTab->pIndex==0 ) continue;
1161: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
1162: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1163: sqlite3VdbeJumpHere(v, addr);
1164: sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
1165: sqlite3VdbeAddOp2(v, OP_Integer, 0, 2); /* reg(2) will count entries */
1166: loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);
1167: sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1); /* increment entry count */
1168: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1169: int jmp2;
1170: int r1;
1171: static const VdbeOpList idxErr[] = {
1172: { OP_AddImm, 1, -1, 0},
1173: { OP_String8, 0, 3, 0}, /* 1 */
1174: { OP_Rowid, 1, 4, 0},
1175: { OP_String8, 0, 5, 0}, /* 3 */
1176: { OP_String8, 0, 6, 0}, /* 4 */
1177: { OP_Concat, 4, 3, 3},
1178: { OP_Concat, 5, 3, 3},
1179: { OP_Concat, 6, 3, 3},
1180: { OP_ResultRow, 3, 1, 0},
1181: { OP_IfPos, 1, 0, 0}, /* 9 */
1182: { OP_Halt, 0, 0, 0},
1183: };
1184: r1 = sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 0);
1185: jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, j+2, 0, r1, pIdx->nColumn+1);
1186: addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
1187: sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
1188: sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
1189: sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
1190: sqlite3VdbeJumpHere(v, addr+9);
1191: sqlite3VdbeJumpHere(v, jmp2);
1192: }
1193: sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
1194: sqlite3VdbeJumpHere(v, loopTop);
1195: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1196: static const VdbeOpList cntIdx[] = {
1197: { OP_Integer, 0, 3, 0},
1198: { OP_Rewind, 0, 0, 0}, /* 1 */
1199: { OP_AddImm, 3, 1, 0},
1200: { OP_Next, 0, 0, 0}, /* 3 */
1201: { OP_Eq, 2, 0, 3}, /* 4 */
1202: { OP_AddImm, 1, -1, 0},
1203: { OP_String8, 0, 2, 0}, /* 6 */
1204: { OP_String8, 0, 3, 0}, /* 7 */
1205: { OP_Concat, 3, 2, 2},
1206: { OP_ResultRow, 2, 1, 0},
1207: };
1208: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
1209: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1210: sqlite3VdbeJumpHere(v, addr);
1211: addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
1212: sqlite3VdbeChangeP1(v, addr+1, j+2);
1213: sqlite3VdbeChangeP2(v, addr+1, addr+4);
1214: sqlite3VdbeChangeP1(v, addr+3, j+2);
1215: sqlite3VdbeChangeP2(v, addr+3, addr+2);
1216: sqlite3VdbeJumpHere(v, addr+4);
1217: sqlite3VdbeChangeP4(v, addr+6,
1218: "wrong # of entries in index ", P4_STATIC);
1219: sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_TRANSIENT);
1220: }
1221: }
1222: }
1223: addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
1224: sqlite3VdbeChangeP2(v, addr, -mxErr);
1225: sqlite3VdbeJumpHere(v, addr+1);
1226: sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
1227: }else
1228: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
1229:
1230: #ifndef SQLITE_OMIT_UTF16
1231: /*
1232: ** PRAGMA encoding
1233: ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
1234: **
1235: ** In its first form, this pragma returns the encoding of the main
1236: ** database. If the database is not initialized, it is initialized now.
1237: **
1238: ** The second form of this pragma is a no-op if the main database file
1239: ** has not already been initialized. In this case it sets the default
1240: ** encoding that will be used for the main database file if a new file
1241: ** is created. If an existing main database file is opened, then the
1242: ** default text encoding for the existing database is used.
1243: **
1244: ** In all cases new databases created using the ATTACH command are
1245: ** created to use the same default text encoding as the main database. If
1246: ** the main database has not been initialized and/or created when ATTACH
1247: ** is executed, this is done before the ATTACH operation.
1248: **
1249: ** In the second form this pragma sets the text encoding to be used in
1250: ** new database files created using this database handle. It is only
1251: ** useful if invoked immediately after the main database i
1252: */
1253: if( sqlite3StrICmp(zLeft, "encoding")==0 ){
1254: static const struct EncName {
1255: char *zName;
1256: u8 enc;
1257: } encnames[] = {
1258: { "UTF8", SQLITE_UTF8 },
1259: { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */
1260: { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */
1261: { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */
1262: { "UTF16le", SQLITE_UTF16LE },
1263: { "UTF16be", SQLITE_UTF16BE },
1264: { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */
1265: { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */
1266: { 0, 0 }
1267: };
1268: const struct EncName *pEnc;
1269: if( !zRight ){ /* "PRAGMA encoding" */
1270: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1271: sqlite3VdbeSetNumCols(v, 1);
1272: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", SQLITE_STATIC);
1273: sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
1274: assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
1275: assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
1276: assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
1277: sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
1278: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1279: }else{ /* "PRAGMA encoding = XXX" */
1280: /* Only change the value of sqlite.enc if the database handle is not
1281: ** initialized. If the main database exists, the new sqlite.enc value
1282: ** will be overwritten when the schema is next loaded. If it does not
1283: ** already exists, it will be created to use the new encoding value.
1284: */
1285: if(
1286: !(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
1287: DbHasProperty(db, 0, DB_Empty)
1288: ){
1289: for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
1290: if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
1291: ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
1292: break;
1293: }
1294: }
1295: if( !pEnc->zName ){
1296: sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
1297: }
1298: }
1299: }
1300: }else
1301: #endif /* SQLITE_OMIT_UTF16 */
1302:
1303: #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
1304: /*
1305: ** PRAGMA [database.]schema_version
1306: ** PRAGMA [database.]schema_version = <integer>
1307: **
1308: ** PRAGMA [database.]user_version
1309: ** PRAGMA [database.]user_version = <integer>
1310: **
1311: ** The pragma's schema_version and user_version are used to set or get
1312: ** the value of the schema-version and user-version, respectively. Both
1313: ** the schema-version and the user-version are 32-bit signed integers
1314: ** stored in the database header.
1315: **
1316: ** The schema-cookie is usually only manipulated internally by SQLite. It
1317: ** is incremented by SQLite whenever the database schema is modified (by
1318: ** creating or dropping a table or index). The schema version is used by
1319: ** SQLite each time a query is executed to ensure that the internal cache
1320: ** of the schema used when compiling the SQL query matches the schema of
1321: ** the database against which the compiled query is actually executed.
1322: ** Subverting this mechanism by using "PRAGMA schema_version" to modify
1323: ** the schema-version is potentially dangerous and may lead to program
1324: ** crashes or database corruption. Use with caution!
1325: **
1326: ** The user-version is not used internally by SQLite. It may be used by
1327: ** applications for any purpose.
1328: */
1329: if( sqlite3StrICmp(zLeft, "schema_version")==0
1330: || sqlite3StrICmp(zLeft, "user_version")==0
1331: || sqlite3StrICmp(zLeft, "freelist_count")==0
1332: ){
1333: int iCookie; /* Cookie index. 1 for schema-cookie, 6 for user-cookie. */
1334: sqlite3VdbeUsesBtree(v, iDb);
1335: switch( zLeft[0] ){
1336: case 'f': case 'F':
1337: iCookie = BTREE_FREE_PAGE_COUNT;
1338: break;
1339: case 's': case 'S':
1340: iCookie = BTREE_SCHEMA_VERSION;
1341: break;
1342: default:
1343: iCookie = BTREE_USER_VERSION;
1344: break;
1345: }
1346:
1347: if( zRight && iCookie!=BTREE_FREE_PAGE_COUNT ){
1348: /* Write the specified cookie value */
1349: static const VdbeOpList setCookie[] = {
1350: { OP_Transaction, 0, 1, 0}, /* 0 */
1351: { OP_Integer, 0, 1, 0}, /* 1 */
1352: { OP_SetCookie, 0, 0, 1}, /* 2 */
1353: };
1354: int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
1355: sqlite3VdbeChangeP1(v, addr, iDb);
1356: sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight));
1357: sqlite3VdbeChangeP1(v, addr+2, iDb);
1358: sqlite3VdbeChangeP2(v, addr+2, iCookie);
1359: }else{
1360: /* Read the specified cookie value */
1361: static const VdbeOpList readCookie[] = {
1362: { OP_Transaction, 0, 0, 0}, /* 0 */
1363: { OP_ReadCookie, 0, 1, 0}, /* 1 */
1364: { OP_ResultRow, 1, 1, 0}
1365: };
1366: int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
1367: sqlite3VdbeChangeP1(v, addr, iDb);
1368: sqlite3VdbeChangeP1(v, addr+1, iDb);
1369: sqlite3VdbeChangeP3(v, addr+1, iCookie);
1370: sqlite3VdbeSetNumCols(v, 1);
1371: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
1372: }
1373: }else
1374: #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
1375:
1376: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1377: /*
1378: ** PRAGMA compile_options
1379: **
1380: ** Return the names of all compile-time options used in this build,
1381: ** one option per row.
1382: */
1383: if( sqlite3StrICmp(zLeft, "compile_options")==0 ){
1384: int i = 0;
1385: const char *zOpt;
1386: sqlite3VdbeSetNumCols(v, 1);
1387: pParse->nMem = 1;
1388: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "compile_option", SQLITE_STATIC);
1389: while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){
1390: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zOpt, 0);
1391: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1392: }
1393: }else
1394: #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1395:
1396: #ifndef SQLITE_OMIT_WAL
1397: /*
1398: ** PRAGMA [database.]wal_checkpoint = passive|full|restart
1399: **
1400: ** Checkpoint the database.
1401: */
1402: if( sqlite3StrICmp(zLeft, "wal_checkpoint")==0 ){
1403: int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
1404: int eMode = SQLITE_CHECKPOINT_PASSIVE;
1405: if( zRight ){
1406: if( sqlite3StrICmp(zRight, "full")==0 ){
1407: eMode = SQLITE_CHECKPOINT_FULL;
1408: }else if( sqlite3StrICmp(zRight, "restart")==0 ){
1409: eMode = SQLITE_CHECKPOINT_RESTART;
1410: }
1411: }
1412: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1413: sqlite3VdbeSetNumCols(v, 3);
1414: pParse->nMem = 3;
1415: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "busy", SQLITE_STATIC);
1416: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLITE_STATIC);
1417: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "checkpointed", SQLITE_STATIC);
1418:
1419: sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
1420: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1421: }else
1422:
1423: /*
1424: ** PRAGMA wal_autocheckpoint
1425: ** PRAGMA wal_autocheckpoint = N
1426: **
1427: ** Configure a database connection to automatically checkpoint a database
1428: ** after accumulating N frames in the log. Or query for the current value
1429: ** of N.
1430: */
1431: if( sqlite3StrICmp(zLeft, "wal_autocheckpoint")==0 ){
1432: if( zRight ){
1433: sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight));
1434: }
1435: returnSingleInt(pParse, "wal_autocheckpoint",
1436: db->xWalCallback==sqlite3WalDefaultHook ?
1437: SQLITE_PTR_TO_INT(db->pWalArg) : 0);
1438: }else
1439: #endif
1440:
1441: /*
1442: ** PRAGMA shrink_memory
1443: **
1444: ** This pragma attempts to free as much memory as possible from the
1445: ** current database connection.
1446: */
1447: if( sqlite3StrICmp(zLeft, "shrink_memory")==0 ){
1448: sqlite3_db_release_memory(db);
1449: }else
1450:
1451: #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
1452: /*
1453: ** Report the current state of file logs for all databases
1454: */
1455: if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
1456: static const char *const azLockName[] = {
1457: "unlocked", "shared", "reserved", "pending", "exclusive"
1458: };
1459: int i;
1460: sqlite3VdbeSetNumCols(v, 2);
1461: pParse->nMem = 2;
1462: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", SQLITE_STATIC);
1463: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", SQLITE_STATIC);
1464: for(i=0; i<db->nDb; i++){
1465: Btree *pBt;
1466: Pager *pPager;
1467: const char *zState = "unknown";
1468: int j;
1469: if( db->aDb[i].zName==0 ) continue;
1470: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
1471: pBt = db->aDb[i].pBt;
1472: if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
1473: zState = "closed";
1474: }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
1475: SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
1476: zState = azLockName[j];
1477: }
1478: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
1479: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
1480: }
1481:
1482: }else
1483: #endif
1484:
1485: #ifdef SQLITE_HAS_CODEC
1486: if( sqlite3StrICmp(zLeft, "key")==0 && zRight ){
1487: sqlite3_key(db, zRight, sqlite3Strlen30(zRight));
1488: }else
1489: if( sqlite3StrICmp(zLeft, "rekey")==0 && zRight ){
1490: sqlite3_rekey(db, zRight, sqlite3Strlen30(zRight));
1491: }else
1492: if( zRight && (sqlite3StrICmp(zLeft, "hexkey")==0 ||
1493: sqlite3StrICmp(zLeft, "hexrekey")==0) ){
1494: int i, h1, h2;
1495: char zKey[40];
1496: for(i=0; (h1 = zRight[i])!=0 && (h2 = zRight[i+1])!=0; i+=2){
1497: h1 += 9*(1&(h1>>6));
1498: h2 += 9*(1&(h2>>6));
1499: zKey[i/2] = (h2 & 0x0f) | ((h1 & 0xf)<<4);
1500: }
1501: if( (zLeft[3] & 0xf)==0xb ){
1502: sqlite3_key(db, zKey, i/2);
1503: }else{
1504: sqlite3_rekey(db, zKey, i/2);
1505: }
1506: }else
1507: #endif
1508: #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)
1509: if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){
1510: #ifdef SQLITE_HAS_CODEC
1511: if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
1512: sqlite3_activate_see(&zRight[4]);
1513: }
1514: #endif
1515: #ifdef SQLITE_ENABLE_CEROD
1516: if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
1517: sqlite3_activate_cerod(&zRight[6]);
1518: }
1519: #endif
1520: }else
1521: #endif
1522:
1523:
1524: {/* Empty ELSE clause */}
1525:
1526: /*
1527: ** Reset the safety level, in case the fullfsync flag or synchronous
1528: ** setting changed.
1529: */
1530: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
1531: if( db->autoCommit ){
1532: sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
1533: (db->flags&SQLITE_FullFSync)!=0,
1534: (db->flags&SQLITE_CkptFullFSync)!=0);
1535: }
1536: #endif
1537: pragma_out:
1538: sqlite3DbFree(db, zLeft);
1539: sqlite3DbFree(db, zRight);
1540: }
1541:
1542: #endif /* SQLITE_OMIT_PRAGMA */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pragma.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src