Mercurial > audlegacy
comparison sqlite/pragma.c @ 1434:b6b61becdf4e trunk
[svn] - add sqlite/ directory
author | nenolod |
---|---|
date | Thu, 27 Jul 2006 22:41:31 -0700 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
1433:3cbe3d14ea68 | 1434:b6b61becdf4e |
---|---|
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 ** $Id: pragma.c,v 1.120 2006/03/03 21:20:17 drh Exp $ | |
15 */ | |
16 #include "sqliteInt.h" | |
17 #include "os.h" | |
18 #include <ctype.h> | |
19 | |
20 /* Ignore this whole file if pragmas are disabled | |
21 */ | |
22 #if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER) | |
23 | |
24 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) | |
25 # include "pager.h" | |
26 # include "btree.h" | |
27 #endif | |
28 | |
29 /* | |
30 ** Interpret the given string as a safety level. Return 0 for OFF, | |
31 ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or | |
32 ** unrecognized string argument. | |
33 ** | |
34 ** Note that the values returned are one less that the values that | |
35 ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done | |
36 ** to support legacy SQL code. The safety level used to be boolean | |
37 ** and older scripts may have used numbers 0 for OFF and 1 for ON. | |
38 */ | |
39 static int getSafetyLevel(const char *z){ | |
40 /* 123456789 123456789 */ | |
41 static const char zText[] = "onoffalseyestruefull"; | |
42 static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16}; | |
43 static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4}; | |
44 static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2}; | |
45 int i, n; | |
46 if( isdigit(*z) ){ | |
47 return atoi(z); | |
48 } | |
49 n = strlen(z); | |
50 for(i=0; i<sizeof(iLength); i++){ | |
51 if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){ | |
52 return iValue[i]; | |
53 } | |
54 } | |
55 return 1; | |
56 } | |
57 | |
58 /* | |
59 ** Interpret the given string as a boolean value. | |
60 */ | |
61 static int getBoolean(const char *z){ | |
62 return getSafetyLevel(z)&1; | |
63 } | |
64 | |
65 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
66 /* | |
67 ** Interpret the given string as a temp db location. Return 1 for file | |
68 ** backed temporary databases, 2 for the Red-Black tree in memory database | |
69 ** and 0 to use the compile-time default. | |
70 */ | |
71 static int getTempStore(const char *z){ | |
72 if( z[0]>='0' && z[0]<='2' ){ | |
73 return z[0] - '0'; | |
74 }else if( sqlite3StrICmp(z, "file")==0 ){ | |
75 return 1; | |
76 }else if( sqlite3StrICmp(z, "memory")==0 ){ | |
77 return 2; | |
78 }else{ | |
79 return 0; | |
80 } | |
81 } | |
82 #endif /* SQLITE_PAGER_PRAGMAS */ | |
83 | |
84 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
85 /* | |
86 ** Invalidate temp storage, either when the temp storage is changed | |
87 ** from default, or when 'file' and the temp_store_directory has changed | |
88 */ | |
89 static int invalidateTempStorage(Parse *pParse){ | |
90 sqlite3 *db = pParse->db; | |
91 if( db->aDb[1].pBt!=0 ){ | |
92 if( db->flags & SQLITE_InTrans ){ | |
93 sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " | |
94 "from within a transaction"); | |
95 return SQLITE_ERROR; | |
96 } | |
97 sqlite3BtreeClose(db->aDb[1].pBt); | |
98 db->aDb[1].pBt = 0; | |
99 sqlite3ResetInternalSchema(db, 0); | |
100 } | |
101 return SQLITE_OK; | |
102 } | |
103 #endif /* SQLITE_PAGER_PRAGMAS */ | |
104 | |
105 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
106 /* | |
107 ** If the TEMP database is open, close it and mark the database schema | |
108 ** as needing reloading. This must be done when using the TEMP_STORE | |
109 ** or DEFAULT_TEMP_STORE pragmas. | |
110 */ | |
111 static int changeTempStorage(Parse *pParse, const char *zStorageType){ | |
112 int ts = getTempStore(zStorageType); | |
113 sqlite3 *db = pParse->db; | |
114 if( db->temp_store==ts ) return SQLITE_OK; | |
115 if( invalidateTempStorage( pParse ) != SQLITE_OK ){ | |
116 return SQLITE_ERROR; | |
117 } | |
118 db->temp_store = ts; | |
119 return SQLITE_OK; | |
120 } | |
121 #endif /* SQLITE_PAGER_PRAGMAS */ | |
122 | |
123 /* | |
124 ** Generate code to return a single integer value. | |
125 */ | |
126 static void returnSingleInt(Parse *pParse, const char *zLabel, int value){ | |
127 Vdbe *v = sqlite3GetVdbe(pParse); | |
128 sqlite3VdbeAddOp(v, OP_Integer, value, 0); | |
129 if( pParse->explain==0 ){ | |
130 sqlite3VdbeSetNumCols(v, 1); | |
131 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P3_STATIC); | |
132 } | |
133 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); | |
134 } | |
135 | |
136 #ifndef SQLITE_OMIT_FLAG_PRAGMAS | |
137 /* | |
138 ** Check to see if zRight and zLeft refer to a pragma that queries | |
139 ** or changes one of the flags in db->flags. Return 1 if so and 0 if not. | |
140 ** Also, implement the pragma. | |
141 */ | |
142 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){ | |
143 static const struct sPragmaType { | |
144 const char *zName; /* Name of the pragma */ | |
145 int mask; /* Mask for the db->flags value */ | |
146 } aPragma[] = { | |
147 { "vdbe_trace", SQLITE_VdbeTrace }, | |
148 { "sql_trace", SQLITE_SqlTrace }, | |
149 { "vdbe_listing", SQLITE_VdbeListing }, | |
150 { "full_column_names", SQLITE_FullColNames }, | |
151 { "short_column_names", SQLITE_ShortColNames }, | |
152 { "count_changes", SQLITE_CountRows }, | |
153 { "empty_result_callbacks", SQLITE_NullCallback }, | |
154 { "legacy_file_format", SQLITE_LegacyFileFmt }, | |
155 { "fullfsync", SQLITE_FullFSync }, | |
156 #ifndef SQLITE_OMIT_CHECK | |
157 { "ignore_check_constraints", SQLITE_IgnoreChecks }, | |
158 #endif | |
159 /* The following is VERY experimental */ | |
160 { "writable_schema", SQLITE_WriteSchema }, | |
161 { "omit_readlock", SQLITE_NoReadlock }, | |
162 | |
163 /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted | |
164 ** flag if there are any active statements. */ | |
165 { "read_uncommitted", SQLITE_ReadUncommitted }, | |
166 }; | |
167 int i; | |
168 const struct sPragmaType *p; | |
169 for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){ | |
170 if( sqlite3StrICmp(zLeft, p->zName)==0 ){ | |
171 sqlite3 *db = pParse->db; | |
172 Vdbe *v; | |
173 v = sqlite3GetVdbe(pParse); | |
174 if( v ){ | |
175 if( zRight==0 ){ | |
176 returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 ); | |
177 }else{ | |
178 if( getBoolean(zRight) ){ | |
179 db->flags |= p->mask; | |
180 }else{ | |
181 db->flags &= ~p->mask; | |
182 } | |
183 } | |
184 } | |
185 return 1; | |
186 } | |
187 } | |
188 return 0; | |
189 } | |
190 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */ | |
191 | |
192 /* | |
193 ** Process a pragma statement. | |
194 ** | |
195 ** Pragmas are of this form: | |
196 ** | |
197 ** PRAGMA [database.]id [= value] | |
198 ** | |
199 ** The identifier might also be a string. The value is a string, and | |
200 ** identifier, or a number. If minusFlag is true, then the value is | |
201 ** a number that was preceded by a minus sign. | |
202 ** | |
203 ** If the left side is "database.id" then pId1 is the database name | |
204 ** and pId2 is the id. If the left side is just "id" then pId1 is the | |
205 ** id and pId2 is any empty string. | |
206 */ | |
207 void sqlite3Pragma( | |
208 Parse *pParse, | |
209 Token *pId1, /* First part of [database.]id field */ | |
210 Token *pId2, /* Second part of [database.]id field, or NULL */ | |
211 Token *pValue, /* Token for <value>, or NULL */ | |
212 int minusFlag /* True if a '-' sign preceded <value> */ | |
213 ){ | |
214 char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */ | |
215 char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */ | |
216 const char *zDb = 0; /* The database name */ | |
217 Token *pId; /* Pointer to <id> token */ | |
218 int iDb; /* Database index for <database> */ | |
219 sqlite3 *db = pParse->db; | |
220 Db *pDb; | |
221 Vdbe *v = sqlite3GetVdbe(pParse); | |
222 if( v==0 ) return; | |
223 | |
224 /* Interpret the [database.] part of the pragma statement. iDb is the | |
225 ** index of the database this pragma is being applied to in db.aDb[]. */ | |
226 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); | |
227 if( iDb<0 ) return; | |
228 pDb = &db->aDb[iDb]; | |
229 | |
230 /* If the temp database has been explicitly named as part of the | |
231 ** pragma, make sure it is open. | |
232 */ | |
233 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ | |
234 return; | |
235 } | |
236 | |
237 zLeft = sqlite3NameFromToken(pId); | |
238 if( !zLeft ) return; | |
239 if( minusFlag ){ | |
240 zRight = sqlite3MPrintf("-%T", pValue); | |
241 }else{ | |
242 zRight = sqlite3NameFromToken(pValue); | |
243 } | |
244 | |
245 zDb = ((iDb>0)?pDb->zName:0); | |
246 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ | |
247 goto pragma_out; | |
248 } | |
249 | |
250 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
251 /* | |
252 ** PRAGMA [database.]default_cache_size | |
253 ** PRAGMA [database.]default_cache_size=N | |
254 ** | |
255 ** The first form reports the current persistent setting for the | |
256 ** page cache size. The value returned is the maximum number of | |
257 ** pages in the page cache. The second form sets both the current | |
258 ** page cache size value and the persistent page cache size value | |
259 ** stored in the database file. | |
260 ** | |
261 ** The default cache size is stored in meta-value 2 of page 1 of the | |
262 ** database file. The cache size is actually the absolute value of | |
263 ** this memory location. The sign of meta-value 2 determines the | |
264 ** synchronous setting. A negative value means synchronous is off | |
265 ** and a positive value means synchronous is on. | |
266 */ | |
267 if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){ | |
268 static const VdbeOpList getCacheSize[] = { | |
269 { OP_ReadCookie, 0, 2, 0}, /* 0 */ | |
270 { OP_AbsValue, 0, 0, 0}, | |
271 { OP_Dup, 0, 0, 0}, | |
272 { OP_Integer, 0, 0, 0}, | |
273 { OP_Ne, 0, 6, 0}, | |
274 { OP_Integer, 0, 0, 0}, /* 5 */ | |
275 { OP_Callback, 1, 0, 0}, | |
276 }; | |
277 int addr; | |
278 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
279 if( !zRight ){ | |
280 sqlite3VdbeSetNumCols(v, 1); | |
281 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P3_STATIC); | |
282 addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); | |
283 sqlite3VdbeChangeP1(v, addr, iDb); | |
284 sqlite3VdbeChangeP1(v, addr+5, MAX_PAGES); | |
285 }else{ | |
286 int size = atoi(zRight); | |
287 if( size<0 ) size = -size; | |
288 sqlite3BeginWriteOperation(pParse, 0, iDb); | |
289 sqlite3VdbeAddOp(v, OP_Integer, size, 0); | |
290 sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2); | |
291 addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0); | |
292 sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3); | |
293 sqlite3VdbeAddOp(v, OP_Negative, 0, 0); | |
294 sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2); | |
295 pDb->pSchema->cache_size = size; | |
296 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); | |
297 } | |
298 }else | |
299 | |
300 /* | |
301 ** PRAGMA [database.]page_size | |
302 ** PRAGMA [database.]page_size=N | |
303 ** | |
304 ** The first form reports the current setting for the | |
305 ** database page size in bytes. The second form sets the | |
306 ** database page size value. The value can only be set if | |
307 ** the database has not yet been created. | |
308 */ | |
309 if( sqlite3StrICmp(zLeft,"page_size")==0 ){ | |
310 Btree *pBt = pDb->pBt; | |
311 if( !zRight ){ | |
312 int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0; | |
313 returnSingleInt(pParse, "page_size", size); | |
314 }else{ | |
315 sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1); | |
316 } | |
317 }else | |
318 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */ | |
319 | |
320 /* | |
321 ** PRAGMA [database.]auto_vacuum | |
322 ** PRAGMA [database.]auto_vacuum=N | |
323 ** | |
324 ** Get or set the (boolean) value of the database 'auto-vacuum' parameter. | |
325 */ | |
326 #ifndef SQLITE_OMIT_AUTOVACUUM | |
327 if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){ | |
328 Btree *pBt = pDb->pBt; | |
329 if( !zRight ){ | |
330 int auto_vacuum = | |
331 pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM; | |
332 returnSingleInt(pParse, "auto_vacuum", auto_vacuum); | |
333 }else{ | |
334 sqlite3BtreeSetAutoVacuum(pBt, getBoolean(zRight)); | |
335 } | |
336 }else | |
337 #endif | |
338 | |
339 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
340 /* | |
341 ** PRAGMA [database.]cache_size | |
342 ** PRAGMA [database.]cache_size=N | |
343 ** | |
344 ** The first form reports the current local setting for the | |
345 ** page cache size. The local setting can be different from | |
346 ** the persistent cache size value that is stored in the database | |
347 ** file itself. The value returned is the maximum number of | |
348 ** pages in the page cache. The second form sets the local | |
349 ** page cache size value. It does not change the persistent | |
350 ** cache size stored on the disk so the cache size will revert | |
351 ** to its default value when the database is closed and reopened. | |
352 ** N should be a positive integer. | |
353 */ | |
354 if( sqlite3StrICmp(zLeft,"cache_size")==0 ){ | |
355 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
356 if( !zRight ){ | |
357 returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size); | |
358 }else{ | |
359 int size = atoi(zRight); | |
360 if( size<0 ) size = -size; | |
361 pDb->pSchema->cache_size = size; | |
362 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); | |
363 } | |
364 }else | |
365 | |
366 /* | |
367 ** PRAGMA temp_store | |
368 ** PRAGMA temp_store = "default"|"memory"|"file" | |
369 ** | |
370 ** Return or set the local value of the temp_store flag. Changing | |
371 ** the local value does not make changes to the disk file and the default | |
372 ** value will be restored the next time the database is opened. | |
373 ** | |
374 ** Note that it is possible for the library compile-time options to | |
375 ** override this setting | |
376 */ | |
377 if( sqlite3StrICmp(zLeft, "temp_store")==0 ){ | |
378 if( !zRight ){ | |
379 returnSingleInt(pParse, "temp_store", db->temp_store); | |
380 }else{ | |
381 changeTempStorage(pParse, zRight); | |
382 } | |
383 }else | |
384 | |
385 /* | |
386 ** PRAGMA temp_store_directory | |
387 ** PRAGMA temp_store_directory = ""|"directory_name" | |
388 ** | |
389 ** Return or set the local value of the temp_store_directory flag. Changing | |
390 ** the value sets a specific directory to be used for temporary files. | |
391 ** Setting to a null string reverts to the default temporary directory search. | |
392 ** If temporary directory is changed, then invalidateTempStorage. | |
393 ** | |
394 */ | |
395 if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){ | |
396 if( !zRight ){ | |
397 if( sqlite3_temp_directory ){ | |
398 sqlite3VdbeSetNumCols(v, 1); | |
399 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, | |
400 "temp_store_directory", P3_STATIC); | |
401 sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0); | |
402 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); | |
403 } | |
404 }else{ | |
405 if( zRight[0] && !sqlite3OsIsDirWritable(zRight) ){ | |
406 sqlite3ErrorMsg(pParse, "not a writable directory"); | |
407 goto pragma_out; | |
408 } | |
409 if( TEMP_STORE==0 | |
410 || (TEMP_STORE==1 && db->temp_store<=1) | |
411 || (TEMP_STORE==2 && db->temp_store==1) | |
412 ){ | |
413 invalidateTempStorage(pParse); | |
414 } | |
415 sqliteFree(sqlite3_temp_directory); | |
416 if( zRight[0] ){ | |
417 sqlite3_temp_directory = zRight; | |
418 zRight = 0; | |
419 }else{ | |
420 sqlite3_temp_directory = 0; | |
421 } | |
422 } | |
423 }else | |
424 | |
425 /* | |
426 ** PRAGMA [database.]synchronous | |
427 ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL | |
428 ** | |
429 ** Return or set the local value of the synchronous flag. Changing | |
430 ** the local value does not make changes to the disk file and the | |
431 ** default value will be restored the next time the database is | |
432 ** opened. | |
433 */ | |
434 if( sqlite3StrICmp(zLeft,"synchronous")==0 ){ | |
435 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
436 if( !zRight ){ | |
437 returnSingleInt(pParse, "synchronous", pDb->safety_level-1); | |
438 }else{ | |
439 if( !db->autoCommit ){ | |
440 sqlite3ErrorMsg(pParse, | |
441 "Safety level may not be changed inside a transaction"); | |
442 }else{ | |
443 pDb->safety_level = getSafetyLevel(zRight)+1; | |
444 } | |
445 } | |
446 }else | |
447 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */ | |
448 | |
449 #ifndef SQLITE_OMIT_FLAG_PRAGMAS | |
450 if( flagPragma(pParse, zLeft, zRight) ){ | |
451 /* The flagPragma() subroutine also generates any necessary code | |
452 ** there is nothing more to do here */ | |
453 }else | |
454 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */ | |
455 | |
456 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS | |
457 /* | |
458 ** PRAGMA table_info(<table>) | |
459 ** | |
460 ** Return a single row for each column of the named table. The columns of | |
461 ** the returned data set are: | |
462 ** | |
463 ** cid: Column id (numbered from left to right, starting at 0) | |
464 ** name: Column name | |
465 ** type: Column declaration type. | |
466 ** notnull: True if 'NOT NULL' is part of column declaration | |
467 ** dflt_value: The default value for the column, if any. | |
468 */ | |
469 if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){ | |
470 Table *pTab; | |
471 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
472 pTab = sqlite3FindTable(db, zRight, zDb); | |
473 if( pTab ){ | |
474 int i; | |
475 Column *pCol; | |
476 sqlite3VdbeSetNumCols(v, 6); | |
477 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P3_STATIC); | |
478 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); | |
479 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P3_STATIC); | |
480 sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P3_STATIC); | |
481 sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P3_STATIC); | |
482 sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P3_STATIC); | |
483 sqlite3ViewGetColumnNames(pParse, pTab); | |
484 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){ | |
485 sqlite3VdbeAddOp(v, OP_Integer, i, 0); | |
486 sqlite3VdbeOp3(v, OP_String8, 0, 0, pCol->zName, 0); | |
487 sqlite3VdbeOp3(v, OP_String8, 0, 0, | |
488 pCol->zType ? pCol->zType : "", 0); | |
489 sqlite3VdbeAddOp(v, OP_Integer, pCol->notNull, 0); | |
490 sqlite3ExprCode(pParse, pCol->pDflt); | |
491 sqlite3VdbeAddOp(v, OP_Integer, pCol->isPrimKey, 0); | |
492 sqlite3VdbeAddOp(v, OP_Callback, 6, 0); | |
493 } | |
494 } | |
495 }else | |
496 | |
497 if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){ | |
498 Index *pIdx; | |
499 Table *pTab; | |
500 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
501 pIdx = sqlite3FindIndex(db, zRight, zDb); | |
502 if( pIdx ){ | |
503 int i; | |
504 pTab = pIdx->pTable; | |
505 sqlite3VdbeSetNumCols(v, 3); | |
506 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P3_STATIC); | |
507 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P3_STATIC); | |
508 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P3_STATIC); | |
509 for(i=0; i<pIdx->nColumn; i++){ | |
510 int cnum = pIdx->aiColumn[i]; | |
511 sqlite3VdbeAddOp(v, OP_Integer, i, 0); | |
512 sqlite3VdbeAddOp(v, OP_Integer, cnum, 0); | |
513 assert( pTab->nCol>cnum ); | |
514 sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0); | |
515 sqlite3VdbeAddOp(v, OP_Callback, 3, 0); | |
516 } | |
517 } | |
518 }else | |
519 | |
520 if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){ | |
521 Index *pIdx; | |
522 Table *pTab; | |
523 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
524 pTab = sqlite3FindTable(db, zRight, zDb); | |
525 if( pTab ){ | |
526 v = sqlite3GetVdbe(pParse); | |
527 pIdx = pTab->pIndex; | |
528 if( pIdx ){ | |
529 int i = 0; | |
530 sqlite3VdbeSetNumCols(v, 3); | |
531 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); | |
532 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); | |
533 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P3_STATIC); | |
534 while(pIdx){ | |
535 sqlite3VdbeAddOp(v, OP_Integer, i, 0); | |
536 sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0); | |
537 sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0); | |
538 sqlite3VdbeAddOp(v, OP_Callback, 3, 0); | |
539 ++i; | |
540 pIdx = pIdx->pNext; | |
541 } | |
542 } | |
543 } | |
544 }else | |
545 | |
546 if( sqlite3StrICmp(zLeft, "database_list")==0 ){ | |
547 int i; | |
548 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
549 sqlite3VdbeSetNumCols(v, 3); | |
550 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); | |
551 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); | |
552 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P3_STATIC); | |
553 for(i=0; i<db->nDb; i++){ | |
554 if( db->aDb[i].pBt==0 ) continue; | |
555 assert( db->aDb[i].zName!=0 ); | |
556 sqlite3VdbeAddOp(v, OP_Integer, i, 0); | |
557 sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0); | |
558 sqlite3VdbeOp3(v, OP_String8, 0, 0, | |
559 sqlite3BtreeGetFilename(db->aDb[i].pBt), 0); | |
560 sqlite3VdbeAddOp(v, OP_Callback, 3, 0); | |
561 } | |
562 }else | |
563 | |
564 if( sqlite3StrICmp(zLeft, "collation_list")==0 ){ | |
565 int i = 0; | |
566 HashElem *p; | |
567 sqlite3VdbeSetNumCols(v, 2); | |
568 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); | |
569 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); | |
570 for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ | |
571 CollSeq *pColl = (CollSeq *)sqliteHashData(p); | |
572 sqlite3VdbeAddOp(v, OP_Integer, i++, 0); | |
573 sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0); | |
574 sqlite3VdbeAddOp(v, OP_Callback, 2, 0); | |
575 } | |
576 }else | |
577 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */ | |
578 | |
579 #ifndef SQLITE_OMIT_FOREIGN_KEY | |
580 if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){ | |
581 FKey *pFK; | |
582 Table *pTab; | |
583 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
584 pTab = sqlite3FindTable(db, zRight, zDb); | |
585 if( pTab ){ | |
586 v = sqlite3GetVdbe(pParse); | |
587 pFK = pTab->pFKey; | |
588 if( pFK ){ | |
589 int i = 0; | |
590 sqlite3VdbeSetNumCols(v, 5); | |
591 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P3_STATIC); | |
592 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P3_STATIC); | |
593 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P3_STATIC); | |
594 sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P3_STATIC); | |
595 sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P3_STATIC); | |
596 while(pFK){ | |
597 int j; | |
598 for(j=0; j<pFK->nCol; j++){ | |
599 char *zCol = pFK->aCol[j].zCol; | |
600 sqlite3VdbeAddOp(v, OP_Integer, i, 0); | |
601 sqlite3VdbeAddOp(v, OP_Integer, j, 0); | |
602 sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0); | |
603 sqlite3VdbeOp3(v, OP_String8, 0, 0, | |
604 pTab->aCol[pFK->aCol[j].iFrom].zName, 0); | |
605 sqlite3VdbeOp3(v, zCol ? OP_String8 : OP_Null, 0, 0, zCol, 0); | |
606 sqlite3VdbeAddOp(v, OP_Callback, 5, 0); | |
607 } | |
608 ++i; | |
609 pFK = pFK->pNextFrom; | |
610 } | |
611 } | |
612 } | |
613 }else | |
614 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ | |
615 | |
616 #ifndef NDEBUG | |
617 if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){ | |
618 extern void sqlite3ParserTrace(FILE*, char *); | |
619 if( zRight ){ | |
620 if( getBoolean(zRight) ){ | |
621 sqlite3ParserTrace(stderr, "parser: "); | |
622 }else{ | |
623 sqlite3ParserTrace(0, 0); | |
624 } | |
625 } | |
626 }else | |
627 #endif | |
628 | |
629 /* Reinstall the LIKE and GLOB functions. The variant of LIKE | |
630 ** used will be case sensitive or not depending on the RHS. | |
631 */ | |
632 if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){ | |
633 if( zRight ){ | |
634 sqlite3RegisterLikeFunctions(db, getBoolean(zRight)); | |
635 } | |
636 }else | |
637 | |
638 #ifndef SQLITE_OMIT_INTEGRITY_CHECK | |
639 if( sqlite3StrICmp(zLeft, "integrity_check")==0 ){ | |
640 int i, j, addr; | |
641 | |
642 /* Code that appears at the end of the integrity check. If no error | |
643 ** messages have been generated, output OK. Otherwise output the | |
644 ** error message | |
645 */ | |
646 static const VdbeOpList endCode[] = { | |
647 { OP_MemLoad, 0, 0, 0}, | |
648 { OP_Integer, 0, 0, 0}, | |
649 { OP_Ne, 0, 0, 0}, /* 2 */ | |
650 { OP_String8, 0, 0, "ok"}, | |
651 { OP_Callback, 1, 0, 0}, | |
652 }; | |
653 | |
654 /* Initialize the VDBE program */ | |
655 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
656 sqlite3VdbeSetNumCols(v, 1); | |
657 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P3_STATIC); | |
658 sqlite3VdbeAddOp(v, OP_MemInt, 0, 0); /* Initialize error count to 0 */ | |
659 | |
660 /* Do an integrity check on each database file */ | |
661 for(i=0; i<db->nDb; i++){ | |
662 HashElem *x; | |
663 Hash *pTbls; | |
664 int cnt = 0; | |
665 | |
666 if( OMIT_TEMPDB && i==1 ) continue; | |
667 | |
668 sqlite3CodeVerifySchema(pParse, i); | |
669 | |
670 /* Do an integrity check of the B-Tree | |
671 */ | |
672 pTbls = &db->aDb[i].pSchema->tblHash; | |
673 for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ | |
674 Table *pTab = sqliteHashData(x); | |
675 Index *pIdx; | |
676 sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0); | |
677 cnt++; | |
678 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ | |
679 sqlite3VdbeAddOp(v, OP_Integer, pIdx->tnum, 0); | |
680 cnt++; | |
681 } | |
682 } | |
683 assert( cnt>0 ); | |
684 sqlite3VdbeAddOp(v, OP_IntegrityCk, cnt, i); | |
685 sqlite3VdbeAddOp(v, OP_Dup, 0, 1); | |
686 addr = sqlite3VdbeOp3(v, OP_String8, 0, 0, "ok", P3_STATIC); | |
687 sqlite3VdbeAddOp(v, OP_Eq, 0, addr+7); | |
688 sqlite3VdbeOp3(v, OP_String8, 0, 0, | |
689 sqlite3MPrintf("*** in database %s ***\n", db->aDb[i].zName), | |
690 P3_DYNAMIC); | |
691 sqlite3VdbeAddOp(v, OP_Pull, 1, 0); | |
692 sqlite3VdbeAddOp(v, OP_Concat, 0, 1); | |
693 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); | |
694 sqlite3VdbeAddOp(v, OP_MemIncr, 1, 0); | |
695 | |
696 /* Make sure all the indices are constructed correctly. | |
697 */ | |
698 sqlite3CodeVerifySchema(pParse, i); | |
699 for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ | |
700 Table *pTab = sqliteHashData(x); | |
701 Index *pIdx; | |
702 int loopTop; | |
703 | |
704 if( pTab->pIndex==0 ) continue; | |
705 sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead); | |
706 sqlite3VdbeAddOp(v, OP_MemInt, 0, 1); | |
707 loopTop = sqlite3VdbeAddOp(v, OP_Rewind, 1, 0); | |
708 sqlite3VdbeAddOp(v, OP_MemIncr, 1, 1); | |
709 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ | |
710 int jmp2; | |
711 static const VdbeOpList idxErr[] = { | |
712 { OP_MemIncr, 1, 0, 0}, | |
713 { OP_String8, 0, 0, "rowid "}, | |
714 { OP_Rowid, 1, 0, 0}, | |
715 { OP_String8, 0, 0, " missing from index "}, | |
716 { OP_String8, 0, 0, 0}, /* 4 */ | |
717 { OP_Concat, 2, 0, 0}, | |
718 { OP_Callback, 1, 0, 0}, | |
719 }; | |
720 sqlite3GenerateIndexKey(v, pIdx, 1); | |
721 jmp2 = sqlite3VdbeAddOp(v, OP_Found, j+2, 0); | |
722 addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr); | |
723 sqlite3VdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC); | |
724 sqlite3VdbeJumpHere(v, jmp2); | |
725 } | |
726 sqlite3VdbeAddOp(v, OP_Next, 1, loopTop+1); | |
727 sqlite3VdbeJumpHere(v, loopTop); | |
728 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ | |
729 static const VdbeOpList cntIdx[] = { | |
730 { OP_MemInt, 0, 2, 0}, | |
731 { OP_Rewind, 0, 0, 0}, /* 1 */ | |
732 { OP_MemIncr, 1, 2, 0}, | |
733 { OP_Next, 0, 0, 0}, /* 3 */ | |
734 { OP_MemLoad, 1, 0, 0}, | |
735 { OP_MemLoad, 2, 0, 0}, | |
736 { OP_Eq, 0, 0, 0}, /* 6 */ | |
737 { OP_MemIncr, 1, 0, 0}, | |
738 { OP_String8, 0, 0, "wrong # of entries in index "}, | |
739 { OP_String8, 0, 0, 0}, /* 9 */ | |
740 { OP_Concat, 0, 0, 0}, | |
741 { OP_Callback, 1, 0, 0}, | |
742 }; | |
743 if( pIdx->tnum==0 ) continue; | |
744 addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx); | |
745 sqlite3VdbeChangeP1(v, addr+1, j+2); | |
746 sqlite3VdbeChangeP2(v, addr+1, addr+4); | |
747 sqlite3VdbeChangeP1(v, addr+3, j+2); | |
748 sqlite3VdbeChangeP2(v, addr+3, addr+2); | |
749 sqlite3VdbeJumpHere(v, addr+6); | |
750 sqlite3VdbeChangeP3(v, addr+9, pIdx->zName, P3_STATIC); | |
751 } | |
752 } | |
753 } | |
754 addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode); | |
755 sqlite3VdbeJumpHere(v, addr+2); | |
756 }else | |
757 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ | |
758 | |
759 #ifndef SQLITE_OMIT_UTF16 | |
760 /* | |
761 ** PRAGMA encoding | |
762 ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" | |
763 ** | |
764 ** In it's first form, this pragma returns the encoding of the main | |
765 ** database. If the database is not initialized, it is initialized now. | |
766 ** | |
767 ** The second form of this pragma is a no-op if the main database file | |
768 ** has not already been initialized. In this case it sets the default | |
769 ** encoding that will be used for the main database file if a new file | |
770 ** is created. If an existing main database file is opened, then the | |
771 ** default text encoding for the existing database is used. | |
772 ** | |
773 ** In all cases new databases created using the ATTACH command are | |
774 ** created to use the same default text encoding as the main database. If | |
775 ** the main database has not been initialized and/or created when ATTACH | |
776 ** is executed, this is done before the ATTACH operation. | |
777 ** | |
778 ** In the second form this pragma sets the text encoding to be used in | |
779 ** new database files created using this database handle. It is only | |
780 ** useful if invoked immediately after the main database i | |
781 */ | |
782 if( sqlite3StrICmp(zLeft, "encoding")==0 ){ | |
783 static struct EncName { | |
784 char *zName; | |
785 u8 enc; | |
786 } encnames[] = { | |
787 { "UTF-8", SQLITE_UTF8 }, | |
788 { "UTF8", SQLITE_UTF8 }, | |
789 { "UTF-16le", SQLITE_UTF16LE }, | |
790 { "UTF16le", SQLITE_UTF16LE }, | |
791 { "UTF-16be", SQLITE_UTF16BE }, | |
792 { "UTF16be", SQLITE_UTF16BE }, | |
793 { "UTF-16", 0 /* Filled in at run-time */ }, | |
794 { "UTF16", 0 /* Filled in at run-time */ }, | |
795 { 0, 0 } | |
796 }; | |
797 struct EncName *pEnc; | |
798 encnames[6].enc = encnames[7].enc = SQLITE_UTF16NATIVE; | |
799 if( !zRight ){ /* "PRAGMA encoding" */ | |
800 if( sqlite3ReadSchema(pParse) ) goto pragma_out; | |
801 sqlite3VdbeSetNumCols(v, 1); | |
802 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P3_STATIC); | |
803 sqlite3VdbeAddOp(v, OP_String8, 0, 0); | |
804 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ | |
805 if( pEnc->enc==ENC(pParse->db) ){ | |
806 sqlite3VdbeChangeP3(v, -1, pEnc->zName, P3_STATIC); | |
807 break; | |
808 } | |
809 } | |
810 sqlite3VdbeAddOp(v, OP_Callback, 1, 0); | |
811 }else{ /* "PRAGMA encoding = XXX" */ | |
812 /* Only change the value of sqlite.enc if the database handle is not | |
813 ** initialized. If the main database exists, the new sqlite.enc value | |
814 ** will be overwritten when the schema is next loaded. If it does not | |
815 ** already exists, it will be created to use the new encoding value. | |
816 */ | |
817 if( | |
818 !(DbHasProperty(db, 0, DB_SchemaLoaded)) || | |
819 DbHasProperty(db, 0, DB_Empty) | |
820 ){ | |
821 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ | |
822 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ | |
823 ENC(pParse->db) = pEnc->enc; | |
824 break; | |
825 } | |
826 } | |
827 if( !pEnc->zName ){ | |
828 sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); | |
829 } | |
830 } | |
831 } | |
832 }else | |
833 #endif /* SQLITE_OMIT_UTF16 */ | |
834 | |
835 #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS | |
836 /* | |
837 ** PRAGMA [database.]schema_version | |
838 ** PRAGMA [database.]schema_version = <integer> | |
839 ** | |
840 ** PRAGMA [database.]user_version | |
841 ** PRAGMA [database.]user_version = <integer> | |
842 ** | |
843 ** The pragma's schema_version and user_version are used to set or get | |
844 ** the value of the schema-version and user-version, respectively. Both | |
845 ** the schema-version and the user-version are 32-bit signed integers | |
846 ** stored in the database header. | |
847 ** | |
848 ** The schema-cookie is usually only manipulated internally by SQLite. It | |
849 ** is incremented by SQLite whenever the database schema is modified (by | |
850 ** creating or dropping a table or index). The schema version is used by | |
851 ** SQLite each time a query is executed to ensure that the internal cache | |
852 ** of the schema used when compiling the SQL query matches the schema of | |
853 ** the database against which the compiled query is actually executed. | |
854 ** Subverting this mechanism by using "PRAGMA schema_version" to modify | |
855 ** the schema-version is potentially dangerous and may lead to program | |
856 ** crashes or database corruption. Use with caution! | |
857 ** | |
858 ** The user-version is not used internally by SQLite. It may be used by | |
859 ** applications for any purpose. | |
860 */ | |
861 if( sqlite3StrICmp(zLeft, "schema_version")==0 || | |
862 sqlite3StrICmp(zLeft, "user_version")==0 ){ | |
863 | |
864 int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */ | |
865 if( zLeft[0]=='s' || zLeft[0]=='S' ){ | |
866 iCookie = 0; | |
867 }else{ | |
868 iCookie = 5; | |
869 } | |
870 | |
871 if( zRight ){ | |
872 /* Write the specified cookie value */ | |
873 static const VdbeOpList setCookie[] = { | |
874 { OP_Transaction, 0, 1, 0}, /* 0 */ | |
875 { OP_Integer, 0, 0, 0}, /* 1 */ | |
876 { OP_SetCookie, 0, 0, 0}, /* 2 */ | |
877 }; | |
878 int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie); | |
879 sqlite3VdbeChangeP1(v, addr, iDb); | |
880 sqlite3VdbeChangeP1(v, addr+1, atoi(zRight)); | |
881 sqlite3VdbeChangeP1(v, addr+2, iDb); | |
882 sqlite3VdbeChangeP2(v, addr+2, iCookie); | |
883 }else{ | |
884 /* Read the specified cookie value */ | |
885 static const VdbeOpList readCookie[] = { | |
886 { OP_ReadCookie, 0, 0, 0}, /* 0 */ | |
887 { OP_Callback, 1, 0, 0} | |
888 }; | |
889 int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie); | |
890 sqlite3VdbeChangeP1(v, addr, iDb); | |
891 sqlite3VdbeChangeP2(v, addr, iCookie); | |
892 sqlite3VdbeSetNumCols(v, 1); | |
893 } | |
894 } | |
895 #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ | |
896 | |
897 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) | |
898 /* | |
899 ** Report the current state of file logs for all databases | |
900 */ | |
901 if( sqlite3StrICmp(zLeft, "lock_status")==0 ){ | |
902 static const char *const azLockName[] = { | |
903 "unlocked", "shared", "reserved", "pending", "exclusive" | |
904 }; | |
905 int i; | |
906 Vdbe *v = sqlite3GetVdbe(pParse); | |
907 sqlite3VdbeSetNumCols(v, 2); | |
908 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P3_STATIC); | |
909 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P3_STATIC); | |
910 for(i=0; i<db->nDb; i++){ | |
911 Btree *pBt; | |
912 Pager *pPager; | |
913 if( db->aDb[i].zName==0 ) continue; | |
914 sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, P3_STATIC); | |
915 pBt = db->aDb[i].pBt; | |
916 if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){ | |
917 sqlite3VdbeOp3(v, OP_String8, 0, 0, "closed", P3_STATIC); | |
918 }else{ | |
919 int j = sqlite3pager_lockstate(pPager); | |
920 sqlite3VdbeOp3(v, OP_String8, 0, 0, | |
921 (j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC); | |
922 } | |
923 sqlite3VdbeAddOp(v, OP_Callback, 2, 0); | |
924 } | |
925 }else | |
926 #endif | |
927 | |
928 #ifdef SQLITE_SSE | |
929 /* | |
930 ** Check to see if the sqlite_statements table exists. Create it | |
931 ** if it does not. | |
932 */ | |
933 if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){ | |
934 extern int sqlite3CreateStatementsTable(Parse*); | |
935 sqlite3CreateStatementsTable(pParse); | |
936 }else | |
937 #endif | |
938 | |
939 #if SQLITE_HAS_CODEC | |
940 if( sqlite3StrICmp(zLeft, "key")==0 ){ | |
941 sqlite3_key(db, zRight, strlen(zRight)); | |
942 }else | |
943 #endif | |
944 | |
945 {} | |
946 | |
947 if( v ){ | |
948 /* Code an OP_Expire at the end of each PRAGMA program to cause | |
949 ** the VDBE implementing the pragma to expire. Most (all?) pragmas | |
950 ** are only valid for a single execution. | |
951 */ | |
952 sqlite3VdbeAddOp(v, OP_Expire, 1, 0); | |
953 | |
954 /* | |
955 ** Reset the safety level, in case the fullfsync flag or synchronous | |
956 ** setting changed. | |
957 */ | |
958 #ifndef SQLITE_OMIT_PAGER_PRAGMAS | |
959 if( db->autoCommit ){ | |
960 sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level, | |
961 (db->flags&SQLITE_FullFSync)!=0); | |
962 } | |
963 #endif | |
964 } | |
965 pragma_out: | |
966 sqliteFree(zLeft); | |
967 sqliteFree(zRight); | |
968 } | |
969 | |
970 #endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */ |