?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update mojo sdk to rev 1dc8a9a5db73d3718d99917fadf31f5fb2ebad4f
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / pragma.c
blob543f265ba9ea1ae5e8e0fff897f91f76aa334450
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 #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
17 # if defined(__APPLE__)
18 # define SQLITE_ENABLE_LOCKING_STYLE 1
19 # else
20 # define SQLITE_ENABLE_LOCKING_STYLE 0
21 # endif
22 #endif
23
24 /***************************************************************************
25 ** The next block of code, including the PragTyp_XXXX macro definitions and
26 ** the aPragmaName[] object is composed of generated code. DO NOT EDIT.
27 **
28 ** To add new pragmas, edit the code in ../tool/mkpragmatab.tcl and rerun
29 ** that script. Then copy/paste the output in place of the following:
30 */
31 #define PragTyp_HEADER_VALUE 0
32 #define PragTyp_AUTO_VACUUM 1
33 #define PragTyp_FLAG 2
34 #define PragTyp_BUSY_TIMEOUT 3
35 #define PragTyp_CACHE_SIZE 4
36 #define PragTyp_CASE_SENSITIVE_LIKE 5
37 #define PragTyp_COLLATION_LIST 6
38 #define PragTyp_COMPILE_OPTIONS 7
39 #define PragTyp_DATA_STORE_DIRECTORY 8
40 #define PragTyp_DATABASE_LIST 9
41 #define PragTyp_DEFAULT_CACHE_SIZE 10
42 #define PragTyp_ENCODING 11
43 #define PragTyp_FOREIGN_KEY_CHECK 12
44 #define PragTyp_FOREIGN_KEY_LIST 13
45 #define PragTyp_INCREMENTAL_VACUUM 14
46 #define PragTyp_INDEX_INFO 15
47 #define PragTyp_INDEX_LIST 16
48 #define PragTyp_INTEGRITY_CHECK 17
49 #define PragTyp_JOURNAL_MODE 18
50 #define PragTyp_JOURNAL_SIZE_LIMIT 19
51 #define PragTyp_LOCK_PROXY_FILE 20
52 #define PragTyp_LOCKING_MODE 21
53 #define PragTyp_PAGE_COUNT 22
54 #define PragTyp_MMAP_SIZE 23
55 #define PragTyp_PAGE_SIZE 24
56 #define PragTyp_SECURE_DELETE 25
57 #define PragTyp_SHRINK_MEMORY 26
58 #define PragTyp_SOFT_HEAP_LIMIT 27
59 #define PragTyp_STATS 28
60 #define PragTyp_SYNCHRONOUS 29
61 #define PragTyp_TABLE_INFO 30
62 #define PragTyp_TEMP_STORE 31
63 #define PragTyp_TEMP_STORE_DIRECTORY 32
64 #define PragTyp_THREADS 33
65 #define PragTyp_WAL_AUTOCHECKPOINT 34
66 #define PragTyp_WAL_CHECKPOINT 35
67 #define PragTyp_ACTIVATE_EXTENSIONS 36
68 #define PragTyp_HEXKEY 37
69 #define PragTyp_KEY 38
70 #define PragTyp_REKEY 39
71 #define PragTyp_LOCK_STATUS 40
72 #define PragTyp_PARSER_TRACE 41
73 #define PragFlag_NeedSchema 0x01
74 static const struct sPragmaNames {
75 const char *const zName; /* Name of pragma */
76 u8 ePragTyp; /* PragTyp_XXX value */
77 u8 mPragFlag; /* Zero or more PragFlag_XXX values */
78 u32 iArg; /* Extra argument */
79 } aPragmaNames[] = {
80 #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)
81 { /* zName: */ "activate_extensions",
82 /* ePragTyp: */ PragTyp_ACTIVATE_EXTENSIONS,
83 /* ePragFlag: */ 0,
84 /* iArg: */ 0 },
85 #endif
86 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
87 { /* zName: */ "application_id",
88 /* ePragTyp: */ PragTyp_HEADER_VALUE,
89 /* ePragFlag: */ 0,
90 /* iArg: */ 0 },
91 #endif
92 #if !defined(SQLITE_OMIT_AUTOVACUUM)
93 { /* zName: */ "auto_vacuum",
94 /* ePragTyp: */ PragTyp_AUTO_VACUUM,
95 /* ePragFlag: */ PragFlag_NeedSchema,
96 /* iArg: */ 0 },
97 #endif
98 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
99 #if !defined(SQLITE_OMIT_AUTOMATIC_INDEX)
100 { /* zName: */ "automatic_index",
101 /* ePragTyp: */ PragTyp_FLAG,
102 /* ePragFlag: */ 0,
103 /* iArg: */ SQLITE_AutoIndex },
104 #endif
105 #endif
106 { /* zName: */ "busy_timeout",
107 /* ePragTyp: */ PragTyp_BUSY_TIMEOUT,
108 /* ePragFlag: */ 0,
109 /* iArg: */ 0 },
110 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
111 { /* zName: */ "cache_size",
112 /* ePragTyp: */ PragTyp_CACHE_SIZE,
113 /* ePragFlag: */ PragFlag_NeedSchema,
114 /* iArg: */ 0 },
115 #endif
116 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
117 { /* zName: */ "cache_spill",
118 /* ePragTyp: */ PragTyp_FLAG,
119 /* ePragFlag: */ 0,
120 /* iArg: */ SQLITE_CacheSpill },
121 #endif
122 { /* zName: */ "case_sensitive_like",
123 /* ePragTyp: */ PragTyp_CASE_SENSITIVE_LIKE,
124 /* ePragFlag: */ 0,
125 /* iArg: */ 0 },
126 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
127 { /* zName: */ "checkpoint_fullfsync",
128 /* ePragTyp: */ PragTyp_FLAG,
129 /* ePragFlag: */ 0,
130 /* iArg: */ SQLITE_CkptFullFSync },
131 #endif
132 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
133 { /* zName: */ "collation_list",
134 /* ePragTyp: */ PragTyp_COLLATION_LIST,
135 /* ePragFlag: */ 0,
136 /* iArg: */ 0 },
137 #endif
138 #if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS)
139 { /* zName: */ "compile_options",
140 /* ePragTyp: */ PragTyp_COMPILE_OPTIONS,
141 /* ePragFlag: */ 0,
142 /* iArg: */ 0 },
143 #endif
144 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
145 { /* zName: */ "count_changes",
146 /* ePragTyp: */ PragTyp_FLAG,
147 /* ePragFlag: */ 0,
148 /* iArg: */ SQLITE_CountRows },
149 #endif
150 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN
151 { /* zName: */ "data_store_directory",
152 /* ePragTyp: */ PragTyp_DATA_STORE_DIRECTORY,
153 /* ePragFlag: */ 0,
154 /* iArg: */ 0 },
155 #endif
156 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
157 { /* zName: */ "database_list",
158 /* ePragTyp: */ PragTyp_DATABASE_LIST,
159 /* ePragFlag: */ PragFlag_NeedSchema,
160 /* iArg: */ 0 },
161 #endif
162 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
163 { /* zName: */ "default_cache_size",
164 /* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE,
165 /* ePragFlag: */ PragFlag_NeedSchema,
166 /* iArg: */ 0 },
167 #endif
168 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
169 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
170 { /* zName: */ "defer_foreign_keys",
171 /* ePragTyp: */ PragTyp_FLAG,
172 /* ePragFlag: */ 0,
173 /* iArg: */ SQLITE_DeferFKs },
174 #endif
175 #endif
176 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
177 { /* zName: */ "empty_result_callbacks",
178 /* ePragTyp: */ PragTyp_FLAG,
179 /* ePragFlag: */ 0,
180 /* iArg: */ SQLITE_NullCallback },
181 #endif
182 #if !defined(SQLITE_OMIT_UTF16)
183 { /* zName: */ "encoding",
184 /* ePragTyp: */ PragTyp_ENCODING,
185 /* ePragFlag: */ 0,
186 /* iArg: */ 0 },
187 #endif
188 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
189 { /* zName: */ "foreign_key_check",
190 /* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK,
191 /* ePragFlag: */ PragFlag_NeedSchema,
192 /* iArg: */ 0 },
193 #endif
194 #if !defined(SQLITE_OMIT_FOREIGN_KEY)
195 { /* zName: */ "foreign_key_list",
196 /* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST,
197 /* ePragFlag: */ PragFlag_NeedSchema,
198 /* iArg: */ 0 },
199 #endif
200 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
201 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
202 { /* zName: */ "foreign_keys",
203 /* ePragTyp: */ PragTyp_FLAG,
204 /* ePragFlag: */ 0,
205 /* iArg: */ SQLITE_ForeignKeys },
206 #endif
207 #endif
208 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
209 { /* zName: */ "freelist_count",
210 /* ePragTyp: */ PragTyp_HEADER_VALUE,
211 /* ePragFlag: */ 0,
212 /* iArg: */ 0 },
213 #endif
214 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
215 { /* zName: */ "full_column_names",
216 /* ePragTyp: */ PragTyp_FLAG,
217 /* ePragFlag: */ 0,
218 /* iArg: */ SQLITE_FullColNames },
219 { /* zName: */ "fullfsync",
220 /* ePragTyp: */ PragTyp_FLAG,
221 /* ePragFlag: */ 0,
222 /* iArg: */ SQLITE_FullFSync },
223 #endif
224 #if defined(SQLITE_HAS_CODEC)
225 { /* zName: */ "hexkey",
226 /* ePragTyp: */ PragTyp_HEXKEY,
227 /* ePragFlag: */ 0,
228 /* iArg: */ 0 },
229 { /* zName: */ "hexrekey",
230 /* ePragTyp: */ PragTyp_HEXKEY,
231 /* ePragFlag: */ 0,
232 /* iArg: */ 0 },
233 #endif
234 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
235 #if !defined(SQLITE_OMIT_CHECK)
236 { /* zName: */ "ignore_check_constraints",
237 /* ePragTyp: */ PragTyp_FLAG,
238 /* ePragFlag: */ 0,
239 /* iArg: */ SQLITE_IgnoreChecks },
240 #endif
241 #endif
242 #if !defined(SQLITE_OMIT_AUTOVACUUM)
243 { /* zName: */ "incremental_vacuum",
244 /* ePragTyp: */ PragTyp_INCREMENTAL_VACUUM,
245 /* ePragFlag: */ PragFlag_NeedSchema,
246 /* iArg: */ 0 },
247 #endif
248 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
249 { /* zName: */ "index_info",
250 /* ePragTyp: */ PragTyp_INDEX_INFO,
251 /* ePragFlag: */ PragFlag_NeedSchema,
252 /* iArg: */ 0 },
253 { /* zName: */ "index_list",
254 /* ePragTyp: */ PragTyp_INDEX_LIST,
255 /* ePragFlag: */ PragFlag_NeedSchema,
256 /* iArg: */ 0 },
257 #endif
258 #if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
259 { /* zName: */ "integrity_check",
260 /* ePragTyp: */ PragTyp_INTEGRITY_CHECK,
261 /* ePragFlag: */ PragFlag_NeedSchema,
262 /* iArg: */ 0 },
263 #endif
264 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
265 { /* zName: */ "journal_mode",
266 /* ePragTyp: */ PragTyp_JOURNAL_MODE,
267 /* ePragFlag: */ PragFlag_NeedSchema,
268 /* iArg: */ 0 },
269 { /* zName: */ "journal_size_limit",
270 /* ePragTyp: */ PragTyp_JOURNAL_SIZE_LIMIT,
271 /* ePragFlag: */ 0,
272 /* iArg: */ 0 },
273 #endif
274 #if defined(SQLITE_HAS_CODEC)
275 { /* zName: */ "key",
276 /* ePragTyp: */ PragTyp_KEY,
277 /* ePragFlag: */ 0,
278 /* iArg: */ 0 },
279 #endif
280 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
281 { /* zName: */ "legacy_file_format",
282 /* ePragTyp: */ PragTyp_FLAG,
283 /* ePragFlag: */ 0,
284 /* iArg: */ SQLITE_LegacyFileFmt },
285 #endif
286 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE
287 { /* zName: */ "lock_proxy_file",
288 /* ePragTyp: */ PragTyp_LOCK_PROXY_FILE,
289 /* ePragFlag: */ 0,
290 /* iArg: */ 0 },
291 #endif
292 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
293 { /* zName: */ "lock_status",
294 /* ePragTyp: */ PragTyp_LOCK_STATUS,
295 /* ePragFlag: */ 0,
296 /* iArg: */ 0 },
297 #endif
298 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
299 { /* zName: */ "locking_mode",
300 /* ePragTyp: */ PragTyp_LOCKING_MODE,
301 /* ePragFlag: */ 0,
302 /* iArg: */ 0 },
303 { /* zName: */ "max_page_count",
304 /* ePragTyp: */ PragTyp_PAGE_COUNT,
305 /* ePragFlag: */ PragFlag_NeedSchema,
306 /* iArg: */ 0 },
307 { /* zName: */ "mmap_size",
308 /* ePragTyp: */ PragTyp_MMAP_SIZE,
309 /* ePragFlag: */ 0,
310 /* iArg: */ 0 },
311 { /* zName: */ "page_count",
312 /* ePragTyp: */ PragTyp_PAGE_COUNT,
313 /* ePragFlag: */ PragFlag_NeedSchema,
314 /* iArg: */ 0 },
315 { /* zName: */ "page_size",
316 /* ePragTyp: */ PragTyp_PAGE_SIZE,
317 /* ePragFlag: */ 0,
318 /* iArg: */ 0 },
319 #endif
320 #if defined(SQLITE_DEBUG)
321 { /* zName: */ "parser_trace",
322 /* ePragTyp: */ PragTyp_PARSER_TRACE,
323 /* ePragFlag: */ 0,
324 /* iArg: */ 0 },
325 #endif
326 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
327 { /* zName: */ "query_only",
328 /* ePragTyp: */ PragTyp_FLAG,
329 /* ePragFlag: */ 0,
330 /* iArg: */ SQLITE_QueryOnly },
331 #endif
332 #if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
333 { /* zName: */ "quick_check",
334 /* ePragTyp: */ PragTyp_INTEGRITY_CHECK,
335 /* ePragFlag: */ PragFlag_NeedSchema,
336 /* iArg: */ 0 },
337 #endif
338 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
339 { /* zName: */ "read_uncommitted",
340 /* ePragTyp: */ PragTyp_FLAG,
341 /* ePragFlag: */ 0,
342 /* iArg: */ SQLITE_ReadUncommitted },
343 { /* zName: */ "recursive_triggers",
344 /* ePragTyp: */ PragTyp_FLAG,
345 /* ePragFlag: */ 0,
346 /* iArg: */ SQLITE_RecTriggers },
347 #endif
348 #if defined(SQLITE_HAS_CODEC)
349 { /* zName: */ "rekey",
350 /* ePragTyp: */ PragTyp_REKEY,
351 /* ePragFlag: */ 0,
352 /* iArg: */ 0 },
353 #endif
354 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
355 { /* zName: */ "reverse_unordered_selects",
356 /* ePragTyp: */ PragTyp_FLAG,
357 /* ePragFlag: */ 0,
358 /* iArg: */ SQLITE_ReverseOrder },
359 #endif
360 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
361 { /* zName: */ "schema_version",
362 /* ePragTyp: */ PragTyp_HEADER_VALUE,
363 /* ePragFlag: */ 0,
364 /* iArg: */ 0 },
365 #endif
366 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
367 { /* zName: */ "secure_delete",
368 /* ePragTyp: */ PragTyp_SECURE_DELETE,
369 /* ePragFlag: */ 0,
370 /* iArg: */ 0 },
371 #endif
372 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
373 { /* zName: */ "short_column_names",
374 /* ePragTyp: */ PragTyp_FLAG,
375 /* ePragFlag: */ 0,
376 /* iArg: */ SQLITE_ShortColNames },
377 #endif
378 { /* zName: */ "shrink_memory",
379 /* ePragTyp: */ PragTyp_SHRINK_MEMORY,
380 /* ePragFlag: */ 0,
381 /* iArg: */ 0 },
382 { /* zName: */ "soft_heap_limit",
383 /* ePragTyp: */ PragTyp_SOFT_HEAP_LIMIT,
384 /* ePragFlag: */ 0,
385 /* iArg: */ 0 },
386 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
387 #if defined(SQLITE_DEBUG)
388 { /* zName: */ "sql_trace",
389 /* ePragTyp: */ PragTyp_FLAG,
390 /* ePragFlag: */ 0,
391 /* iArg: */ SQLITE_SqlTrace },
392 #endif
393 #endif
394 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
395 { /* zName: */ "stats",
396 /* ePragTyp: */ PragTyp_STATS,
397 /* ePragFlag: */ PragFlag_NeedSchema,
398 /* iArg: */ 0 },
399 #endif
400 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
401 { /* zName: */ "synchronous",
402 /* ePragTyp: */ PragTyp_SYNCHRONOUS,
403 /* ePragFlag: */ PragFlag_NeedSchema,
404 /* iArg: */ 0 },
405 #endif
406 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
407 { /* zName: */ "table_info",
408 /* ePragTyp: */ PragTyp_TABLE_INFO,
409 /* ePragFlag: */ PragFlag_NeedSchema,
410 /* iArg: */ 0 },
411 #endif
412 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
413 { /* zName: */ "temp_store",
414 /* ePragTyp: */ PragTyp_TEMP_STORE,
415 /* ePragFlag: */ 0,
416 /* iArg: */ 0 },
417 { /* zName: */ "temp_store_directory",
418 /* ePragTyp: */ PragTyp_TEMP_STORE_DIRECTORY,
419 /* ePragFlag: */ 0,
420 /* iArg: */ 0 },
421 #endif
422 { /* zName: */ "threads",
423 /* ePragTyp: */ PragTyp_THREADS,
424 /* ePragFlag: */ 0,
425 /* iArg: */ 0 },
426 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
427 { /* zName: */ "user_version",
428 /* ePragTyp: */ PragTyp_HEADER_VALUE,
429 /* ePragFlag: */ 0,
430 /* iArg: */ 0 },
431 #endif
432 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
433 #if defined(SQLITE_DEBUG)
434 { /* zName: */ "vdbe_addoptrace",
435 /* ePragTyp: */ PragTyp_FLAG,
436 /* ePragFlag: */ 0,
437 /* iArg: */ SQLITE_VdbeAddopTrace },
438 { /* zName: */ "vdbe_debug",
439 /* ePragTyp: */ PragTyp_FLAG,
440 /* ePragFlag: */ 0,
441 /* iArg: */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace },
442 { /* zName: */ "vdbe_eqp",
443 /* ePragTyp: */ PragTyp_FLAG,
444 /* ePragFlag: */ 0,
445 /* iArg: */ SQLITE_VdbeEQP },
446 { /* zName: */ "vdbe_listing",
447 /* ePragTyp: */ PragTyp_FLAG,
448 /* ePragFlag: */ 0,
449 /* iArg: */ SQLITE_VdbeListing },
450 { /* zName: */ "vdbe_trace",
451 /* ePragTyp: */ PragTyp_FLAG,
452 /* ePragFlag: */ 0,
453 /* iArg: */ SQLITE_VdbeTrace },
454 #endif
455 #endif
456 #if !defined(SQLITE_OMIT_WAL)
457 { /* zName: */ "wal_autocheckpoint",
458 /* ePragTyp: */ PragTyp_WAL_AUTOCHECKPOINT,
459 /* ePragFlag: */ 0,
460 /* iArg: */ 0 },
461 { /* zName: */ "wal_checkpoint",
462 /* ePragTyp: */ PragTyp_WAL_CHECKPOINT,
463 /* ePragFlag: */ PragFlag_NeedSchema,
464 /* iArg: */ 0 },
465 #endif
466 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
467 { /* zName: */ "writable_schema",
468 /* ePragTyp: */ PragTyp_FLAG,
469 /* ePragFlag: */ 0,
470 /* iArg: */ SQLITE_WriteSchema|SQLITE_RecoveryMode },
471 #endif
472 };
473 /* Number of pragmas: 57 on by default, 70 total. */
474 /* End of the automatically generated pragma table.
475 ***************************************************************************/
476
477 /*
478 ** Interpret the given string as a safety level. Return 0 for OFF,
479 ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or
480 ** unrecognized string argument. The FULL option is disallowed
481 ** if the omitFull parameter it 1.
482 **
483 ** Note that the values returned are one less that the values that
484 ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done
485 ** to support legacy SQL code. The safety level used to be boolean
486 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
487 */
488 static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){
489 /* 123456789 123456789 */
490 static const char zText[] = "onoffalseyestruefull";
491 static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
492 static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
493 static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};
494 int i, n;
495 if( sqlite3Isdigit(*z) ){
496 return (u8)sqlite3Atoi(z);
497 }
498 n = sqlite3Strlen30(z);
499 for(i=0; i<ArraySize(iLength)-omitFull; i++){
500 if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
501 return iValue[i];
502 }
503 }
504 return dflt;
505 }
506
507 /*
508 ** Interpret the given string as a boolean value.
509 */
510 u8 sqlite3GetBoolean(const char *z, u8 dflt){
511 return getSafetyLevel(z,1,dflt)!=0;
512 }
513
514 /* The sqlite3GetBoolean() function is used by other modules but the
515 ** remainder of this file is specific to PRAGMA processing. So omit
516 ** the rest of the file if PRAGMAs are omitted from the build.
517 */
518 #if !defined(SQLITE_OMIT_PRAGMA)
519
520 /*
521 ** Interpret the given string as a locking mode value.
522 */
523 static int getLockingMode(const char *z){
524 if( z ){
525 if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
526 if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
527 }
528 return PAGER_LOCKINGMODE_QUERY;
529 }
530
531 #ifndef SQLITE_OMIT_AUTOVACUUM
532 /*
533 ** Interpret the given string as an auto-vacuum mode value.
534 **
535 ** The following strings, "none", "full" and "incremental" are
536 ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
537 */
538 static int getAutoVacuum(const char *z){
539 int i;
540 if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
541 if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
542 if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
543 i = sqlite3Atoi(z);
544 return (u8)((i>=0&&i<=2)?i:0);
545 }
546 #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
547
548 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
549 /*
550 ** Interpret the given string as a temp db location. Return 1 for file
551 ** backed temporary databases, 2 for the Red-Black tree in memory database
552 ** and 0 to use the compile-time default.
553 */
554 static int getTempStore(const char *z){
555 if( z[0]>='0' && z[0]<='2' ){
556 return z[0] - '0';
557 }else if( sqlite3StrICmp(z, "file")==0 ){
558 return 1;
559 }else if( sqlite3StrICmp(z, "memory")==0 ){
560 return 2;
561 }else{
562 return 0;
563 }
564 }
565 #endif /* SQLITE_PAGER_PRAGMAS */
566
567 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
568 /*
569 ** Invalidate temp storage, either when the temp storage is changed
570 ** from default, or when 'file' and the temp_store_directory has changed
571 */
572 static int invalidateTempStorage(Parse *pParse){
573 sqlite3 *db = pParse->db;
574 if( db->aDb[1].pBt!=0 ){
575 if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
576 sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
577 "from within a transaction");
578 return SQLITE_ERROR;
579 }
580 sqlite3BtreeClose(db->aDb[1].pBt);
581 db->aDb[1].pBt = 0;
582 sqlite3ResetAllSchemasOfConnection(db);
583 }
584 return SQLITE_OK;
585 }
586 #endif /* SQLITE_PAGER_PRAGMAS */
587
588 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
589 /*
590 ** If the TEMP database is open, close it and mark the database schema
591 ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
592 ** or DEFAULT_TEMP_STORE pragmas.
593 */
594 static int changeTempStorage(Parse *pParse, const char *zStorageType){
595 int ts = getTempStore(zStorageType);
596 sqlite3 *db = pParse->db;
597 if( db->temp_store==ts ) return SQLITE_OK;
598 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
599 return SQLITE_ERROR;
600 }
601 db->temp_store = (u8)ts;
602 return SQLITE_OK;
603 }
604 #endif /* SQLITE_PAGER_PRAGMAS */
605
606 /*
607 ** Generate code to return a single integer value.
608 */
609 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
610 Vdbe *v = sqlite3GetVdbe(pParse);
611 int mem = ++pParse->nMem;
612 i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
613 if( pI64 ){
614 memcpy(pI64, &value, sizeof(value));
615 }
616 sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
617 sqlite3VdbeSetNumCols(v, 1);
618 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);
619 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
620 }
621
622
623 /*
624 ** Set the safety_level and pager flags for pager iDb. Or if iDb<0
625 ** set these values for all pagers.
626 */
627 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
628 static void setAllPagerFlags(sqlite3 *db){
629 if( db->autoCommit ){
630 Db *pDb = db->aDb;
631 int n = db->nDb;
632 assert( SQLITE_FullFSync==PAGER_FULLFSYNC );
633 assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC );
634 assert( SQLITE_CacheSpill==PAGER_CACHESPILL );
635 assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL)
636 == PAGER_FLAGS_MASK );
637 assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );
638 while( (n--) > 0 ){
639 if( pDb->pBt ){
640 sqlite3BtreeSetPagerFlags(pDb->pBt,
641 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );
642 }
643 pDb++;
644 }
645 }
646 }
647 #else
648 # define setAllPagerFlags(X) /* no-op */
649 #endif
650
651
652 /*
653 ** Return a human-readable name for a constraint resolution action.
654 */
655 #ifndef SQLITE_OMIT_FOREIGN_KEY
656 static const char *actionName(u8 action){
657 const char *zName;
658 switch( action ){
659 case OE_SetNull: zName = "SET NULL"; break;
660 case OE_SetDflt: zName = "SET DEFAULT"; break;
661 case OE_Cascade: zName = "CASCADE"; break;
662 case OE_Restrict: zName = "RESTRICT"; break;
663 default: zName = "NO ACTION";
664 assert( action==OE_None ); break;
665 }
666 return zName;
667 }
668 #endif
669
670
671 /*
672 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
673 ** defined in pager.h. This function returns the associated lowercase
674 ** journal-mode name.
675 */
676 const char *sqlite3JournalModename(int eMode){
677 static char * const azModeName[] = {
678 "delete", "persist", "off", "truncate", "memory"
679 #ifndef SQLITE_OMIT_WAL
680 , "wal"
681 #endif
682 };
683 assert( PAGER_JOURNALMODE_DELETE==0 );
684 assert( PAGER_JOURNALMODE_PERSIST==1 );
685 assert( PAGER_JOURNALMODE_OFF==2 );
686 assert( PAGER_JOURNALMODE_TRUNCATE==3 );
687 assert( PAGER_JOURNALMODE_MEMORY==4 );
688 assert( PAGER_JOURNALMODE_WAL==5 );
689 assert( eMode>=0 && eMode<=ArraySize(azModeName) );
690
691 if( eMode==ArraySize(azModeName) ) return 0;
692 return azModeName[eMode];
693 }
694
695 /*
696 ** Process a pragma statement.
697 **
698 ** Pragmas are of this form:
699 **
700 ** PRAGMA [database.]id [= value]
701 **
702 ** The identifier might also be a string. The value is a string, and
703 ** identifier, or a number. If minusFlag is true, then the value is
704 ** a number that was preceded by a minus sign.
705 **
706 ** If the left side is "database.id" then pId1 is the database name
707 ** and pId2 is the id. If the left side is just "id" then pId1 is the
708 ** id and pId2 is any empty string.
709 */
710 void sqlite3Pragma(
711 Parse *pParse,
712 Token *pId1, /* First part of [database.]id field */
713 Token *pId2, /* Second part of [database.]id field, or NULL */
714 Token *pValue, /* Token for <value>, or NULL */
715 int minusFlag /* True if a '-' sign preceded <value> */
716 ){
717 char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
718 char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
719 const char *zDb = 0; /* The database name */
720 Token *pId; /* Pointer to <id> token */
721 char *aFcntl[4]; /* Argument to SQLITE_FCNTL_PRAGMA */
722 int iDb; /* Database index for <database> */
723 int lwr, upr, mid; /* Binary search bounds */
724 int rc; /* return value form SQLITE_FCNTL_PRAGMA */
725 sqlite3 *db = pParse->db; /* The database connection */
726 Db *pDb; /* The specific database being pragmaed */
727 Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */
728
729 if( v==0 ) return;
730 sqlite3VdbeRunOnlyOnce(v);
731 pParse->nMem = 2;
732
733 /* Interpret the [database.] part of the pragma statement. iDb is the
734 ** index of the database this pragma is being applied to in db.aDb[]. */
735 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
736 if( iDb<0 ) return;
737 pDb = &db->aDb[iDb];
738
739 /* If the temp database has been explicitly named as part of the
740 ** pragma, make sure it is open.
741 */
742 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
743 return;
744 }
745
746 zLeft = sqlite3NameFromToken(db, pId);
747 if( !zLeft ) return;
748 if( minusFlag ){
749 zRight = sqlite3MPrintf(db, "-%T", pValue);
750 }else{
751 zRight = sqlite3NameFromToken(db, pValue);
752 }
753
754 assert( pId2 );
755 zDb = pId2->n>0 ? pDb->zName : 0;
756 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
757 goto pragma_out;
758 }
759
760 /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS
761 ** connection. If it returns SQLITE_OK, then assume that the VFS
762 ** handled the pragma and generate a no-op prepared statement.
763 */
764 aFcntl[0] = 0;
765 aFcntl[1] = zLeft;
766 aFcntl[2] = zRight;
767 aFcntl[3] = 0;
768 db->busyHandler.nBusy = 0;
769 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl);
770 if( rc==SQLITE_OK ){
771 if( aFcntl[0] ){
772 int mem = ++pParse->nMem;
773 sqlite3VdbeAddOp4(v, OP_String8, 0, mem, 0, aFcntl[0], 0);
774 sqlite3VdbeSetNumCols(v, 1);
775 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "result", SQLITE_STATIC);
776 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
777 sqlite3_free(aFcntl[0]);
778 }
779 goto pragma_out;
780 }
781 if( rc!=SQLITE_NOTFOUND ){
782 if( aFcntl[0] ){
783 sqlite3ErrorMsg(pParse, "%s", aFcntl[0]);
784 sqlite3_free(aFcntl[0]);
785 }
786 pParse->nErr++;
787 pParse->rc = rc;
788 goto pragma_out;
789 }
790
791 /* Locate the pragma in the lookup table */
792 lwr = 0;
793 upr = ArraySize(aPragmaNames)-1;
794 while( lwr<=upr ){
795 mid = (lwr+upr)/2;
796 rc = sqlite3_stricmp(zLeft, aPragmaNames[mid].zName);
797 if( rc==0 ) break;
798 if( rc<0 ){
799 upr = mid - 1;
800 }else{
801 lwr = mid + 1;
802 }
803 }
804 if( lwr>upr ) goto pragma_out;
805
806 /* Make sure the database schema is loaded if the pragma requires that */
807 if( (aPragmaNames[mid].mPragFlag & PragFlag_NeedSchema)!=0 ){
808 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
809 }
810
811 /* Jump to the appropriate pragma handler */
812 switch( aPragmaNames[mid].ePragTyp ){
813
814 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
815 /*
816 ** PRAGMA [database.]default_cache_size
817 ** PRAGMA [database.]default_cache_size=N
818 **
819 ** The first form reports the current persistent setting for the
820 ** page cache size. The value returned is the maximum number of
821 ** pages in the page cache. The second form sets both the current
822 ** page cache size value and the persistent page cache size value
823 ** stored in the database file.
824 **
825 ** Older versions of SQLite would set the default cache size to a
826 ** negative number to indicate synchronous=OFF. These days, synchronous
827 ** is always on by default regardless of the sign of the default cache
828 ** size. But continue to take the absolute value of the default cache
829 ** size of historical compatibility.
830 */
831 case PragTyp_DEFAULT_CACHE_SIZE: {
832 static const int iLn = VDBE_OFFSET_LINENO(2);
833 static const VdbeOpList getCacheSize[] = {
834 { OP_Transaction, 0, 0, 0}, /* 0 */
835 { OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */
836 { OP_IfPos, 1, 8, 0},
837 { OP_Integer, 0, 2, 0},
838 { OP_Subtract, 1, 2, 1},
839 { OP_IfPos, 1, 8, 0},
840 { OP_Integer, 0, 1, 0}, /* 6 */
841 { OP_Noop, 0, 0, 0},
842 { OP_ResultRow, 1, 1, 0},
843 };
844 int addr;
845 sqlite3VdbeUsesBtree(v, iDb);
846 if( !zRight ){
847 sqlite3VdbeSetNumCols(v, 1);
848 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLITE_STATIC);
849 pParse->nMem += 2;
850 addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize,iLn);
851 sqlite3VdbeChangeP1(v, addr, iDb);
852 sqlite3VdbeChangeP1(v, addr+1, iDb);
853 sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);
854 }else{
855 int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
856 sqlite3BeginWriteOperation(pParse, 0, iDb);
857 sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
858 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
859 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
860 pDb->pSchema->cache_size = size;
861 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
862 }
863 break;
864 }
865 #endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */
866
867 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
868 /*
869 ** PRAGMA [database.]page_size
870 ** PRAGMA [database.]page_size=N
871 **
872 ** The first form reports the current setting for the
873 ** database page size in bytes. The second form sets the
874 ** database page size value. The value can only be set if
875 ** the database has not yet been created.
876 */
877 case PragTyp_PAGE_SIZE: {
878 Btree *pBt = pDb->pBt;
879 assert( pBt!=0 );
880 if( !zRight ){
881 int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
882 returnSingleInt(pParse, "page_size", size);
883 }else{
884 /* Malloc may fail when setting the page-size, as there is an internal
885 ** buffer that the pager module resizes using sqlite3_realloc().
886 */
887 db->nextPagesize = sqlite3Atoi(zRight);
888 if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
889 db->mallocFailed = 1;
890 }
891 }
892 break;
893 }
894
895 /*
896 ** PRAGMA [database.]secure_delete
897 ** PRAGMA [database.]secure_delete=ON/OFF
898 **
899 ** The first form reports the current setting for the
900 ** secure_delete flag. The second form changes the secure_delete
901 ** flag setting and reports thenew value.
902 */
903 case PragTyp_SECURE_DELETE: {
904 Btree *pBt = pDb->pBt;
905 int b = -1;
906 assert( pBt!=0 );
907 if( zRight ){
908 b = sqlite3GetBoolean(zRight, 0);
909 }
910 if( pId2->n==0 && b>=0 ){
911 int ii;
912 for(ii=0; ii<db->nDb; ii++){
913 sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
914 }
915 }
916 b = sqlite3BtreeSecureDelete(pBt, b);
917 returnSingleInt(pParse, "secure_delete", b);
918 break;
919 }
920
921 /*
922 ** PRAGMA [database.]max_page_count
923 ** PRAGMA [database.]max_page_count=N
924 **
925 ** The first form reports the current setting for the
926 ** maximum number of pages in the database file. The
927 ** second form attempts to change this setting. Both
928 ** forms return the current setting.
929 **
930 ** The absolute value of N is used. This is undocumented and might
931 ** change. The only purpose is to provide an easy way to test
932 ** the sqlite3AbsInt32() function.
933 **
934 ** PRAGMA [database.]page_count
935 **
936 ** Return the number of pages in the specified database.
937 */
938 case PragTyp_PAGE_COUNT: {
939 int iReg;
940 sqlite3CodeVerifySchema(pParse, iDb);
941 iReg = ++pParse->nMem;
942 if( sqlite3Tolower(zLeft[0])=='p' ){
943 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
944 }else{
945 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg,
946 sqlite3AbsInt32(sqlite3Atoi(zRight)));
947 }
948 sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
949 sqlite3VdbeSetNumCols(v, 1);
950 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
951 break;
952 }
953
954 /*
955 ** PRAGMA [database.]locking_mode
956 ** PRAGMA [database.]locking_mode = (normal|exclusive)
957 */
958 case PragTyp_LOCKING_MODE: {
959 const char *zRet = "normal";
960 int eMode = getLockingMode(zRight);
961
962 if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
963 /* Simple "PRAGMA locking_mode;" statement. This is a query for
964 ** the current default locking mode (which may be different to
965 ** the locking-mode of the main database).
966 */
967 eMode = db->dfltLockMode;
968 }else{
969 Pager *pPager;
970 if( pId2->n==0 ){
971 /* This indicates that no database name was specified as part
972 ** of the PRAGMA command. In this case the locking-mode must be
973 ** set on all attached databases, as well as the main db file.
974 **
975 ** Also, the sqlite3.dfltLockMode variable is set so that
976 ** any subsequently attached databases also use the specified
977 ** locking mode.
978 */
979 int ii;
980 assert(pDb==&db->aDb[0]);
981 for(ii=2; ii<db->nDb; ii++){
982 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
983 sqlite3PagerLockingMode(pPager, eMode);
984 }
985 db->dfltLockMode = (u8)eMode;
986 }
987 pPager = sqlite3BtreePager(pDb->pBt);
988 eMode = sqlite3PagerLockingMode(pPager, eMode);
989 }
990
991 assert( eMode==PAGER_LOCKINGMODE_NORMAL
992 || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
993 if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
994 zRet = "exclusive";
995 }
996 sqlite3VdbeSetNumCols(v, 1);
997 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", SQLITE_STATIC);
998 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
999 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1000 break;
1001 }
1002
1003 /*
1004 ** PRAGMA [database.]journal_mode
1005 ** PRAGMA [database.]journal_mode =
1006 ** (delete|persist|off|truncate|memory|wal|off)
1007 */
1008 case PragTyp_JOURNAL_MODE: {
1009 int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */
1010 int ii; /* Loop counter */
1011
1012 sqlite3VdbeSetNumCols(v, 1);
1013 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", SQLITE_STATIC);
1014
1015 if( zRight==0 ){
1016 /* If there is no "=MODE" part of the pragma, do a query for the
1017 ** current mode */
1018 eMode = PAGER_JOURNALMODE_QUERY;
1019 }else{
1020 const char *zMode;
1021 int n = sqlite3Strlen30(zRight);
1022 for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){
1023 if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;
1024 }
1025 if( !zMode ){
1026 /* If the "=MODE" part does not match any known journal mode,
1027 ** then do a query */
1028 eMode = PAGER_JOURNALMODE_QUERY;
1029 }
1030 }
1031 if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
1032 /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
1033 iDb = 0;
1034 pId2->n = 1;
1035 }
1036 for(ii=db->nDb-1; ii>=0; ii--){
1037 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
1038 sqlite3VdbeUsesBtree(v, ii);
1039 sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
1040 }
1041 }
1042 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1043 break;
1044 }
1045
1046 /*
1047 ** PRAGMA [database.]journal_size_limit
1048 ** PRAGMA [database.]journal_size_limit=N
1049 **
1050 ** Get or set the size limit on rollback journal files.
1051 */
1052 case PragTyp_JOURNAL_SIZE_LIMIT: {
1053 Pager *pPager = sqlite3BtreePager(pDb->pBt);
1054 i64 iLimit = -2;
1055 if( zRight ){
1056 sqlite3DecOrHexToI64(zRight, &iLimit);
1057 if( iLimit<-1 ) iLimit = -1;
1058 }
1059 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
1060 returnSingleInt(pParse, "journal_size_limit", iLimit);
1061 break;
1062 }
1063
1064 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
1065
1066 /*
1067 ** PRAGMA [database.]auto_vacuum
1068 ** PRAGMA [database.]auto_vacuum=N
1069 **
1070 ** Get or set the value of the database 'auto-vacuum' parameter.
1071 ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL
1072 */
1073 #ifndef SQLITE_OMIT_AUTOVACUUM
1074 case PragTyp_AUTO_VACUUM: {
1075 Btree *pBt = pDb->pBt;
1076 assert( pBt!=0 );
1077 if( !zRight ){
1078 returnSingleInt(pParse, "auto_vacuum", sqlite3BtreeGetAutoVacuum(pBt));
1079 }else{
1080 int eAuto = getAutoVacuum(zRight);
1081 assert( eAuto>=0 && eAuto<=2 );
1082 db->nextAutovac = (u8)eAuto;
1083 /* Call SetAutoVacuum() to set initialize the internal auto and
1084 ** incr-vacuum flags. This is required in case this connection
1085 ** creates the database file. It is important that it is created
1086 ** as an auto-vacuum capable db.
1087 */
1088 rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
1089 if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
1090 /* When setting the auto_vacuum mode to either "full" or
1091 ** "incremental", write the value of meta[6] in the database
1092 ** file. Before writing to meta[6], check that meta[3] indicates
1093 ** that this really is an auto-vacuum capable database.
1094 */
1095 static const int iLn = VDBE_OFFSET_LINENO(2);
1096 static const VdbeOpList setMeta6[] = {
1097 { OP_Transaction, 0, 1, 0}, /* 0 */
1098 { OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE},
1099 { OP_If, 1, 0, 0}, /* 2 */
1100 { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
1101 { OP_Integer, 0, 1, 0}, /* 4 */
1102 { OP_SetCookie, 0, BTREE_INCR_VACUUM, 1}, /* 5 */
1103 };
1104 int iAddr;
1105 iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
1106 sqlite3VdbeChangeP1(v, iAddr, iDb);
1107 sqlite3VdbeChangeP1(v, iAddr+1, iDb);
1108 sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
1109 sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
1110 sqlite3VdbeChangeP1(v, iAddr+5, iDb);
1111 sqlite3VdbeUsesBtree(v, iDb);
1112 }
1113 }
1114 break;
1115 }
1116 #endif
1117
1118 /*
1119 ** PRAGMA [database.]incremental_vacuum(N)
1120 **
1121 ** Do N steps of incremental vacuuming on a database.
1122 */
1123 #ifndef SQLITE_OMIT_AUTOVACUUM
1124 case PragTyp_INCREMENTAL_VACUUM: {
1125 int iLimit, addr;
1126 if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
1127 iLimit = 0x7fffffff;
1128 }
1129 sqlite3BeginWriteOperation(pParse, 0, iDb);
1130 sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
1131 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
1132 sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
1133 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
1134 sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v);
1135 sqlite3VdbeJumpHere(v, addr);
1136 break;
1137 }
1138 #endif
1139
1140 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
1141 /*
1142 ** PRAGMA [database.]cache_size
1143 ** PRAGMA [database.]cache_size=N
1144 **
1145 ** The first form reports the current local setting for the
1146 ** page cache size. The second form sets the local
1147 ** page cache size value. If N is positive then that is the
1148 ** number of pages in the cache. If N is negative, then the
1149 ** number of pages is adjusted so that the cache uses -N kibibytes
1150 ** of memory.
1151 */
1152 case PragTyp_CACHE_SIZE: {
1153 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1154 if( !zRight ){
1155 returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
1156 }else{
1157 int size = sqlite3Atoi(zRight);
1158 pDb->pSchema->cache_size = size;
1159 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
1160 }
1161 break;
1162 }
1163
1164 /*
1165 ** PRAGMA [database.]mmap_size(N)
1166 **
1167 ** Used to set mapping size limit. The mapping size limit is
1168 ** used to limit the aggregate size of all memory mapped regions of the
1169 ** database file. If this parameter is set to zero, then memory mapping
1170 ** is not used at all. If N is negative, then the default memory map
1171 ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.
1172 ** The parameter N is measured in bytes.
1173 **
1174 ** This value is advisory. The underlying VFS is free to memory map
1175 ** as little or as much as it wants. Except, if N is set to 0 then the
1176 ** upper layers will never invoke the xFetch interfaces to the VFS.
1177 */
1178 case PragTyp_MMAP_SIZE: {
1179 sqlite3_int64 sz;
1180 #if SQLITE_MAX_MMAP_SIZE>0
1181 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1182 if( zRight ){
1183 int ii;
1184 sqlite3DecOrHexToI64(zRight, &sz);
1185 if( sz<0 ) sz = sqlite3GlobalConfig.szMmap;
1186 if( pId2->n==0 ) db->szMmap = sz;
1187 for(ii=db->nDb-1; ii>=0; ii--){
1188 if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
1189 sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
1190 }
1191 }
1192 }
1193 sz = -1;
1194 rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz);
1195 #else
1196 sz = 0;
1197 rc = SQLITE_OK;
1198 #endif
1199 if( rc==SQLITE_OK ){
1200 returnSingleInt(pParse, "mmap_size", sz);
1201 }else if( rc!=SQLITE_NOTFOUND ){
1202 pParse->nErr++;
1203 pParse->rc = rc;
1204 }
1205 break;
1206 }
1207
1208 /*
1209 ** PRAGMA temp_store
1210 ** PRAGMA temp_store = "default"|"memory"|"file"
1211 **
1212 ** Return or set the local value of the temp_store flag. Changing
1213 ** the local value does not make changes to the disk file and the default
1214 ** value will be restored the next time the database is opened.
1215 **
1216 ** Note that it is possible for the library compile-time options to
1217 ** override this setting
1218 */
1219 case PragTyp_TEMP_STORE: {
1220 if( !zRight ){
1221 returnSingleInt(pParse, "temp_store", db->temp_store);
1222 }else{
1223 changeTempStorage(pParse, zRight);
1224 }
1225 break;
1226 }
1227
1228 /*
1229 ** PRAGMA temp_store_directory
1230 ** PRAGMA temp_store_directory = ""|"directory_name"
1231 **
1232 ** Return or set the local value of the temp_store_directory flag. Changing
1233 ** the value sets a specific directory to be used for temporary files.
1234 ** Setting to a null string reverts to the default temporary directory search.
1235 ** If temporary directory is changed, then invalidateTempStorage.
1236 **
1237 */
1238 case PragTyp_TEMP_STORE_DIRECTORY: {
1239 if( !zRight ){
1240 if( sqlite3_temp_directory ){
1241 sqlite3VdbeSetNumCols(v, 1);
1242 sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
1243 "temp_store_directory", SQLITE_STATIC);
1244 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
1245 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1246 }
1247 }else{
1248 #ifndef SQLITE_OMIT_WSD
1249 if( zRight[0] ){
1250 int res;
1251 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
1252 if( rc!=SQLITE_OK || res==0 ){
1253 sqlite3ErrorMsg(pParse, "not a writable directory");
1254 goto pragma_out;
1255 }
1256 }
1257 if( SQLITE_TEMP_STORE==0
1258 || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
1259 || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
1260 ){
1261 invalidateTempStorage(pParse);
1262 }
1263 sqlite3_free(sqlite3_temp_directory);
1264 if( zRight[0] ){
1265 sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);
1266 }else{
1267 sqlite3_temp_directory = 0;
1268 }
1269 #endif /* SQLITE_OMIT_WSD */
1270 }
1271 break;
1272 }
1273
1274 #if SQLITE_OS_WIN
1275 /*
1276 ** PRAGMA data_store_directory
1277 ** PRAGMA data_store_directory = ""|"directory_name"
1278 **
1279 ** Return or set the local value of the data_store_directory flag. Changing
1280 ** the value sets a specific directory to be used for database files that
1281 ** were specified with a relative pathname. Setting to a null string reverts
1282 ** to the default database directory, which for database files specified with
1283 ** a relative path will probably be based on the current directory for the
1284 ** process. Database file specified with an absolute path are not impacted
1285 ** by this setting, regardless of its value.
1286 **
1287 */
1288 case PragTyp_DATA_STORE_DIRECTORY: {
1289 if( !zRight ){
1290 if( sqlite3_data_directory ){
1291 sqlite3VdbeSetNumCols(v, 1);
1292 sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
1293 "data_store_directory", SQLITE_STATIC);
1294 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_data_directory, 0);
1295 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1296 }
1297 }else{
1298 #ifndef SQLITE_OMIT_WSD
1299 if( zRight[0] ){
1300 int res;
1301 rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
1302 if( rc!=SQLITE_OK || res==0 ){
1303 sqlite3ErrorMsg(pParse, "not a writable directory");
1304 goto pragma_out;
1305 }
1306 }
1307 sqlite3_free(sqlite3_data_directory);
1308 if( zRight[0] ){
1309 sqlite3_data_directory = sqlite3_mprintf("%s", zRight);
1310 }else{
1311 sqlite3_data_directory = 0;
1312 }
1313 #endif /* SQLITE_OMIT_WSD */
1314 }
1315 break;
1316 }
1317 #endif
1318
1319 #if SQLITE_ENABLE_LOCKING_STYLE
1320 /*
1321 ** PRAGMA [database.]lock_proxy_file
1322 ** PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"
1323 **
1324 ** Return or set the value of the lock_proxy_file flag. Changing
1325 ** the value sets a specific file to be used for database access locks.
1326 **
1327 */
1328 case PragTyp_LOCK_PROXY_FILE: {
1329 if( !zRight ){
1330 Pager *pPager = sqlite3BtreePager(pDb->pBt);
1331 char *proxy_file_path = NULL;
1332 sqlite3_file *pFile = sqlite3PagerFile(pPager);
1333 sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
1334 &proxy_file_path);
1335
1336 if( proxy_file_path ){
1337 sqlite3VdbeSetNumCols(v, 1);
1338 sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
1339 "lock_proxy_file", SQLITE_STATIC);
1340 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, proxy_file_path, 0);
1341 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1342 }
1343 }else{
1344 Pager *pPager = sqlite3BtreePager(pDb->pBt);
1345 sqlite3_file *pFile = sqlite3PagerFile(pPager);
1346 int res;
1347 if( zRight[0] ){
1348 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
1349 zRight);
1350 } else {
1351 res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
1352 NULL);
1353 }
1354 if( res!=SQLITE_OK ){
1355 sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
1356 goto pragma_out;
1357 }
1358 }
1359 break;
1360 }
1361 #endif /* SQLITE_ENABLE_LOCKING_STYLE */
1362
1363 /*
1364 ** PRAGMA [database.]synchronous
1365 ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
1366 **
1367 ** Return or set the local value of the synchronous flag. Changing
1368 ** the local value does not make changes to the disk file and the
1369 ** default value will be restored the next time the database is
1370 ** opened.
1371 */
1372 case PragTyp_SYNCHRONOUS: {
1373 if( !zRight ){
1374 returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
1375 }else{
1376 if( !db->autoCommit ){
1377 sqlite3ErrorMsg(pParse,
1378 "Safety level may not be changed inside a transaction");
1379 }else{
1380 pDb->safety_level = getSafetyLevel(zRight,0,1)+1;
1381 setAllPagerFlags(db);
1382 }
1383 }
1384 break;
1385 }
1386 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
1387
1388 #ifndef SQLITE_OMIT_FLAG_PRAGMAS
1389 case PragTyp_FLAG: {
1390 if( zRight==0 ){
1391 returnSingleInt(pParse, aPragmaNames[mid].zName,
1392 (db->flags & aPragmaNames[mid].iArg)!=0 );
1393 }else{
1394 int mask = aPragmaNames[mid].iArg; /* Mask of bits to set or clear. */
1395 if( db->autoCommit==0 ){
1396 /* Foreign key support may not be enabled or disabled while not
1397 ** in auto-commit mode. */
1398 mask &= ~(SQLITE_ForeignKeys);
1399 }
1400 #if SQLITE_USER_AUTHENTICATION
1401 if( db->auth.authLevel==UAUTH_User ){
1402 /* Do not allow non-admin users to modify the schema arbitrarily */
1403 mask &= ~(SQLITE_WriteSchema);
1404 }
1405 #endif
1406
1407 if( sqlite3GetBoolean(zRight, 0) ){
1408 db->flags |= mask;
1409 }else{
1410 db->flags &= ~mask;
1411 if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0;
1412 }
1413
1414 /* Many of the flag-pragmas modify the code generated by the SQL
1415 ** compiler (eg. count_changes). So add an opcode to expire all
1416 ** compiled SQL statements after modifying a pragma value.
1417 */
1418 sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
1419 setAllPagerFlags(db);
1420 }
1421 break;
1422 }
1423 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
1424
1425 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
1426 /*
1427 ** PRAGMA table_info(<table>)
1428 **
1429 ** Return a single row for each column of the named table. The columns of
1430 ** the returned data set are:
1431 **
1432 ** cid: Column id (numbered from left to right, starting at 0)
1433 ** name: Column name
1434 ** type: Column declaration type.
1435 ** notnull: True if 'NOT NULL' is part of column declaration
1436 ** dflt_value: The default value for the column, if any.
1437 */
1438 case PragTyp_TABLE_INFO: if( zRight ){
1439 Table *pTab;
1440 pTab = sqlite3FindTable(db, zRight, zDb);
1441 if( pTab ){
1442 int i, k;
1443 int nHidden = 0;
1444 Column *pCol;
1445 Index *pPk = sqlite3PrimaryKeyIndex(pTab);
1446 sqlite3VdbeSetNumCols(v, 6);
1447 pParse->nMem = 6;
1448 sqlite3CodeVerifySchema(pParse, iDb);
1449 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", SQLITE_STATIC);
1450 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
1451 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", SQLITE_STATIC);
1452 sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", SQLITE_STATIC);
1453 sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", SQLITE_STATIC);
1454 sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", SQLITE_STATIC);
1455 sqlite3ViewGetColumnNames(pParse, pTab);
1456 for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
1457 if( IsHiddenColumn(pCol) ){
1458 nHidden++;
1459 continue;
1460 }
1461 sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
1462 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
1463 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1464 pCol->zType ? pCol->zType : "", 0);
1465 sqlite3VdbeAddOp2(v, OP_Integer, (pCol->notNull ? 1 : 0), 4);
1466 if( pCol->zDflt ){
1467 sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pCol->zDflt, 0);
1468 }else{
1469 sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
1470 }
1471 if( (pCol->colFlags & COLFLAG_PRIMKEY)==0 ){
1472 k = 0;
1473 }else if( pPk==0 ){
1474 k = 1;
1475 }else{
1476 for(k=1; ALWAYS(k<=pTab->nCol) && pPk->aiColumn[k-1]!=i; k++){}
1477 }
1478 sqlite3VdbeAddOp2(v, OP_Integer, k, 6);
1479 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
1480 }
1481 }
1482 }
1483 break;
1484
1485 case PragTyp_STATS: {
1486 Index *pIdx;
1487 HashElem *i;
1488 v = sqlite3GetVdbe(pParse);
1489 sqlite3VdbeSetNumCols(v, 4);
1490 pParse->nMem = 4;
1491 sqlite3CodeVerifySchema(pParse, iDb);
1492 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "table", SQLITE_STATIC);
1493 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "index", SQLITE_STATIC);
1494 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "width", SQLITE_STATIC);
1495 sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "height", SQLITE_STATIC);
1496 for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){
1497 Table *pTab = sqliteHashData(i);
1498 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, pTab->zName, 0);
1499 sqlite3VdbeAddOp2(v, OP_Null, 0, 2);
1500 sqlite3VdbeAddOp2(v, OP_Integer,
1501 (int)sqlite3LogEstToInt(pTab->szTabRow), 3);
1502 sqlite3VdbeAddOp2(v, OP_Integer,
1503 (int)sqlite3LogEstToInt(pTab->nRowLogEst), 4);
1504 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4);
1505 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1506 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
1507 sqlite3VdbeAddOp2(v, OP_Integer,
1508 (int)sqlite3LogEstToInt(pIdx->szIdxRow), 3);
1509 sqlite3VdbeAddOp2(v, OP_Integer,
1510 (int)sqlite3LogEstToInt(pIdx->aiRowLogEst[0]), 4);
1511 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 4);
1512 }
1513 }
1514 }
1515 break;
1516
1517 case PragTyp_INDEX_INFO: if( zRight ){
1518 Index *pIdx;
1519 Table *pTab;
1520 pIdx = sqlite3FindIndex(db, zRight, zDb);
1521 if( pIdx ){
1522 int i;
1523 pTab = pIdx->pTable;
1524 sqlite3VdbeSetNumCols(v, 3);
1525 pParse->nMem = 3;
1526 sqlite3CodeVerifySchema(pParse, iDb);
1527 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLITE_STATIC);
1528 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLITE_STATIC);
1529 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLITE_STATIC);
1530 for(i=0; i<pIdx->nKeyCol; i++){
1531 i16 cnum = pIdx->aiColumn[i];
1532 sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1533 sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
1534 assert( pTab->nCol>cnum );
1535 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
1536 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1537 }
1538 }
1539 }
1540 break;
1541
1542 case PragTyp_INDEX_LIST: if( zRight ){
1543 Index *pIdx;
1544 Table *pTab;
1545 int i;
1546 pTab = sqlite3FindTable(db, zRight, zDb);
1547 if( pTab ){
1548 v = sqlite3GetVdbe(pParse);
1549 sqlite3VdbeSetNumCols(v, 3);
1550 pParse->nMem = 3;
1551 sqlite3CodeVerifySchema(pParse, iDb);
1552 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
1553 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
1554 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", SQLITE_STATIC);
1555 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
1556 sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1557 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
1558 sqlite3VdbeAddOp2(v, OP_Integer, IsUniqueIndex(pIdx), 3);
1559 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1560 }
1561 }
1562 }
1563 break;
1564
1565 case PragTyp_DATABASE_LIST: {
1566 int i;
1567 sqlite3VdbeSetNumCols(v, 3);
1568 pParse->nMem = 3;
1569 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
1570 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
1571 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", SQLITE_STATIC);
1572 for(i=0; i<db->nDb; i++){
1573 if( db->aDb[i].pBt==0 ) continue;
1574 assert( db->aDb[i].zName!=0 );
1575 sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1576 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
1577 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1578 sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
1579 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1580 }
1581 }
1582 break;
1583
1584 case PragTyp_COLLATION_LIST: {
1585 int i = 0;
1586 HashElem *p;
1587 sqlite3VdbeSetNumCols(v, 2);
1588 pParse->nMem = 2;
1589 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
1590 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
1591 for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
1592 CollSeq *pColl = (CollSeq *)sqliteHashData(p);
1593 sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
1594 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
1595 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
1596 }
1597 }
1598 break;
1599 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
1600
1601 #ifndef SQLITE_OMIT_FOREIGN_KEY
1602 case PragTyp_FOREIGN_KEY_LIST: if( zRight ){
1603 FKey *pFK;
1604 Table *pTab;
1605 pTab = sqlite3FindTable(db, zRight, zDb);
1606 if( pTab ){
1607 v = sqlite3GetVdbe(pParse);
1608 pFK = pTab->pFKey;
1609 if( pFK ){
1610 int i = 0;
1611 sqlite3VdbeSetNumCols(v, 8);
1612 pParse->nMem = 8;
1613 sqlite3CodeVerifySchema(pParse, iDb);
1614 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", SQLITE_STATIC);
1615 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", SQLITE_STATIC);
1616 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", SQLITE_STATIC);
1617 sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", SQLITE_STATIC);
1618 sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", SQLITE_STATIC);
1619 sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "on_update", SQLITE_STATIC);
1620 sqlite3VdbeSetColName(v, 6, COLNAME_NAME, "on_delete", SQLITE_STATIC);
1621 sqlite3VdbeSetColName(v, 7, COLNAME_NAME, "match", SQLITE_STATIC);
1622 while(pFK){
1623 int j;
1624 for(j=0; j<pFK->nCol; j++){
1625 char *zCol = pFK->aCol[j].zCol;
1626 char *zOnDelete = (char *)actionName(pFK->aAction[0]);
1627 char *zOnUpdate = (char *)actionName(pFK->aAction[1]);
1628 sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1629 sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
1630 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
1631 sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
1632 pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
1633 sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
1634 sqlite3VdbeAddOp4(v, OP_String8, 0, 6, 0, zOnUpdate, 0);
1635 sqlite3VdbeAddOp4(v, OP_String8, 0, 7, 0, zOnDelete, 0);
1636 sqlite3VdbeAddOp4(v, OP_String8, 0, 8, 0, "NONE", 0);
1637 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 8);
1638 }
1639 ++i;
1640 pFK = pFK->pNextFrom;
1641 }
1642 }
1643 }
1644 }
1645 break;
1646 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1647
1648 #ifndef SQLITE_OMIT_FOREIGN_KEY
1649 #ifndef SQLITE_OMIT_TRIGGER
1650 case PragTyp_FOREIGN_KEY_CHECK: {
1651 FKey *pFK; /* A foreign key constraint */
1652 Table *pTab; /* Child table contain "REFERENCES" keyword */
1653 Table *pParent; /* Parent table that child points to */
1654 Index *pIdx; /* Index in the parent table */
1655 int i; /* Loop counter: Foreign key number for pTab */
1656 int j; /* Loop counter: Field of the foreign key */
1657 HashElem *k; /* Loop counter: Next table in schema */
1658 int x; /* result variable */
1659 int regResult; /* 3 registers to hold a result row */
1660 int regKey; /* Register to hold key for checking the FK */
1661 int regRow; /* Registers to hold a row from pTab */
1662 int addrTop; /* Top of a loop checking foreign keys */
1663 int addrOk; /* Jump here if the key is OK */
1664 int *aiCols; /* child to parent column mapping */
1665
1666 regResult = pParse->nMem+1;
1667 pParse->nMem += 4;
1668 regKey = ++pParse->nMem;
1669 regRow = ++pParse->nMem;
1670 v = sqlite3GetVdbe(pParse);
1671 sqlite3VdbeSetNumCols(v, 4);
1672 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "table", SQLITE_STATIC);
1673 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "rowid", SQLITE_STATIC);
1674 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "parent", SQLITE_STATIC);
1675 sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "fkid", SQLITE_STATIC);
1676 sqlite3CodeVerifySchema(pParse, iDb);
1677 k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
1678 while( k ){
1679 if( zRight ){
1680 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
1681 k = 0;
1682 }else{
1683 pTab = (Table*)sqliteHashData(k);
1684 k = sqliteHashNext(k);
1685 }
1686 if( pTab==0 || pTab->pFKey==0 ) continue;
1687 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
1688 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
1689 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
1690 sqlite3VdbeAddOp4(v, OP_String8, 0, regResult, 0, pTab->zName,
1691 P4_TRANSIENT);
1692 for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
1693 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
1694 if( pParent==0 ) continue;
1695 pIdx = 0;
1696 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
1697 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
1698 if( x==0 ){
1699 if( pIdx==0 ){
1700 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
1701 }else{
1702 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
1703 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
1704 }
1705 }else{
1706 k = 0;
1707 break;
1708 }
1709 }
1710 assert( pParse->nErr>0 || pFK==0 );
1711 if( pFK ) break;
1712 if( pParse->nTab<i ) pParse->nTab = i;
1713 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
1714 for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
1715 pParent = sqlite3FindTable(db, pFK->zTo, zDb);
1716 pIdx = 0;
1717 aiCols = 0;
1718 if( pParent ){
1719 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
1720 assert( x==0 );
1721 }
1722 addrOk = sqlite3VdbeMakeLabel(v);
1723 if( pParent && pIdx==0 ){
1724 int iKey = pFK->aCol[0].iFrom;
1725 assert( iKey>=0 && iKey<pTab->nCol );
1726 if( iKey!=pTab->iPKey ){
1727 sqlite3VdbeAddOp3(v, OP_Column, 0, iKey, regRow);
1728 sqlite3ColumnDefault(v, pTab, iKey, regRow);
1729 sqlite3VdbeAddOp2(v, OP_IsNull, regRow, addrOk); VdbeCoverage(v);
1730 sqlite3VdbeAddOp2(v, OP_MustBeInt, regRow,
1731 sqlite3VdbeCurrentAddr(v)+3); VdbeCoverage(v);
1732 }else{
1733 sqlite3VdbeAddOp2(v, OP_Rowid, 0, regRow);
1734 }
1735 sqlite3VdbeAddOp3(v, OP_NotExists, i, 0, regRow); VdbeCoverage(v);
1736 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrOk);
1737 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
1738 }else{
1739 for(j=0; j<pFK->nCol; j++){
1740 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0,
1741 aiCols ? aiCols[j] : pFK->aCol[j].iFrom, regRow+j);
1742 sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v);
1743 }
1744 if( pParent ){
1745 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
1746 sqlite3IndexAffinityStr(v,pIdx), pFK->nCol);
1747 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regKey, 0);
1748 VdbeCoverage(v);
1749 }
1750 }
1751 sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1);
1752 sqlite3VdbeAddOp4(v, OP_String8, 0, regResult+2, 0,
1753 pFK->zTo, P4_TRANSIENT);
1754 sqlite3VdbeAddOp2(v, OP_Integer, i-1, regResult+3);
1755 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4);
1756 sqlite3VdbeResolveLabel(v, addrOk);
1757 sqlite3DbFree(db, aiCols);
1758 }
1759 sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v);
1760 sqlite3VdbeJumpHere(v, addrTop);
1761 }
1762 }
1763 break;
1764 #endif /* !defined(SQLITE_OMIT_TRIGGER) */
1765 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1766
1767 #ifndef NDEBUG
1768 case PragTyp_PARSER_TRACE: {
1769 if( zRight ){
1770 if( sqlite3GetBoolean(zRight, 0) ){
1771 sqlite3ParserTrace(stderr, "parser: ");
1772 }else{
1773 sqlite3ParserTrace(0, 0);
1774 }
1775 }
1776 }
1777 break;
1778 #endif
1779
1780 /* Reinstall the LIKE and GLOB functions. The variant of LIKE
1781 ** used will be case sensitive or not depending on the RHS.
1782 */
1783 case PragTyp_CASE_SENSITIVE_LIKE: {
1784 if( zRight ){
1785 sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight, 0));
1786 }
1787 }
1788 break;
1789
1790 #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
1791 # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
1792 #endif
1793
1794 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
1795 /* Pragma "quick_check" is reduced version of
1796 ** integrity_check designed to detect most database corruption
1797 ** without most of the overhead of a full integrity-check.
1798 */
1799 case PragTyp_INTEGRITY_CHECK: {
1800 int i, j, addr, mxErr;
1801
1802 /* Code that appears at the end of the integrity check. If no error
1803 ** messages have been generated, output OK. Otherwise output the
1804 ** error message
1805 */
1806 static const int iLn = VDBE_OFFSET_LINENO(2);
1807 static const VdbeOpList endCode[] = {
1808 { OP_IfNeg, 1, 0, 0}, /* 0 */
1809 { OP_String8, 0, 3, 0}, /* 1 */
1810 { OP_ResultRow, 3, 1, 0},
1811 };
1812
1813 int isQuick = (sqlite3Tolower(zLeft[0])=='q');
1814
1815 /* If the PRAGMA command was of the form "PRAGMA <db>.integrity_check",
1816 ** then iDb is set to the index of the database identified by <db>.
1817 ** In this case, the integrity of database iDb only is verified by
1818 ** the VDBE created below.
1819 **
1820 ** Otherwise, if the command was simply "PRAGMA integrity_check" (or
1821 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
1822 ** to -1 here, to indicate that the VDBE should verify the integrity
1823 ** of all attached databases. */
1824 assert( iDb>=0 );
1825 assert( iDb==0 || pId2->z );
1826 if( pId2->z==0 ) iDb = -1;
1827
1828 /* Initialize the VDBE program */
1829 pParse->nMem = 6;
1830 sqlite3VdbeSetNumCols(v, 1);
1831 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", SQLITE_STATIC);
1832
1833 /* Set the maximum error count */
1834 mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1835 if( zRight ){
1836 sqlite3GetInt32(zRight, &mxErr);
1837 if( mxErr<=0 ){
1838 mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1839 }
1840 }
1841 sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */
1842
1843 /* Do an integrity check on each database file */
1844 for(i=0; i<db->nDb; i++){
1845 HashElem *x;
1846 Hash *pTbls;
1847 int cnt = 0;
1848
1849 if( OMIT_TEMPDB && i==1 ) continue;
1850 if( iDb>=0 && i!=iDb ) continue;
1851
1852 sqlite3CodeVerifySchema(pParse, i);
1853 addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
1854 VdbeCoverage(v);
1855 sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1856 sqlite3VdbeJumpHere(v, addr);
1857
1858 /* Do an integrity check of the B-Tree
1859 **
1860 ** Begin by filling registers 2, 3, ... with the root pages numbers
1861 ** for all tables and indices in the database.
1862 */
1863 assert( sqlite3SchemaMutexHeld(db, i, 0) );
1864 pTbls = &db->aDb[i].pSchema->tblHash;
1865 for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
1866 Table *pTab = sqliteHashData(x);
1867 Index *pIdx;
1868 if( HasRowid(pTab) ){
1869 sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
1870 VdbeComment((v, "%s", pTab->zName));
1871 cnt++;
1872 }
1873 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1874 sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
1875 VdbeComment((v, "%s", pIdx->zName));
1876 cnt++;
1877 }
1878 }
1879
1880 /* Make sure sufficient number of registers have been allocated */
1881 pParse->nMem = MAX( pParse->nMem, cnt+8 );
1882
1883 /* Do the b-tree integrity checks */
1884 sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
1885 sqlite3VdbeChangeP5(v, (u8)i);
1886 addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v);
1887 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1888 sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
1889 P4_DYNAMIC);
1890 sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
1891 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
1892 sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
1893 sqlite3VdbeJumpHere(v, addr);
1894
1895 /* Make sure all the indices are constructed correctly.
1896 */
1897 for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
1898 Table *pTab = sqliteHashData(x);
1899 Index *pIdx, *pPk;
1900 Index *pPrior = 0;
1901 int loopTop;
1902 int iDataCur, iIdxCur;
1903 int r1 = -1;
1904
1905 if( pTab->pIndex==0 ) continue;
1906 pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
1907 addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
1908 VdbeCoverage(v);
1909 sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1910 sqlite3VdbeJumpHere(v, addr);
1911 sqlite3ExprCacheClear(pParse);
1912 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead,
1913 1, 0, &iDataCur, &iIdxCur);
1914 sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
1915 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1916 sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */
1917 }
1918 pParse->nMem = MAX(pParse->nMem, 8+j);
1919 sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
1920 loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
1921 /* Verify that all NOT NULL columns really are NOT NULL */
1922 for(j=0; j<pTab->nCol; j++){
1923 char *zErr;
1924 int jmp2, jmp3;
1925 if( j==pTab->iPKey ) continue;
1926 if( pTab->aCol[j].notNull==0 ) continue;
1927 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
1928 sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
1929 jmp2 = sqlite3VdbeAddOp1(v, OP_NotNull, 3); VdbeCoverage(v);
1930 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
1931 zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName,
1932 pTab->aCol[j].zName);
1933 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
1934 sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
1935 jmp3 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
1936 sqlite3VdbeAddOp0(v, OP_Halt);
1937 sqlite3VdbeJumpHere(v, jmp2);
1938 sqlite3VdbeJumpHere(v, jmp3);
1939 }
1940 /* Validate index entries for the current row */
1941 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1942 int jmp2, jmp3, jmp4, jmp5;
1943 int ckUniq = sqlite3VdbeMakeLabel(v);
1944 if( pPk==pIdx ) continue;
1945 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
1946 pPrior, r1);
1947 pPrior = pIdx;
1948 sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1); /* increment entry count */
1949 /* Verify that an index entry exists for the current table row */
1950 jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
1951 pIdx->nColumn); VdbeCoverage(v);
1952 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
1953 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, "row ", P4_STATIC);
1954 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
1955 sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
1956 " missing from index ", P4_STATIC);
1957 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
1958 jmp5 = sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
1959 pIdx->zName, P4_TRANSIENT);
1960 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
1961 sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
1962 jmp4 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
1963 sqlite3VdbeAddOp0(v, OP_Halt);
1964 sqlite3VdbeJumpHere(v, jmp2);
1965 /* For UNIQUE indexes, verify that only one entry exists with the
1966 ** current key. The entry is unique if (1) any column is NULL
1967 ** or (2) the next entry has a different key */
1968 if( IsUniqueIndex(pIdx) ){
1969 int uniqOk = sqlite3VdbeMakeLabel(v);
1970 int jmp6;
1971 int kk;
1972 for(kk=0; kk<pIdx->nKeyCol; kk++){
1973 int iCol = pIdx->aiColumn[kk];
1974 assert( iCol>=0 && iCol<pTab->nCol );
1975 if( pTab->aCol[iCol].notNull ) continue;
1976 sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk);
1977 VdbeCoverage(v);
1978 }
1979 jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
1980 sqlite3VdbeAddOp2(v, OP_Goto, 0, uniqOk);
1981 sqlite3VdbeJumpHere(v, jmp6);
1982 sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
1983 pIdx->nKeyCol); VdbeCoverage(v);
1984 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
1985 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1986 "non-unique entry in index ", P4_STATIC);
1987 sqlite3VdbeAddOp2(v, OP_Goto, 0, jmp5);
1988 sqlite3VdbeResolveLabel(v, uniqOk);
1989 }
1990 sqlite3VdbeJumpHere(v, jmp4);
1991 sqlite3ResolvePartIdxLabel(pParse, jmp3);
1992 }
1993 sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
1994 sqlite3VdbeJumpHere(v, loopTop-1);
1995 #ifndef SQLITE_OMIT_BTREECOUNT
1996 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0,
1997 "wrong # of entries in index ", P4_STATIC);
1998 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1999 if( pPk==pIdx ) continue;
2000 addr = sqlite3VdbeCurrentAddr(v);
2001 sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr+2); VdbeCoverage(v);
2002 sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
2003 sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
2004 sqlite3VdbeAddOp3(v, OP_Eq, 8+j, addr+8, 3); VdbeCoverage(v);
2005 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
2006 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
2007 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pIdx->zName, P4_TRANSIENT);
2008 sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7);
2009 sqlite3VdbeAddOp2(v, OP_ResultRow, 7, 1);
2010 }
2011 #endif /* SQLITE_OMIT_BTREECOUNT */
2012 }
2013 }
2014 addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
2015 sqlite3VdbeChangeP3(v, addr, -mxErr);
2016 sqlite3VdbeJumpHere(v, addr);
2017 sqlite3VdbeChangeP4(v, addr+1, "ok", P4_STATIC);
2018 }
2019 break;
2020 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
2021
2022 #ifndef SQLITE_OMIT_UTF16
2023 /*
2024 ** PRAGMA encoding
2025 ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
2026 **
2027 ** In its first form, this pragma returns the encoding of the main
2028 ** database. If the database is not initialized, it is initialized now.
2029 **
2030 ** The second form of this pragma is a no-op if the main database file
2031 ** has not already been initialized. In this case it sets the default
2032 ** encoding that will be used for the main database file if a new file
2033 ** is created. If an existing main database file is opened, then the
2034 ** default text encoding for the existing database is used.
2035 **
2036 ** In all cases new databases created using the ATTACH command are
2037 ** created to use the same default text encoding as the main database. If
2038 ** the main database has not been initialized and/or created when ATTACH
2039 ** is executed, this is done before the ATTACH operation.
2040 **
2041 ** In the second form this pragma sets the text encoding to be used in
2042 ** new database files created using this database handle. It is only
2043 ** useful if invoked immediately after the main database i
2044 */
2045 case PragTyp_ENCODING: {
2046 static const struct EncName {
2047 char *zName;
2048 u8 enc;
2049 } encnames[] = {
2050 { "UTF8", SQLITE_UTF8 },
2051 { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */
2052 { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */
2053 { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */
2054 { "UTF16le", SQLITE_UTF16LE },
2055 { "UTF16be", SQLITE_UTF16BE },
2056 { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */
2057 { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */
2058 { 0, 0 }
2059 };
2060 const struct EncName *pEnc;
2061 if( !zRight ){ /* "PRAGMA encoding" */
2062 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
2063 sqlite3VdbeSetNumCols(v, 1);
2064 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", SQLITE_STATIC);
2065 sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
2066 assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
2067 assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
2068 assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
2069 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
2070 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
2071 }else{ /* "PRAGMA encoding = XXX" */
2072 /* Only change the value of sqlite.enc if the database handle is not
2073 ** initialized. If the main database exists, the new sqlite.enc value
2074 ** will be overwritten when the schema is next loaded. If it does not
2075 ** already exists, it will be created to use the new encoding value.
2076 */
2077 if(
2078 !(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
2079 DbHasProperty(db, 0, DB_Empty)
2080 ){
2081 for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
2082 if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
2083 ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
2084 break;
2085 }
2086 }
2087 if( !pEnc->zName ){
2088 sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
2089 }
2090 }
2091 }
2092 }
2093 break;
2094 #endif /* SQLITE_OMIT_UTF16 */
2095
2096 #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
2097 /*
2098 ** PRAGMA [database.]schema_version
2099 ** PRAGMA [database.]schema_version = <integer>
2100 **
2101 ** PRAGMA [database.]user_version
2102 ** PRAGMA [database.]user_version = <integer>
2103 **
2104 ** PRAGMA [database.]freelist_count = <integer>
2105 **
2106 ** PRAGMA [database.]application_id
2107 ** PRAGMA [database.]application_id = <integer>
2108 **
2109 ** The pragma's schema_version and user_version are used to set or get
2110 ** the value of the schema-version and user-version, respectively. Both
2111 ** the schema-version and the user-version are 32-bit signed integers
2112 ** stored in the database header.
2113 **
2114 ** The schema-cookie is usually only manipulated internally by SQLite. It
2115 ** is incremented by SQLite whenever the database schema is modified (by
2116 ** creating or dropping a table or index). The schema version is used by
2117 ** SQLite each time a query is executed to ensure that the internal cache
2118 ** of the schema used when compiling the SQL query matches the schema of
2119 ** the database against which the compiled query is actually executed.
2120 ** Subverting this mechanism by using "PRAGMA schema_version" to modify
2121 ** the schema-version is potentially dangerous and may lead to program
2122 ** crashes or database corruption. Use with caution!
2123 **
2124 ** The user-version is not used internally by SQLite. It may be used by
2125 ** applications for any purpose.
2126 */
2127 case PragTyp_HEADER_VALUE: {
2128 int iCookie; /* Cookie index. 1 for schema-cookie, 6 for user-cookie. */
2129 sqlite3VdbeUsesBtree(v, iDb);
2130 switch( zLeft[0] ){
2131 case 'a': case 'A':
2132 iCookie = BTREE_APPLICATION_ID;
2133 break;
2134 case 'f': case 'F':
2135 iCookie = BTREE_FREE_PAGE_COUNT;
2136 break;
2137 case 's': case 'S':
2138 iCookie = BTREE_SCHEMA_VERSION;
2139 break;
2140 default:
2141 iCookie = BTREE_USER_VERSION;
2142 break;
2143 }
2144
2145 if( zRight && iCookie!=BTREE_FREE_PAGE_COUNT ){
2146 /* Write the specified cookie value */
2147 static const VdbeOpList setCookie[] = {
2148 { OP_Transaction, 0, 1, 0}, /* 0 */
2149 { OP_Integer, 0, 1, 0}, /* 1 */
2150 { OP_SetCookie, 0, 0, 1}, /* 2 */
2151 };
2152 int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
2153 sqlite3VdbeChangeP1(v, addr, iDb);
2154 sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight));
2155 sqlite3VdbeChangeP1(v, addr+2, iDb);
2156 sqlite3VdbeChangeP2(v, addr+2, iCookie);
2157 }else{
2158 /* Read the specified cookie value */
2159 static const VdbeOpList readCookie[] = {
2160 { OP_Transaction, 0, 0, 0}, /* 0 */
2161 { OP_ReadCookie, 0, 1, 0}, /* 1 */
2162 { OP_ResultRow, 1, 1, 0}
2163 };
2164 int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie, 0);
2165 sqlite3VdbeChangeP1(v, addr, iDb);
2166 sqlite3VdbeChangeP1(v, addr+1, iDb);
2167 sqlite3VdbeChangeP3(v, addr+1, iCookie);
2168 sqlite3VdbeSetNumCols(v, 1);
2169 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
2170 }
2171 }
2172 break;
2173 #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
2174
2175 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
2176 /*
2177 ** PRAGMA compile_options
2178 **
2179 ** Return the names of all compile-time options used in this build,
2180 ** one option per row.
2181 */
2182 case PragTyp_COMPILE_OPTIONS: {
2183 int i = 0;
2184 const char *zOpt;
2185 sqlite3VdbeSetNumCols(v, 1);
2186 pParse->nMem = 1;
2187 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "compile_option", SQLITE_STATIC);
2188 while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){
2189 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zOpt, 0);
2190 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
2191 }
2192 }
2193 break;
2194 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
2195
2196 #ifndef SQLITE_OMIT_WAL
2197 /*
2198 ** PRAGMA [database.]wal_checkpoint = passive|full|restart
2199 **
2200 ** Checkpoint the database.
2201 */
2202 case PragTyp_WAL_CHECKPOINT: {
2203 int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
2204 int eMode = SQLITE_CHECKPOINT_PASSIVE;
2205 if( zRight ){
2206 if( sqlite3StrICmp(zRight, "full")==0 ){
2207 eMode = SQLITE_CHECKPOINT_FULL;
2208 }else if( sqlite3StrICmp(zRight, "restart")==0 ){
2209 eMode = SQLITE_CHECKPOINT_RESTART;
2210 }
2211 }
2212 sqlite3VdbeSetNumCols(v, 3);
2213 pParse->nMem = 3;
2214 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "busy", SQLITE_STATIC);
2215 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLITE_STATIC);
2216 sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "checkpointed", SQLITE_STATIC);
2217
2218 sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
2219 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
2220 }
2221 break;
2222
2223 /*
2224 ** PRAGMA wal_autocheckpoint
2225 ** PRAGMA wal_autocheckpoint = N
2226 **
2227 ** Configure a database connection to automatically checkpoint a database
2228 ** after accumulating N frames in the log. Or query for the current value
2229 ** of N.
2230 */
2231 case PragTyp_WAL_AUTOCHECKPOINT: {
2232 if( zRight ){
2233 sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight));
2234 }
2235 returnSingleInt(pParse, "wal_autocheckpoint",
2236 db->xWalCallback==sqlite3WalDefaultHook ?
2237 SQLITE_PTR_TO_INT(db->pWalArg) : 0);
2238 }
2239 break;
2240 #endif
2241
2242 /*
2243 ** PRAGMA shrink_memory
2244 **
2245 ** This pragma attempts to free as much memory as possible from the
2246 ** current database connection.
2247 */
2248 case PragTyp_SHRINK_MEMORY: {
2249 sqlite3_db_release_memory(db);
2250 break;
2251 }
2252
2253 /*
2254 ** PRAGMA busy_timeout
2255 ** PRAGMA busy_timeout = N
2256 **
2257 ** Call sqlite3_busy_timeout(db, N). Return the current timeout value
2258 ** if one is set. If no busy handler or a different busy handler is set
2259 ** then 0 is returned. Setting the busy_timeout to 0 or negative
2260 ** disables the timeout.
2261 */
2262 /*case PragTyp_BUSY_TIMEOUT*/ default: {
2263 assert( aPragmaNames[mid].ePragTyp==PragTyp_BUSY_TIMEOUT );
2264 if( zRight ){
2265 sqlite3_busy_timeout(db, sqlite3Atoi(zRight));
2266 }
2267 returnSingleInt(pParse, "timeout", db->busyTimeout);
2268 break;
2269 }
2270
2271 /*
2272 ** PRAGMA soft_heap_limit
2273 ** PRAGMA soft_heap_limit = N
2274 **
2275 ** Call sqlite3_soft_heap_limit64(N). Return the result. If N is omitted,
2276 ** use -1.
2277 */
2278 case PragTyp_SOFT_HEAP_LIMIT: {
2279 sqlite3_int64 N;
2280 if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){
2281 sqlite3_soft_heap_limit64(N);
2282 }
2283 returnSingleInt(pParse, "soft_heap_limit", sqlite3_soft_heap_limit64(-1));
2284 break;
2285 }
2286
2287 /*
2288 ** PRAGMA threads
2289 ** PRAGMA threads = N
2290 **
2291 ** Configure the maximum number of worker threads. Return the new
2292 ** maximum, which might be less than requested.
2293 */
2294 case PragTyp_THREADS: {
2295 sqlite3_int64 N;
2296 if( zRight
2297 && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK
2298 && N>=0
2299 ){
2300 sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, (int)(N&0x7fffffff));
2301 }
2302 returnSingleInt(pParse, "threads",
2303 sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1));
2304 break;
2305 }
2306
2307 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
2308 /*
2309 ** Report the current state of file logs for all databases
2310 */
2311 case PragTyp_LOCK_STATUS: {
2312 static const char *const azLockName[] = {
2313 "unlocked", "shared", "reserved", "pending", "exclusive"
2314 };
2315 int i;
2316 sqlite3VdbeSetNumCols(v, 2);
2317 pParse->nMem = 2;
2318 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", SQLITE_STATIC);
2319 sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", SQLITE_STATIC);
2320 for(i=0; i<db->nDb; i++){
2321 Btree *pBt;
2322 const char *zState = "unknown";
2323 int j;
2324 if( db->aDb[i].zName==0 ) continue;
2325 sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
2326 pBt = db->aDb[i].pBt;
2327 if( pBt==0 || sqlite3BtreePager(pBt)==0 ){
2328 zState = "closed";
2329 }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
2330 SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
2331 zState = azLockName[j];
2332 }
2333 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
2334 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
2335 }
2336 break;
2337 }
2338 #endif
2339
2340 #ifdef SQLITE_HAS_CODEC
2341 case PragTyp_KEY: {
2342 if( zRight ) sqlite3_key_v2(db, zDb, zRight, sqlite3Strlen30(zRight));
2343 break;
2344 }
2345 case PragTyp_REKEY: {
2346 if( zRight ) sqlite3_rekey_v2(db, zDb, zRight, sqlite3Strlen30(zRight));
2347 break;
2348 }
2349 case PragTyp_HEXKEY: {
2350 if( zRight ){
2351 u8 iByte;
2352 int i;
2353 char zKey[40];
2354 for(i=0, iByte=0; i<sizeof(zKey)*2 && sqlite3Isxdigit(zRight[i]); i++){
2355 iByte = (iByte<<4) + sqlite3HexToInt(zRight[i]);
2356 if( (i&1)!=0 ) zKey[i/2] = iByte;
2357 }
2358 if( (zLeft[3] & 0xf)==0xb ){
2359 sqlite3_key_v2(db, zDb, zKey, i/2);
2360 }else{
2361 sqlite3_rekey_v2(db, zDb, zKey, i/2);
2362 }
2363 }
2364 break;
2365 }
2366 #endif
2367 #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)
2368 case PragTyp_ACTIVATE_EXTENSIONS: if( zRight ){
2369 #ifdef SQLITE_HAS_CODEC
2370 if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
2371 sqlite3_activate_see(&zRight[4]);
2372 }
2373 #endif
2374 #ifdef SQLITE_ENABLE_CEROD
2375 if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
2376 sqlite3_activate_cerod(&zRight[6]);
2377 }
2378 #endif
2379 }
2380 break;
2381 #endif
2382
2383 } /* End of the PRAGMA switch */
2384
2385 pragma_out:
2386 sqlite3DbFree(db, zLeft);
2387 sqlite3DbFree(db, zRight);
2388 }
2389
2390 #endif /* SQLITE_OMIT_PRAGMA */