4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains code used to implement the PRAGMA command.
14 #include "sqliteInt.h"
16 #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
17 # if defined(__APPLE__)
18 # define SQLITE_ENABLE_LOCKING_STYLE 1
20 # define SQLITE_ENABLE_LOCKING_STYLE 0
24 /***************************************************************************
25 ** The "pragma.h" include file is an automatically generated file that
26 ** that includes the PragType_XXXX macro definitions and the aPragmaName[]
27 ** object. This ensures that the aPragmaName[] table is arranged in
28 ** lexicographical order to facility a binary search of the pragma name.
29 ** Do not edit pragma.h directly. Edit and rerun the script in at
30 ** ../tool/mkpragmatab.tcl. */
34 ** Interpret the given string as a safety level. Return 0 for OFF,
35 ** 1 for ON or NORMAL, 2 for FULL, and 3 for EXTRA. Return 1 for an empty or
36 ** unrecognized string argument. The FULL and EXTRA option is disallowed
37 ** if the omitFull parameter it 1.
39 ** Note that the values returned are one less that the values that
40 ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done
41 ** to support legacy SQL code. The safety level used to be boolean
42 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
44 static u8
getSafetyLevel(const char *z
, int omitFull
, u8 dflt
){
45 /* 123456789 123456789 123 */
46 static const char zText
[] = "onoffalseyestruextrafull";
47 static const u8 iOffset
[] = {0, 1, 2, 4, 9, 12, 15, 20};
48 static const u8 iLength
[] = {2, 2, 3, 5, 3, 4, 5, 4};
49 static const u8 iValue
[] = {1, 0, 0, 0, 1, 1, 3, 2};
50 /* on no off false yes true extra full */
52 if( sqlite3Isdigit(*z
) ){
53 return (u8
)sqlite3Atoi(z
);
55 n
= sqlite3Strlen30(z
);
56 for(i
=0; i
<ArraySize(iLength
); i
++){
57 if( iLength
[i
]==n
&& sqlite3StrNICmp(&zText
[iOffset
[i
]],z
,n
)==0
58 && (!omitFull
|| iValue
[i
]<=1)
67 ** Interpret the given string as a boolean value.
69 u8
sqlite3GetBoolean(const char *z
, u8 dflt
){
70 return getSafetyLevel(z
,1,dflt
)!=0;
73 /* The sqlite3GetBoolean() function is used by other modules but the
74 ** remainder of this file is specific to PRAGMA processing. So omit
75 ** the rest of the file if PRAGMAs are omitted from the build.
77 #if !defined(SQLITE_OMIT_PRAGMA)
80 ** Interpret the given string as a locking mode value.
82 static int getLockingMode(const char *z
){
84 if( 0==sqlite3StrICmp(z
, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE
;
85 if( 0==sqlite3StrICmp(z
, "normal") ) return PAGER_LOCKINGMODE_NORMAL
;
87 return PAGER_LOCKINGMODE_QUERY
;
90 #ifndef SQLITE_OMIT_AUTOVACUUM
92 ** Interpret the given string as an auto-vacuum mode value.
94 ** The following strings, "none", "full" and "incremental" are
95 ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
97 static int getAutoVacuum(const char *z
){
99 if( 0==sqlite3StrICmp(z
, "none") ) return BTREE_AUTOVACUUM_NONE
;
100 if( 0==sqlite3StrICmp(z
, "full") ) return BTREE_AUTOVACUUM_FULL
;
101 if( 0==sqlite3StrICmp(z
, "incremental") ) return BTREE_AUTOVACUUM_INCR
;
103 return (u8
)((i
>=0&&i
<=2)?i
:0);
105 #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
107 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
109 ** Interpret the given string as a temp db location. Return 1 for file
110 ** backed temporary databases, 2 for the Red-Black tree in memory database
111 ** and 0 to use the compile-time default.
113 static int getTempStore(const char *z
){
114 if( z
[0]>='0' && z
[0]<='2' ){
116 }else if( sqlite3StrICmp(z
, "file")==0 ){
118 }else if( sqlite3StrICmp(z
, "memory")==0 ){
124 #endif /* SQLITE_PAGER_PRAGMAS */
126 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
128 ** Invalidate temp storage, either when the temp storage is changed
129 ** from default, or when 'file' and the temp_store_directory has changed
131 static int invalidateTempStorage(Parse
*pParse
){
132 sqlite3
*db
= pParse
->db
;
133 if( db
->aDb
[1].pBt
!=0 ){
134 if( !db
->autoCommit
|| sqlite3BtreeIsInReadTrans(db
->aDb
[1].pBt
) ){
135 sqlite3ErrorMsg(pParse
, "temporary storage cannot be changed "
136 "from within a transaction");
139 sqlite3BtreeClose(db
->aDb
[1].pBt
);
141 sqlite3ResetAllSchemasOfConnection(db
);
145 #endif /* SQLITE_PAGER_PRAGMAS */
147 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
149 ** If the TEMP database is open, close it and mark the database schema
150 ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
151 ** or DEFAULT_TEMP_STORE pragmas.
153 static int changeTempStorage(Parse
*pParse
, const char *zStorageType
){
154 int ts
= getTempStore(zStorageType
);
155 sqlite3
*db
= pParse
->db
;
156 if( db
->temp_store
==ts
) return SQLITE_OK
;
157 if( invalidateTempStorage( pParse
) != SQLITE_OK
){
160 db
->temp_store
= (u8
)ts
;
163 #endif /* SQLITE_PAGER_PRAGMAS */
166 ** Set result column names for a pragma.
168 static void setPragmaResultColumnNames(
169 Vdbe
*v
, /* The query under construction */
170 const PragmaName
*pPragma
/* The pragma */
172 u8 n
= pPragma
->nPragCName
;
173 sqlite3VdbeSetNumCols(v
, n
==0 ? 1 : n
);
175 sqlite3VdbeSetColName(v
, 0, COLNAME_NAME
, pPragma
->zName
, SQLITE_STATIC
);
178 for(i
=0, j
=pPragma
->iPragCName
; i
<n
; i
++, j
++){
179 sqlite3VdbeSetColName(v
, i
, COLNAME_NAME
, pragCName
[j
], SQLITE_STATIC
);
185 ** Generate code to return a single integer value.
187 static void returnSingleInt(Vdbe
*v
, i64 value
){
188 sqlite3VdbeAddOp4Dup8(v
, OP_Int64
, 0, 1, 0, (const u8
*)&value
, P4_INT64
);
189 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, 1);
193 ** Generate code to return a single text value.
195 static void returnSingleText(
196 Vdbe
*v
, /* Prepared statement under construction */
197 const char *zValue
/* Value to be returned */
200 sqlite3VdbeLoadString(v
, 1, (const char*)zValue
);
201 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, 1);
207 ** Set the safety_level and pager flags for pager iDb. Or if iDb<0
208 ** set these values for all pagers.
210 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
211 static void setAllPagerFlags(sqlite3
*db
){
212 if( db
->autoCommit
){
215 assert( SQLITE_FullFSync
==PAGER_FULLFSYNC
);
216 assert( SQLITE_CkptFullFSync
==PAGER_CKPT_FULLFSYNC
);
217 assert( SQLITE_CacheSpill
==PAGER_CACHESPILL
);
218 assert( (PAGER_FULLFSYNC
| PAGER_CKPT_FULLFSYNC
| PAGER_CACHESPILL
)
219 == PAGER_FLAGS_MASK
);
220 assert( (pDb
->safety_level
& PAGER_SYNCHRONOUS_MASK
)==pDb
->safety_level
);
223 sqlite3BtreeSetPagerFlags(pDb
->pBt
,
224 pDb
->safety_level
| (db
->flags
& PAGER_FLAGS_MASK
) );
231 # define setAllPagerFlags(X) /* no-op */
236 ** Return a human-readable name for a constraint resolution action.
238 #ifndef SQLITE_OMIT_FOREIGN_KEY
239 static const char *actionName(u8 action
){
242 case OE_SetNull
: zName
= "SET NULL"; break;
243 case OE_SetDflt
: zName
= "SET DEFAULT"; break;
244 case OE_Cascade
: zName
= "CASCADE"; break;
245 case OE_Restrict
: zName
= "RESTRICT"; break;
246 default: zName
= "NO ACTION";
247 assert( action
==OE_None
); break;
255 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
256 ** defined in pager.h. This function returns the associated lowercase
257 ** journal-mode name.
259 const char *sqlite3JournalModename(int eMode
){
260 static char * const azModeName
[] = {
261 "delete", "persist", "off", "truncate", "memory"
262 #ifndef SQLITE_OMIT_WAL
266 assert( PAGER_JOURNALMODE_DELETE
==0 );
267 assert( PAGER_JOURNALMODE_PERSIST
==1 );
268 assert( PAGER_JOURNALMODE_OFF
==2 );
269 assert( PAGER_JOURNALMODE_TRUNCATE
==3 );
270 assert( PAGER_JOURNALMODE_MEMORY
==4 );
271 assert( PAGER_JOURNALMODE_WAL
==5 );
272 assert( eMode
>=0 && eMode
<=ArraySize(azModeName
) );
274 if( eMode
==ArraySize(azModeName
) ) return 0;
275 return azModeName
[eMode
];
279 ** Locate a pragma in the aPragmaName[] array.
281 static const PragmaName
*pragmaLocate(const char *zName
){
282 int upr
, lwr
, mid
= 0, rc
;
284 upr
= ArraySize(aPragmaName
)-1;
287 rc
= sqlite3_stricmp(zName
, aPragmaName
[mid
].zName
);
295 return lwr
>upr
? 0 : &aPragmaName
[mid
];
299 ** Helper subroutine for PRAGMA integrity_check:
301 ** Generate code to output a single-column result row with a value of the
302 ** string held in register 3. Decrement the result count in register 1
303 ** and halt if the maximum number of result rows have been issued.
305 static int integrityCheckResultRow(Vdbe
*v
){
307 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 3, 1);
308 addr
= sqlite3VdbeAddOp3(v
, OP_IfPos
, 1, sqlite3VdbeCurrentAddr(v
)+2, 1);
310 sqlite3VdbeAddOp0(v
, OP_Halt
);
315 ** Process a pragma statement.
317 ** Pragmas are of this form:
319 ** PRAGMA [schema.]id [= value]
321 ** The identifier might also be a string. The value is a string, and
322 ** identifier, or a number. If minusFlag is true, then the value is
323 ** a number that was preceded by a minus sign.
325 ** If the left side is "database.id" then pId1 is the database name
326 ** and pId2 is the id. If the left side is just "id" then pId1 is the
327 ** id and pId2 is any empty string.
331 Token
*pId1
, /* First part of [schema.]id field */
332 Token
*pId2
, /* Second part of [schema.]id field, or NULL */
333 Token
*pValue
, /* Token for <value>, or NULL */
334 int minusFlag
/* True if a '-' sign preceded <value> */
336 char *zLeft
= 0; /* Nul-terminated UTF-8 string <id> */
337 char *zRight
= 0; /* Nul-terminated UTF-8 string <value>, or NULL */
338 const char *zDb
= 0; /* The database name */
339 Token
*pId
; /* Pointer to <id> token */
340 char *aFcntl
[4]; /* Argument to SQLITE_FCNTL_PRAGMA */
341 int iDb
; /* Database index for <database> */
342 int rc
; /* return value form SQLITE_FCNTL_PRAGMA */
343 sqlite3
*db
= pParse
->db
; /* The database connection */
344 Db
*pDb
; /* The specific database being pragmaed */
345 Vdbe
*v
= sqlite3GetVdbe(pParse
); /* Prepared statement */
346 const PragmaName
*pPragma
; /* The pragma */
349 sqlite3VdbeRunOnlyOnce(v
);
352 /* Interpret the [schema.] part of the pragma statement. iDb is the
353 ** index of the database this pragma is being applied to in db.aDb[]. */
354 iDb
= sqlite3TwoPartName(pParse
, pId1
, pId2
, &pId
);
358 /* If the temp database has been explicitly named as part of the
359 ** pragma, make sure it is open.
361 if( iDb
==1 && sqlite3OpenTempDatabase(pParse
) ){
365 zLeft
= sqlite3NameFromToken(db
, pId
);
368 zRight
= sqlite3MPrintf(db
, "-%T", pValue
);
370 zRight
= sqlite3NameFromToken(db
, pValue
);
374 zDb
= pId2
->n
>0 ? pDb
->zDbSName
: 0;
375 if( sqlite3AuthCheck(pParse
, SQLITE_PRAGMA
, zLeft
, zRight
, zDb
) ){
379 /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS
380 ** connection. If it returns SQLITE_OK, then assume that the VFS
381 ** handled the pragma and generate a no-op prepared statement.
383 ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed,
384 ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file
385 ** object corresponding to the database file to which the pragma
388 ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA
389 ** file control is an array of pointers to strings (char**) in which the
390 ** second element of the array is the name of the pragma and the third
391 ** element is the argument to the pragma or NULL if the pragma has no
398 db
->busyHandler
.nBusy
= 0;
399 rc
= sqlite3_file_control(db
, zDb
, SQLITE_FCNTL_PRAGMA
, (void*)aFcntl
);
401 sqlite3VdbeSetNumCols(v
, 1);
402 sqlite3VdbeSetColName(v
, 0, COLNAME_NAME
, aFcntl
[0], SQLITE_TRANSIENT
);
403 returnSingleText(v
, aFcntl
[0]);
404 sqlite3_free(aFcntl
[0]);
407 if( rc
!=SQLITE_NOTFOUND
){
409 sqlite3ErrorMsg(pParse
, "%s", aFcntl
[0]);
410 sqlite3_free(aFcntl
[0]);
417 /* Locate the pragma in the lookup table */
418 pPragma
= pragmaLocate(zLeft
);
419 if( pPragma
==0 ) goto pragma_out
;
421 /* Make sure the database schema is loaded if the pragma requires that */
422 if( (pPragma
->mPragFlg
& PragFlg_NeedSchema
)!=0 ){
423 if( sqlite3ReadSchema(pParse
) ) goto pragma_out
;
426 /* Register the result column names for pragmas that return results */
427 if( (pPragma
->mPragFlg
& PragFlg_NoColumns
)==0
428 && ((pPragma
->mPragFlg
& PragFlg_NoColumns1
)==0 || zRight
==0)
430 setPragmaResultColumnNames(v
, pPragma
);
433 /* Jump to the appropriate pragma handler */
434 switch( pPragma
->ePragTyp
){
436 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
438 ** PRAGMA [schema.]default_cache_size
439 ** PRAGMA [schema.]default_cache_size=N
441 ** The first form reports the current persistent setting for the
442 ** page cache size. The value returned is the maximum number of
443 ** pages in the page cache. The second form sets both the current
444 ** page cache size value and the persistent page cache size value
445 ** stored in the database file.
447 ** Older versions of SQLite would set the default cache size to a
448 ** negative number to indicate synchronous=OFF. These days, synchronous
449 ** is always on by default regardless of the sign of the default cache
450 ** size. But continue to take the absolute value of the default cache
451 ** size of historical compatibility.
453 case PragTyp_DEFAULT_CACHE_SIZE
: {
454 static const int iLn
= VDBE_OFFSET_LINENO(2);
455 static const VdbeOpList getCacheSize
[] = {
456 { OP_Transaction
, 0, 0, 0}, /* 0 */
457 { OP_ReadCookie
, 0, 1, BTREE_DEFAULT_CACHE_SIZE
}, /* 1 */
458 { OP_IfPos
, 1, 8, 0},
459 { OP_Integer
, 0, 2, 0},
460 { OP_Subtract
, 1, 2, 1},
461 { OP_IfPos
, 1, 8, 0},
462 { OP_Integer
, 0, 1, 0}, /* 6 */
464 { OP_ResultRow
, 1, 1, 0},
467 sqlite3VdbeUsesBtree(v
, iDb
);
470 sqlite3VdbeVerifyNoMallocRequired(v
, ArraySize(getCacheSize
));
471 aOp
= sqlite3VdbeAddOpList(v
, ArraySize(getCacheSize
), getCacheSize
, iLn
);
472 if( ONLY_IF_REALLOC_STRESS(aOp
==0) ) break;
475 aOp
[6].p1
= SQLITE_DEFAULT_CACHE_SIZE
;
477 int size
= sqlite3AbsInt32(sqlite3Atoi(zRight
));
478 sqlite3BeginWriteOperation(pParse
, 0, iDb
);
479 sqlite3VdbeAddOp3(v
, OP_SetCookie
, iDb
, BTREE_DEFAULT_CACHE_SIZE
, size
);
480 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
481 pDb
->pSchema
->cache_size
= size
;
482 sqlite3BtreeSetCacheSize(pDb
->pBt
, pDb
->pSchema
->cache_size
);
486 #endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */
488 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
490 ** PRAGMA [schema.]page_size
491 ** PRAGMA [schema.]page_size=N
493 ** The first form reports the current setting for the
494 ** database page size in bytes. The second form sets the
495 ** database page size value. The value can only be set if
496 ** the database has not yet been created.
498 case PragTyp_PAGE_SIZE
: {
499 Btree
*pBt
= pDb
->pBt
;
502 int size
= ALWAYS(pBt
) ? sqlite3BtreeGetPageSize(pBt
) : 0;
503 returnSingleInt(v
, size
);
505 /* Malloc may fail when setting the page-size, as there is an internal
506 ** buffer that the pager module resizes using sqlite3_realloc().
508 db
->nextPagesize
= sqlite3Atoi(zRight
);
509 if( SQLITE_NOMEM
==sqlite3BtreeSetPageSize(pBt
, db
->nextPagesize
,-1,0) ){
517 ** PRAGMA [schema.]secure_delete
518 ** PRAGMA [schema.]secure_delete=ON/OFF/FAST
520 ** The first form reports the current setting for the
521 ** secure_delete flag. The second form changes the secure_delete
522 ** flag setting and reports the new value.
524 case PragTyp_SECURE_DELETE
: {
525 Btree
*pBt
= pDb
->pBt
;
529 if( sqlite3_stricmp(zRight
, "fast")==0 ){
532 b
= sqlite3GetBoolean(zRight
, 0);
535 if( pId2
->n
==0 && b
>=0 ){
537 for(ii
=0; ii
<db
->nDb
; ii
++){
538 sqlite3BtreeSecureDelete(db
->aDb
[ii
].pBt
, b
);
541 b
= sqlite3BtreeSecureDelete(pBt
, b
);
542 returnSingleInt(v
, b
);
547 ** PRAGMA [schema.]max_page_count
548 ** PRAGMA [schema.]max_page_count=N
550 ** The first form reports the current setting for the
551 ** maximum number of pages in the database file. The
552 ** second form attempts to change this setting. Both
553 ** forms return the current setting.
555 ** The absolute value of N is used. This is undocumented and might
556 ** change. The only purpose is to provide an easy way to test
557 ** the sqlite3AbsInt32() function.
559 ** PRAGMA [schema.]page_count
561 ** Return the number of pages in the specified database.
563 case PragTyp_PAGE_COUNT
: {
565 sqlite3CodeVerifySchema(pParse
, iDb
);
566 iReg
= ++pParse
->nMem
;
567 if( sqlite3Tolower(zLeft
[0])=='p' ){
568 sqlite3VdbeAddOp2(v
, OP_Pagecount
, iDb
, iReg
);
570 sqlite3VdbeAddOp3(v
, OP_MaxPgcnt
, iDb
, iReg
,
571 sqlite3AbsInt32(sqlite3Atoi(zRight
)));
573 sqlite3VdbeAddOp2(v
, OP_ResultRow
, iReg
, 1);
578 ** PRAGMA [schema.]locking_mode
579 ** PRAGMA [schema.]locking_mode = (normal|exclusive)
581 case PragTyp_LOCKING_MODE
: {
582 const char *zRet
= "normal";
583 int eMode
= getLockingMode(zRight
);
585 if( pId2
->n
==0 && eMode
==PAGER_LOCKINGMODE_QUERY
){
586 /* Simple "PRAGMA locking_mode;" statement. This is a query for
587 ** the current default locking mode (which may be different to
588 ** the locking-mode of the main database).
590 eMode
= db
->dfltLockMode
;
594 /* This indicates that no database name was specified as part
595 ** of the PRAGMA command. In this case the locking-mode must be
596 ** set on all attached databases, as well as the main db file.
598 ** Also, the sqlite3.dfltLockMode variable is set so that
599 ** any subsequently attached databases also use the specified
603 assert(pDb
==&db
->aDb
[0]);
604 for(ii
=2; ii
<db
->nDb
; ii
++){
605 pPager
= sqlite3BtreePager(db
->aDb
[ii
].pBt
);
606 sqlite3PagerLockingMode(pPager
, eMode
);
608 db
->dfltLockMode
= (u8
)eMode
;
610 pPager
= sqlite3BtreePager(pDb
->pBt
);
611 eMode
= sqlite3PagerLockingMode(pPager
, eMode
);
614 assert( eMode
==PAGER_LOCKINGMODE_NORMAL
615 || eMode
==PAGER_LOCKINGMODE_EXCLUSIVE
);
616 if( eMode
==PAGER_LOCKINGMODE_EXCLUSIVE
){
619 returnSingleText(v
, zRet
);
624 ** PRAGMA [schema.]journal_mode
625 ** PRAGMA [schema.]journal_mode =
626 ** (delete|persist|off|truncate|memory|wal|off)
628 case PragTyp_JOURNAL_MODE
: {
629 int eMode
; /* One of the PAGER_JOURNALMODE_XXX symbols */
630 int ii
; /* Loop counter */
633 /* If there is no "=MODE" part of the pragma, do a query for the
635 eMode
= PAGER_JOURNALMODE_QUERY
;
638 int n
= sqlite3Strlen30(zRight
);
639 for(eMode
=0; (zMode
= sqlite3JournalModename(eMode
))!=0; eMode
++){
640 if( sqlite3StrNICmp(zRight
, zMode
, n
)==0 ) break;
643 /* If the "=MODE" part does not match any known journal mode,
644 ** then do a query */
645 eMode
= PAGER_JOURNALMODE_QUERY
;
648 if( eMode
==PAGER_JOURNALMODE_QUERY
&& pId2
->n
==0 ){
649 /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
653 for(ii
=db
->nDb
-1; ii
>=0; ii
--){
654 if( db
->aDb
[ii
].pBt
&& (ii
==iDb
|| pId2
->n
==0) ){
655 sqlite3VdbeUsesBtree(v
, ii
);
656 sqlite3VdbeAddOp3(v
, OP_JournalMode
, ii
, 1, eMode
);
659 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, 1);
664 ** PRAGMA [schema.]journal_size_limit
665 ** PRAGMA [schema.]journal_size_limit=N
667 ** Get or set the size limit on rollback journal files.
669 case PragTyp_JOURNAL_SIZE_LIMIT
: {
670 Pager
*pPager
= sqlite3BtreePager(pDb
->pBt
);
673 sqlite3DecOrHexToI64(zRight
, &iLimit
);
674 if( iLimit
<-1 ) iLimit
= -1;
676 iLimit
= sqlite3PagerJournalSizeLimit(pPager
, iLimit
);
677 returnSingleInt(v
, iLimit
);
681 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
684 ** PRAGMA [schema.]auto_vacuum
685 ** PRAGMA [schema.]auto_vacuum=N
687 ** Get or set the value of the database 'auto-vacuum' parameter.
688 ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL
690 #ifndef SQLITE_OMIT_AUTOVACUUM
691 case PragTyp_AUTO_VACUUM
: {
692 Btree
*pBt
= pDb
->pBt
;
695 returnSingleInt(v
, sqlite3BtreeGetAutoVacuum(pBt
));
697 int eAuto
= getAutoVacuum(zRight
);
698 assert( eAuto
>=0 && eAuto
<=2 );
699 db
->nextAutovac
= (u8
)eAuto
;
700 /* Call SetAutoVacuum() to set initialize the internal auto and
701 ** incr-vacuum flags. This is required in case this connection
702 ** creates the database file. It is important that it is created
703 ** as an auto-vacuum capable db.
705 rc
= sqlite3BtreeSetAutoVacuum(pBt
, eAuto
);
706 if( rc
==SQLITE_OK
&& (eAuto
==1 || eAuto
==2) ){
707 /* When setting the auto_vacuum mode to either "full" or
708 ** "incremental", write the value of meta[6] in the database
709 ** file. Before writing to meta[6], check that meta[3] indicates
710 ** that this really is an auto-vacuum capable database.
712 static const int iLn
= VDBE_OFFSET_LINENO(2);
713 static const VdbeOpList setMeta6
[] = {
714 { OP_Transaction
, 0, 1, 0}, /* 0 */
715 { OP_ReadCookie
, 0, 1, BTREE_LARGEST_ROOT_PAGE
},
716 { OP_If
, 1, 0, 0}, /* 2 */
717 { OP_Halt
, SQLITE_OK
, OE_Abort
, 0}, /* 3 */
718 { OP_SetCookie
, 0, BTREE_INCR_VACUUM
, 0}, /* 4 */
721 int iAddr
= sqlite3VdbeCurrentAddr(v
);
722 sqlite3VdbeVerifyNoMallocRequired(v
, ArraySize(setMeta6
));
723 aOp
= sqlite3VdbeAddOpList(v
, ArraySize(setMeta6
), setMeta6
, iLn
);
724 if( ONLY_IF_REALLOC_STRESS(aOp
==0) ) break;
729 aOp
[4].p3
= eAuto
- 1;
730 sqlite3VdbeUsesBtree(v
, iDb
);
738 ** PRAGMA [schema.]incremental_vacuum(N)
740 ** Do N steps of incremental vacuuming on a database.
742 #ifndef SQLITE_OMIT_AUTOVACUUM
743 case PragTyp_INCREMENTAL_VACUUM
: {
745 if( zRight
==0 || !sqlite3GetInt32(zRight
, &iLimit
) || iLimit
<=0 ){
748 sqlite3BeginWriteOperation(pParse
, 0, iDb
);
749 sqlite3VdbeAddOp2(v
, OP_Integer
, iLimit
, 1);
750 addr
= sqlite3VdbeAddOp1(v
, OP_IncrVacuum
, iDb
); VdbeCoverage(v
);
751 sqlite3VdbeAddOp1(v
, OP_ResultRow
, 1);
752 sqlite3VdbeAddOp2(v
, OP_AddImm
, 1, -1);
753 sqlite3VdbeAddOp2(v
, OP_IfPos
, 1, addr
); VdbeCoverage(v
);
754 sqlite3VdbeJumpHere(v
, addr
);
759 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
761 ** PRAGMA [schema.]cache_size
762 ** PRAGMA [schema.]cache_size=N
764 ** The first form reports the current local setting for the
765 ** page cache size. The second form sets the local
766 ** page cache size value. If N is positive then that is the
767 ** number of pages in the cache. If N is negative, then the
768 ** number of pages is adjusted so that the cache uses -N kibibytes
771 case PragTyp_CACHE_SIZE
: {
772 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
774 returnSingleInt(v
, pDb
->pSchema
->cache_size
);
776 int size
= sqlite3Atoi(zRight
);
777 pDb
->pSchema
->cache_size
= size
;
778 sqlite3BtreeSetCacheSize(pDb
->pBt
, pDb
->pSchema
->cache_size
);
784 ** PRAGMA [schema.]cache_spill
785 ** PRAGMA cache_spill=BOOLEAN
786 ** PRAGMA [schema.]cache_spill=N
788 ** The first form reports the current local setting for the
789 ** page cache spill size. The second form turns cache spill on
790 ** or off. When turnning cache spill on, the size is set to the
791 ** current cache_size. The third form sets a spill size that
792 ** may be different form the cache size.
793 ** If N is positive then that is the
794 ** number of pages in the cache. If N is negative, then the
795 ** number of pages is adjusted so that the cache uses -N kibibytes
798 ** If the number of cache_spill pages is less then the number of
799 ** cache_size pages, no spilling occurs until the page count exceeds
800 ** the number of cache_size pages.
802 ** The cache_spill=BOOLEAN setting applies to all attached schemas,
803 ** not just the schema specified.
805 case PragTyp_CACHE_SPILL
: {
806 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
809 (db
->flags
& SQLITE_CacheSpill
)==0 ? 0 :
810 sqlite3BtreeSetSpillSize(pDb
->pBt
,0));
813 if( sqlite3GetInt32(zRight
, &size
) ){
814 sqlite3BtreeSetSpillSize(pDb
->pBt
, size
);
816 if( sqlite3GetBoolean(zRight
, size
!=0) ){
817 db
->flags
|= SQLITE_CacheSpill
;
819 db
->flags
&= ~SQLITE_CacheSpill
;
821 setAllPagerFlags(db
);
827 ** PRAGMA [schema.]mmap_size(N)
829 ** Used to set mapping size limit. The mapping size limit is
830 ** used to limit the aggregate size of all memory mapped regions of the
831 ** database file. If this parameter is set to zero, then memory mapping
832 ** is not used at all. If N is negative, then the default memory map
833 ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.
834 ** The parameter N is measured in bytes.
836 ** This value is advisory. The underlying VFS is free to memory map
837 ** as little or as much as it wants. Except, if N is set to 0 then the
838 ** upper layers will never invoke the xFetch interfaces to the VFS.
840 case PragTyp_MMAP_SIZE
: {
842 #if SQLITE_MAX_MMAP_SIZE>0
843 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
846 sqlite3DecOrHexToI64(zRight
, &sz
);
847 if( sz
<0 ) sz
= sqlite3GlobalConfig
.szMmap
;
848 if( pId2
->n
==0 ) db
->szMmap
= sz
;
849 for(ii
=db
->nDb
-1; ii
>=0; ii
--){
850 if( db
->aDb
[ii
].pBt
&& (ii
==iDb
|| pId2
->n
==0) ){
851 sqlite3BtreeSetMmapLimit(db
->aDb
[ii
].pBt
, sz
);
856 rc
= sqlite3_file_control(db
, zDb
, SQLITE_FCNTL_MMAP_SIZE
, &sz
);
862 returnSingleInt(v
, sz
);
863 }else if( rc
!=SQLITE_NOTFOUND
){
872 ** PRAGMA temp_store = "default"|"memory"|"file"
874 ** Return or set the local value of the temp_store flag. Changing
875 ** the local value does not make changes to the disk file and the default
876 ** value will be restored the next time the database is opened.
878 ** Note that it is possible for the library compile-time options to
879 ** override this setting
881 case PragTyp_TEMP_STORE
: {
883 returnSingleInt(v
, db
->temp_store
);
885 changeTempStorage(pParse
, zRight
);
891 ** PRAGMA temp_store_directory
892 ** PRAGMA temp_store_directory = ""|"directory_name"
894 ** Return or set the local value of the temp_store_directory flag. Changing
895 ** the value sets a specific directory to be used for temporary files.
896 ** Setting to a null string reverts to the default temporary directory search.
897 ** If temporary directory is changed, then invalidateTempStorage.
900 case PragTyp_TEMP_STORE_DIRECTORY
: {
902 returnSingleText(v
, sqlite3_temp_directory
);
904 #ifndef SQLITE_OMIT_WSD
907 rc
= sqlite3OsAccess(db
->pVfs
, zRight
, SQLITE_ACCESS_READWRITE
, &res
);
908 if( rc
!=SQLITE_OK
|| res
==0 ){
909 sqlite3ErrorMsg(pParse
, "not a writable directory");
913 if( SQLITE_TEMP_STORE
==0
914 || (SQLITE_TEMP_STORE
==1 && db
->temp_store
<=1)
915 || (SQLITE_TEMP_STORE
==2 && db
->temp_store
==1)
917 invalidateTempStorage(pParse
);
919 sqlite3_free(sqlite3_temp_directory
);
921 sqlite3_temp_directory
= sqlite3_mprintf("%s", zRight
);
923 sqlite3_temp_directory
= 0;
925 #endif /* SQLITE_OMIT_WSD */
932 ** PRAGMA data_store_directory
933 ** PRAGMA data_store_directory = ""|"directory_name"
935 ** Return or set the local value of the data_store_directory flag. Changing
936 ** the value sets a specific directory to be used for database files that
937 ** were specified with a relative pathname. Setting to a null string reverts
938 ** to the default database directory, which for database files specified with
939 ** a relative path will probably be based on the current directory for the
940 ** process. Database file specified with an absolute path are not impacted
941 ** by this setting, regardless of its value.
944 case PragTyp_DATA_STORE_DIRECTORY
: {
946 returnSingleText(v
, sqlite3_data_directory
);
948 #ifndef SQLITE_OMIT_WSD
951 rc
= sqlite3OsAccess(db
->pVfs
, zRight
, SQLITE_ACCESS_READWRITE
, &res
);
952 if( rc
!=SQLITE_OK
|| res
==0 ){
953 sqlite3ErrorMsg(pParse
, "not a writable directory");
957 sqlite3_free(sqlite3_data_directory
);
959 sqlite3_data_directory
= sqlite3_mprintf("%s", zRight
);
961 sqlite3_data_directory
= 0;
963 #endif /* SQLITE_OMIT_WSD */
969 #if SQLITE_ENABLE_LOCKING_STYLE
971 ** PRAGMA [schema.]lock_proxy_file
972 ** PRAGMA [schema.]lock_proxy_file = ":auto:"|"lock_file_path"
974 ** Return or set the value of the lock_proxy_file flag. Changing
975 ** the value sets a specific file to be used for database access locks.
978 case PragTyp_LOCK_PROXY_FILE
: {
980 Pager
*pPager
= sqlite3BtreePager(pDb
->pBt
);
981 char *proxy_file_path
= NULL
;
982 sqlite3_file
*pFile
= sqlite3PagerFile(pPager
);
983 sqlite3OsFileControlHint(pFile
, SQLITE_GET_LOCKPROXYFILE
,
985 returnSingleText(v
, proxy_file_path
);
987 Pager
*pPager
= sqlite3BtreePager(pDb
->pBt
);
988 sqlite3_file
*pFile
= sqlite3PagerFile(pPager
);
991 res
=sqlite3OsFileControl(pFile
, SQLITE_SET_LOCKPROXYFILE
,
994 res
=sqlite3OsFileControl(pFile
, SQLITE_SET_LOCKPROXYFILE
,
997 if( res
!=SQLITE_OK
){
998 sqlite3ErrorMsg(pParse
, "failed to set lock proxy file");
1004 #endif /* SQLITE_ENABLE_LOCKING_STYLE */
1007 ** PRAGMA [schema.]synchronous
1008 ** PRAGMA [schema.]synchronous=OFF|ON|NORMAL|FULL|EXTRA
1010 ** Return or set the local value of the synchronous flag. Changing
1011 ** the local value does not make changes to the disk file and the
1012 ** default value will be restored the next time the database is
1015 case PragTyp_SYNCHRONOUS
: {
1017 returnSingleInt(v
, pDb
->safety_level
-1);
1019 if( !db
->autoCommit
){
1020 sqlite3ErrorMsg(pParse
,
1021 "Safety level may not be changed inside a transaction");
1023 int iLevel
= (getSafetyLevel(zRight
,0,1)+1) & PAGER_SYNCHRONOUS_MASK
;
1024 if( iLevel
==0 ) iLevel
= 1;
1025 pDb
->safety_level
= iLevel
;
1027 setAllPagerFlags(db
);
1032 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
1034 #ifndef SQLITE_OMIT_FLAG_PRAGMAS
1035 case PragTyp_FLAG
: {
1037 setPragmaResultColumnNames(v
, pPragma
);
1038 returnSingleInt(v
, (db
->flags
& pPragma
->iArg
)!=0 );
1040 int mask
= pPragma
->iArg
; /* Mask of bits to set or clear. */
1041 if( db
->autoCommit
==0 ){
1042 /* Foreign key support may not be enabled or disabled while not
1043 ** in auto-commit mode. */
1044 mask
&= ~(SQLITE_ForeignKeys
);
1046 #if SQLITE_USER_AUTHENTICATION
1047 if( db
->auth
.authLevel
==UAUTH_User
){
1048 /* Do not allow non-admin users to modify the schema arbitrarily */
1049 mask
&= ~(SQLITE_WriteSchema
);
1053 if( sqlite3GetBoolean(zRight
, 0) ){
1057 if( mask
==SQLITE_DeferFKs
) db
->nDeferredImmCons
= 0;
1060 /* Many of the flag-pragmas modify the code generated by the SQL
1061 ** compiler (eg. count_changes). So add an opcode to expire all
1062 ** compiled SQL statements after modifying a pragma value.
1064 sqlite3VdbeAddOp0(v
, OP_Expire
);
1065 setAllPagerFlags(db
);
1069 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
1071 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
1073 ** PRAGMA table_info(<table>)
1075 ** Return a single row for each column of the named table. The columns of
1076 ** the returned data set are:
1078 ** cid: Column id (numbered from left to right, starting at 0)
1079 ** name: Column name
1080 ** type: Column declaration type.
1081 ** notnull: True if 'NOT NULL' is part of column declaration
1082 ** dflt_value: The default value for the column, if any.
1084 case PragTyp_TABLE_INFO
: if( zRight
){
1086 pTab
= sqlite3LocateTable(pParse
, LOCATE_NOERR
, zRight
, zDb
);
1091 Index
*pPk
= sqlite3PrimaryKeyIndex(pTab
);
1093 sqlite3CodeVerifySchema(pParse
, iDb
);
1094 sqlite3ViewGetColumnNames(pParse
, pTab
);
1095 for(i
=0, pCol
=pTab
->aCol
; i
<pTab
->nCol
; i
++, pCol
++){
1096 if( IsHiddenColumn(pCol
) ){
1100 if( (pCol
->colFlags
& COLFLAG_PRIMKEY
)==0 ){
1105 for(k
=1; k
<=pTab
->nCol
&& pPk
->aiColumn
[k
-1]!=i
; k
++){}
1107 assert( pCol
->pDflt
==0 || pCol
->pDflt
->op
==TK_SPAN
);
1108 sqlite3VdbeMultiLoad(v
, 1, "issisi",
1111 sqlite3ColumnType(pCol
,""),
1112 pCol
->notNull
? 1 : 0,
1113 pCol
->pDflt
? pCol
->pDflt
->u
.zToken
: 0,
1121 case PragTyp_STATS
: {
1125 sqlite3CodeVerifySchema(pParse
, iDb
);
1126 for(i
=sqliteHashFirst(&pDb
->pSchema
->tblHash
); i
; i
=sqliteHashNext(i
)){
1127 Table
*pTab
= sqliteHashData(i
);
1128 sqlite3VdbeMultiLoad(v
, 1, "ssiii",
1134 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
1135 sqlite3VdbeMultiLoad(v
, 2, "siiiX",
1138 pIdx
->aiRowLogEst
[0],
1140 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, 5);
1147 case PragTyp_INDEX_INFO
: if( zRight
){
1150 pIdx
= sqlite3FindIndex(db
, zRight
, zDb
);
1154 if( pPragma
->iArg
){
1155 /* PRAGMA index_xinfo (newer version with more rows and columns) */
1159 /* PRAGMA index_info (legacy version) */
1163 pTab
= pIdx
->pTable
;
1164 sqlite3CodeVerifySchema(pParse
, iDb
);
1165 assert( pParse
->nMem
<=pPragma
->nPragCName
);
1166 for(i
=0; i
<mx
; i
++){
1167 i16 cnum
= pIdx
->aiColumn
[i
];
1168 sqlite3VdbeMultiLoad(v
, 1, "iisX", i
, cnum
,
1169 cnum
<0 ? 0 : pTab
->aCol
[cnum
].zName
);
1170 if( pPragma
->iArg
){
1171 sqlite3VdbeMultiLoad(v
, 4, "isiX",
1172 pIdx
->aSortOrder
[i
],
1176 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, pParse
->nMem
);
1182 case PragTyp_INDEX_LIST
: if( zRight
){
1186 pTab
= sqlite3FindTable(db
, zRight
, zDb
);
1189 sqlite3CodeVerifySchema(pParse
, iDb
);
1190 for(pIdx
=pTab
->pIndex
, i
=0; pIdx
; pIdx
=pIdx
->pNext
, i
++){
1191 const char *azOrigin
[] = { "c", "u", "pk" };
1192 sqlite3VdbeMultiLoad(v
, 1, "isisi",
1195 IsUniqueIndex(pIdx
),
1196 azOrigin
[pIdx
->idxType
],
1197 pIdx
->pPartIdxWhere
!=0);
1203 case PragTyp_DATABASE_LIST
: {
1206 for(i
=0; i
<db
->nDb
; i
++){
1207 if( db
->aDb
[i
].pBt
==0 ) continue;
1208 assert( db
->aDb
[i
].zDbSName
!=0 );
1209 sqlite3VdbeMultiLoad(v
, 1, "iss",
1211 db
->aDb
[i
].zDbSName
,
1212 sqlite3BtreeGetFilename(db
->aDb
[i
].pBt
));
1217 case PragTyp_COLLATION_LIST
: {
1221 for(p
=sqliteHashFirst(&db
->aCollSeq
); p
; p
=sqliteHashNext(p
)){
1222 CollSeq
*pColl
= (CollSeq
*)sqliteHashData(p
);
1223 sqlite3VdbeMultiLoad(v
, 1, "is", i
++, pColl
->zName
);
1228 #ifdef SQLITE_INTROSPECTION_PRAGMAS
1229 case PragTyp_FUNCTION_LIST
: {
1234 for(i
=0; i
<SQLITE_FUNC_HASH_SZ
; i
++){
1235 for(p
=sqlite3BuiltinFunctions
.a
[i
]; p
; p
=p
->u
.pHash
){
1236 sqlite3VdbeMultiLoad(v
, 1, "si", p
->zName
, 1);
1239 for(j
=sqliteHashFirst(&db
->aFunc
); j
; j
=sqliteHashNext(j
)){
1240 p
= (FuncDef
*)sqliteHashData(j
);
1241 sqlite3VdbeMultiLoad(v
, 1, "si", p
->zName
, 0);
1246 #ifndef SQLITE_OMIT_VIRTUALTABLE
1247 case PragTyp_MODULE_LIST
: {
1250 for(j
=sqliteHashFirst(&db
->aModule
); j
; j
=sqliteHashNext(j
)){
1251 Module
*pMod
= (Module
*)sqliteHashData(j
);
1252 sqlite3VdbeMultiLoad(v
, 1, "s", pMod
->zName
);
1256 #endif /* SQLITE_OMIT_VIRTUALTABLE */
1258 case PragTyp_PRAGMA_LIST
: {
1260 for(i
=0; i
<ArraySize(aPragmaName
); i
++){
1261 sqlite3VdbeMultiLoad(v
, 1, "s", aPragmaName
[i
].zName
);
1265 #endif /* SQLITE_INTROSPECTION_PRAGMAS */
1267 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
1269 #ifndef SQLITE_OMIT_FOREIGN_KEY
1270 case PragTyp_FOREIGN_KEY_LIST
: if( zRight
){
1273 pTab
= sqlite3FindTable(db
, zRight
, zDb
);
1279 sqlite3CodeVerifySchema(pParse
, iDb
);
1282 for(j
=0; j
<pFK
->nCol
; j
++){
1283 sqlite3VdbeMultiLoad(v
, 1, "iissssss",
1287 pTab
->aCol
[pFK
->aCol
[j
].iFrom
].zName
,
1289 actionName(pFK
->aAction
[1]), /* ON UPDATE */
1290 actionName(pFK
->aAction
[0]), /* ON DELETE */
1294 pFK
= pFK
->pNextFrom
;
1300 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1302 #ifndef SQLITE_OMIT_FOREIGN_KEY
1303 #ifndef SQLITE_OMIT_TRIGGER
1304 case PragTyp_FOREIGN_KEY_CHECK
: {
1305 FKey
*pFK
; /* A foreign key constraint */
1306 Table
*pTab
; /* Child table contain "REFERENCES" keyword */
1307 Table
*pParent
; /* Parent table that child points to */
1308 Index
*pIdx
; /* Index in the parent table */
1309 int i
; /* Loop counter: Foreign key number for pTab */
1310 int j
; /* Loop counter: Field of the foreign key */
1311 HashElem
*k
; /* Loop counter: Next table in schema */
1312 int x
; /* result variable */
1313 int regResult
; /* 3 registers to hold a result row */
1314 int regKey
; /* Register to hold key for checking the FK */
1315 int regRow
; /* Registers to hold a row from pTab */
1316 int addrTop
; /* Top of a loop checking foreign keys */
1317 int addrOk
; /* Jump here if the key is OK */
1318 int *aiCols
; /* child to parent column mapping */
1320 regResult
= pParse
->nMem
+1;
1322 regKey
= ++pParse
->nMem
;
1323 regRow
= ++pParse
->nMem
;
1324 sqlite3CodeVerifySchema(pParse
, iDb
);
1325 k
= sqliteHashFirst(&db
->aDb
[iDb
].pSchema
->tblHash
);
1328 pTab
= sqlite3LocateTable(pParse
, 0, zRight
, zDb
);
1331 pTab
= (Table
*)sqliteHashData(k
);
1332 k
= sqliteHashNext(k
);
1334 if( pTab
==0 || pTab
->pFKey
==0 ) continue;
1335 sqlite3TableLock(pParse
, iDb
, pTab
->tnum
, 0, pTab
->zName
);
1336 if( pTab
->nCol
+regRow
>pParse
->nMem
) pParse
->nMem
= pTab
->nCol
+ regRow
;
1337 sqlite3OpenTable(pParse
, 0, iDb
, pTab
, OP_OpenRead
);
1338 sqlite3VdbeLoadString(v
, regResult
, pTab
->zName
);
1339 for(i
=1, pFK
=pTab
->pFKey
; pFK
; i
++, pFK
=pFK
->pNextFrom
){
1340 pParent
= sqlite3FindTable(db
, pFK
->zTo
, zDb
);
1341 if( pParent
==0 ) continue;
1343 sqlite3TableLock(pParse
, iDb
, pParent
->tnum
, 0, pParent
->zName
);
1344 x
= sqlite3FkLocateIndex(pParse
, pParent
, pFK
, &pIdx
, 0);
1347 sqlite3OpenTable(pParse
, i
, iDb
, pParent
, OP_OpenRead
);
1349 sqlite3VdbeAddOp3(v
, OP_OpenRead
, i
, pIdx
->tnum
, iDb
);
1350 sqlite3VdbeSetP4KeyInfo(pParse
, pIdx
);
1357 assert( pParse
->nErr
>0 || pFK
==0 );
1359 if( pParse
->nTab
<i
) pParse
->nTab
= i
;
1360 addrTop
= sqlite3VdbeAddOp1(v
, OP_Rewind
, 0); VdbeCoverage(v
);
1361 for(i
=1, pFK
=pTab
->pFKey
; pFK
; i
++, pFK
=pFK
->pNextFrom
){
1362 pParent
= sqlite3FindTable(db
, pFK
->zTo
, zDb
);
1366 x
= sqlite3FkLocateIndex(pParse
, pParent
, pFK
, &pIdx
, &aiCols
);
1369 addrOk
= sqlite3VdbeMakeLabel(v
);
1371 /* Generate code to read the child key values into registers
1372 ** regRow..regRow+n. If any of the child key values are NULL, this
1373 ** row cannot cause an FK violation. Jump directly to addrOk in
1375 for(j
=0; j
<pFK
->nCol
; j
++){
1376 int iCol
= aiCols
? aiCols
[j
] : pFK
->aCol
[j
].iFrom
;
1377 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, 0, iCol
, regRow
+j
);
1378 sqlite3VdbeAddOp2(v
, OP_IsNull
, regRow
+j
, addrOk
); VdbeCoverage(v
);
1381 /* Generate code to query the parent index for a matching parent
1382 ** key. If a match is found, jump to addrOk. */
1384 sqlite3VdbeAddOp4(v
, OP_MakeRecord
, regRow
, pFK
->nCol
, regKey
,
1385 sqlite3IndexAffinityStr(db
,pIdx
), pFK
->nCol
);
1386 sqlite3VdbeAddOp4Int(v
, OP_Found
, i
, addrOk
, regKey
, 0);
1388 }else if( pParent
){
1389 int jmp
= sqlite3VdbeCurrentAddr(v
)+2;
1390 sqlite3VdbeAddOp3(v
, OP_SeekRowid
, i
, jmp
, regRow
); VdbeCoverage(v
);
1391 sqlite3VdbeGoto(v
, addrOk
);
1392 assert( pFK
->nCol
==1 );
1395 /* Generate code to report an FK violation to the caller. */
1396 if( HasRowid(pTab
) ){
1397 sqlite3VdbeAddOp2(v
, OP_Rowid
, 0, regResult
+1);
1399 sqlite3VdbeAddOp2(v
, OP_Null
, 0, regResult
+1);
1401 sqlite3VdbeMultiLoad(v
, regResult
+2, "siX", pFK
->zTo
, i
-1);
1402 sqlite3VdbeAddOp2(v
, OP_ResultRow
, regResult
, 4);
1403 sqlite3VdbeResolveLabel(v
, addrOk
);
1404 sqlite3DbFree(db
, aiCols
);
1406 sqlite3VdbeAddOp2(v
, OP_Next
, 0, addrTop
+1); VdbeCoverage(v
);
1407 sqlite3VdbeJumpHere(v
, addrTop
);
1411 #endif /* !defined(SQLITE_OMIT_TRIGGER) */
1412 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1415 case PragTyp_PARSER_TRACE
: {
1417 if( sqlite3GetBoolean(zRight
, 0) ){
1418 sqlite3ParserTrace(stdout
, "parser: ");
1420 sqlite3ParserTrace(0, 0);
1427 /* Reinstall the LIKE and GLOB functions. The variant of LIKE
1428 ** used will be case sensitive or not depending on the RHS.
1430 case PragTyp_CASE_SENSITIVE_LIKE
: {
1432 sqlite3RegisterLikeFunctions(db
, sqlite3GetBoolean(zRight
, 0));
1437 #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
1438 # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
1441 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
1442 /* PRAGMA integrity_check
1443 ** PRAGMA integrity_check(N)
1444 ** PRAGMA quick_check
1445 ** PRAGMA quick_check(N)
1447 ** Verify the integrity of the database.
1449 ** The "quick_check" is reduced version of
1450 ** integrity_check designed to detect most database corruption
1451 ** without the overhead of cross-checking indexes. Quick_check
1452 ** is linear time wherease integrity_check is O(NlogN).
1454 case PragTyp_INTEGRITY_CHECK
: {
1455 int i
, j
, addr
, mxErr
;
1457 int isQuick
= (sqlite3Tolower(zLeft
[0])=='q');
1459 /* If the PRAGMA command was of the form "PRAGMA <db>.integrity_check",
1460 ** then iDb is set to the index of the database identified by <db>.
1461 ** In this case, the integrity of database iDb only is verified by
1462 ** the VDBE created below.
1464 ** Otherwise, if the command was simply "PRAGMA integrity_check" (or
1465 ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
1466 ** to -1 here, to indicate that the VDBE should verify the integrity
1467 ** of all attached databases. */
1469 assert( iDb
==0 || pId2
->z
);
1470 if( pId2
->z
==0 ) iDb
= -1;
1472 /* Initialize the VDBE program */
1475 /* Set the maximum error count */
1476 mxErr
= SQLITE_INTEGRITY_CHECK_ERROR_MAX
;
1478 sqlite3GetInt32(zRight
, &mxErr
);
1480 mxErr
= SQLITE_INTEGRITY_CHECK_ERROR_MAX
;
1483 sqlite3VdbeAddOp2(v
, OP_Integer
, mxErr
-1, 1); /* reg[1] holds errors left */
1485 /* Do an integrity check on each database file */
1486 for(i
=0; i
<db
->nDb
; i
++){
1487 HashElem
*x
; /* For looping over tables in the schema */
1488 Hash
*pTbls
; /* Set of all tables in the schema */
1489 int *aRoot
; /* Array of root page numbers of all btrees */
1490 int cnt
= 0; /* Number of entries in aRoot[] */
1491 int mxIdx
= 0; /* Maximum number of indexes for any table */
1493 if( OMIT_TEMPDB
&& i
==1 ) continue;
1494 if( iDb
>=0 && i
!=iDb
) continue;
1496 sqlite3CodeVerifySchema(pParse
, i
);
1498 /* Do an integrity check of the B-Tree
1500 ** Begin by finding the root pages numbers
1501 ** for all tables and indices in the database.
1503 assert( sqlite3SchemaMutexHeld(db
, i
, 0) );
1504 pTbls
= &db
->aDb
[i
].pSchema
->tblHash
;
1505 for(cnt
=0, x
=sqliteHashFirst(pTbls
); x
; x
=sqliteHashNext(x
)){
1506 Table
*pTab
= sqliteHashData(x
); /* Current table */
1507 Index
*pIdx
; /* An index on pTab */
1508 int nIdx
; /* Number of indexes on pTab */
1509 if( HasRowid(pTab
) ) cnt
++;
1510 for(nIdx
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, nIdx
++){ cnt
++; }
1511 if( nIdx
>mxIdx
) mxIdx
= nIdx
;
1513 aRoot
= sqlite3DbMallocRawNN(db
, sizeof(int)*(cnt
+1));
1514 if( aRoot
==0 ) break;
1515 for(cnt
=0, x
=sqliteHashFirst(pTbls
); x
; x
=sqliteHashNext(x
)){
1516 Table
*pTab
= sqliteHashData(x
);
1518 if( HasRowid(pTab
) ) aRoot
[++cnt
] = pTab
->tnum
;
1519 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
1520 aRoot
[++cnt
] = pIdx
->tnum
;
1525 /* Make sure sufficient number of registers have been allocated */
1526 pParse
->nMem
= MAX( pParse
->nMem
, 8+mxIdx
);
1527 sqlite3ClearTempRegCache(pParse
);
1529 /* Do the b-tree integrity checks */
1530 sqlite3VdbeAddOp4(v
, OP_IntegrityCk
, 2, cnt
, 1, (char*)aRoot
,P4_INTARRAY
);
1531 sqlite3VdbeChangeP5(v
, (u8
)i
);
1532 addr
= sqlite3VdbeAddOp1(v
, OP_IsNull
, 2); VdbeCoverage(v
);
1533 sqlite3VdbeAddOp4(v
, OP_String8
, 0, 3, 0,
1534 sqlite3MPrintf(db
, "*** in database %s ***\n", db
->aDb
[i
].zDbSName
),
1536 sqlite3VdbeAddOp3(v
, OP_Concat
, 2, 3, 3);
1537 integrityCheckResultRow(v
);
1538 sqlite3VdbeJumpHere(v
, addr
);
1540 /* Make sure all the indices are constructed correctly.
1542 for(x
=sqliteHashFirst(pTbls
); x
; x
=sqliteHashNext(x
)){
1543 Table
*pTab
= sqliteHashData(x
);
1547 int iDataCur
, iIdxCur
;
1550 if( pTab
->tnum
<1 ) continue; /* Skip VIEWs or VIRTUAL TABLEs */
1551 pPk
= HasRowid(pTab
) ? 0 : sqlite3PrimaryKeyIndex(pTab
);
1552 sqlite3ExprCacheClear(pParse
);
1553 sqlite3OpenTableAndIndices(pParse
, pTab
, OP_OpenRead
, 0,
1554 1, 0, &iDataCur
, &iIdxCur
);
1555 /* reg[7] counts the number of entries in the table.
1556 ** reg[8+i] counts the number of entries in the i-th index
1558 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, 7);
1559 for(j
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, j
++){
1560 sqlite3VdbeAddOp2(v
, OP_Integer
, 0, 8+j
); /* index entries counter */
1562 assert( pParse
->nMem
>=8+j
);
1563 assert( sqlite3NoTempsInRange(pParse
,1,7+j
) );
1564 sqlite3VdbeAddOp2(v
, OP_Rewind
, iDataCur
, 0); VdbeCoverage(v
);
1565 loopTop
= sqlite3VdbeAddOp2(v
, OP_AddImm
, 7, 1);
1566 /* Verify that all NOT NULL columns really are NOT NULL */
1567 for(j
=0; j
<pTab
->nCol
; j
++){
1570 if( j
==pTab
->iPKey
) continue;
1571 if( pTab
->aCol
[j
].notNull
==0 ) continue;
1572 sqlite3ExprCodeGetColumnOfTable(v
, pTab
, iDataCur
, j
, 3);
1573 sqlite3VdbeChangeP5(v
, OPFLAG_TYPEOFARG
);
1574 jmp2
= sqlite3VdbeAddOp1(v
, OP_NotNull
, 3); VdbeCoverage(v
);
1575 zErr
= sqlite3MPrintf(db
, "NULL value in %s.%s", pTab
->zName
,
1576 pTab
->aCol
[j
].zName
);
1577 sqlite3VdbeAddOp4(v
, OP_String8
, 0, 3, 0, zErr
, P4_DYNAMIC
);
1578 integrityCheckResultRow(v
);
1579 sqlite3VdbeJumpHere(v
, jmp2
);
1581 /* Verify CHECK constraints */
1582 if( pTab
->pCheck
&& (db
->flags
& SQLITE_IgnoreChecks
)==0 ){
1583 ExprList
*pCheck
= sqlite3ExprListDup(db
, pTab
->pCheck
, 0);
1584 if( db
->mallocFailed
==0 ){
1585 int addrCkFault
= sqlite3VdbeMakeLabel(v
);
1586 int addrCkOk
= sqlite3VdbeMakeLabel(v
);
1589 pParse
->iSelfTab
= iDataCur
+ 1;
1590 sqlite3ExprCachePush(pParse
);
1591 for(k
=pCheck
->nExpr
-1; k
>0; k
--){
1592 sqlite3ExprIfFalse(pParse
, pCheck
->a
[k
].pExpr
, addrCkFault
, 0);
1594 sqlite3ExprIfTrue(pParse
, pCheck
->a
[0].pExpr
, addrCkOk
,
1596 sqlite3VdbeResolveLabel(v
, addrCkFault
);
1597 pParse
->iSelfTab
= 0;
1598 zErr
= sqlite3MPrintf(db
, "CHECK constraint failed in %s",
1600 sqlite3VdbeAddOp4(v
, OP_String8
, 0, 3, 0, zErr
, P4_DYNAMIC
);
1601 integrityCheckResultRow(v
);
1602 sqlite3VdbeResolveLabel(v
, addrCkOk
);
1603 sqlite3ExprCachePop(pParse
);
1605 sqlite3ExprListDelete(db
, pCheck
);
1607 if( !isQuick
){ /* Omit the remaining tests for quick_check */
1608 /* Sanity check on record header decoding */
1609 sqlite3VdbeAddOp3(v
, OP_Column
, iDataCur
, pTab
->nCol
-1, 3);
1610 sqlite3VdbeChangeP5(v
, OPFLAG_TYPEOFARG
);
1611 /* Validate index entries for the current row */
1612 for(j
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, j
++){
1613 int jmp2
, jmp3
, jmp4
, jmp5
;
1614 int ckUniq
= sqlite3VdbeMakeLabel(v
);
1615 if( pPk
==pIdx
) continue;
1616 r1
= sqlite3GenerateIndexKey(pParse
, pIdx
, iDataCur
, 0, 0, &jmp3
,
1619 sqlite3VdbeAddOp2(v
, OP_AddImm
, 8+j
, 1);/* increment entry count */
1620 /* Verify that an index entry exists for the current table row */
1621 jmp2
= sqlite3VdbeAddOp4Int(v
, OP_Found
, iIdxCur
+j
, ckUniq
, r1
,
1622 pIdx
->nColumn
); VdbeCoverage(v
);
1623 sqlite3VdbeLoadString(v
, 3, "row ");
1624 sqlite3VdbeAddOp3(v
, OP_Concat
, 7, 3, 3);
1625 sqlite3VdbeLoadString(v
, 4, " missing from index ");
1626 sqlite3VdbeAddOp3(v
, OP_Concat
, 4, 3, 3);
1627 jmp5
= sqlite3VdbeLoadString(v
, 4, pIdx
->zName
);
1628 sqlite3VdbeAddOp3(v
, OP_Concat
, 4, 3, 3);
1629 jmp4
= integrityCheckResultRow(v
);
1630 sqlite3VdbeJumpHere(v
, jmp2
);
1631 /* For UNIQUE indexes, verify that only one entry exists with the
1632 ** current key. The entry is unique if (1) any column is NULL
1633 ** or (2) the next entry has a different key */
1634 if( IsUniqueIndex(pIdx
) ){
1635 int uniqOk
= sqlite3VdbeMakeLabel(v
);
1638 for(kk
=0; kk
<pIdx
->nKeyCol
; kk
++){
1639 int iCol
= pIdx
->aiColumn
[kk
];
1640 assert( iCol
!=XN_ROWID
&& iCol
<pTab
->nCol
);
1641 if( iCol
>=0 && pTab
->aCol
[iCol
].notNull
) continue;
1642 sqlite3VdbeAddOp2(v
, OP_IsNull
, r1
+kk
, uniqOk
);
1645 jmp6
= sqlite3VdbeAddOp1(v
, OP_Next
, iIdxCur
+j
); VdbeCoverage(v
);
1646 sqlite3VdbeGoto(v
, uniqOk
);
1647 sqlite3VdbeJumpHere(v
, jmp6
);
1648 sqlite3VdbeAddOp4Int(v
, OP_IdxGT
, iIdxCur
+j
, uniqOk
, r1
,
1649 pIdx
->nKeyCol
); VdbeCoverage(v
);
1650 sqlite3VdbeLoadString(v
, 3, "non-unique entry in index ");
1651 sqlite3VdbeGoto(v
, jmp5
);
1652 sqlite3VdbeResolveLabel(v
, uniqOk
);
1654 sqlite3VdbeJumpHere(v
, jmp4
);
1655 sqlite3ResolvePartIdxLabel(pParse
, jmp3
);
1658 sqlite3VdbeAddOp2(v
, OP_Next
, iDataCur
, loopTop
); VdbeCoverage(v
);
1659 sqlite3VdbeJumpHere(v
, loopTop
-1);
1660 #ifndef SQLITE_OMIT_BTREECOUNT
1662 sqlite3VdbeLoadString(v
, 2, "wrong # of entries in index ");
1663 for(j
=0, pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
, j
++){
1664 if( pPk
==pIdx
) continue;
1665 sqlite3VdbeAddOp2(v
, OP_Count
, iIdxCur
+j
, 3);
1666 addr
= sqlite3VdbeAddOp3(v
, OP_Eq
, 8+j
, 0, 3); VdbeCoverage(v
);
1667 sqlite3VdbeChangeP5(v
, SQLITE_NOTNULL
);
1668 sqlite3VdbeLoadString(v
, 4, pIdx
->zName
);
1669 sqlite3VdbeAddOp3(v
, OP_Concat
, 4, 2, 3);
1670 integrityCheckResultRow(v
);
1671 sqlite3VdbeJumpHere(v
, addr
);
1674 #endif /* SQLITE_OMIT_BTREECOUNT */
1678 static const int iLn
= VDBE_OFFSET_LINENO(2);
1679 static const VdbeOpList endCode
[] = {
1680 { OP_AddImm
, 1, 0, 0}, /* 0 */
1681 { OP_IfNotZero
, 1, 4, 0}, /* 1 */
1682 { OP_String8
, 0, 3, 0}, /* 2 */
1683 { OP_ResultRow
, 3, 1, 0}, /* 3 */
1684 { OP_Halt
, 0, 0, 0}, /* 4 */
1685 { OP_String8
, 0, 3, 0}, /* 5 */
1686 { OP_Goto
, 0, 3, 0}, /* 6 */
1690 aOp
= sqlite3VdbeAddOpList(v
, ArraySize(endCode
), endCode
, iLn
);
1692 aOp
[0].p2
= 1-mxErr
;
1693 aOp
[2].p4type
= P4_STATIC
;
1695 aOp
[5].p4type
= P4_STATIC
;
1696 aOp
[5].p4
.z
= (char*)sqlite3ErrStr(SQLITE_CORRUPT
);
1698 sqlite3VdbeChangeP3(v
, 0, sqlite3VdbeCurrentAddr(v
)-2);
1702 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
1704 #ifndef SQLITE_OMIT_UTF16
1707 ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
1709 ** In its first form, this pragma returns the encoding of the main
1710 ** database. If the database is not initialized, it is initialized now.
1712 ** The second form of this pragma is a no-op if the main database file
1713 ** has not already been initialized. In this case it sets the default
1714 ** encoding that will be used for the main database file if a new file
1715 ** is created. If an existing main database file is opened, then the
1716 ** default text encoding for the existing database is used.
1718 ** In all cases new databases created using the ATTACH command are
1719 ** created to use the same default text encoding as the main database. If
1720 ** the main database has not been initialized and/or created when ATTACH
1721 ** is executed, this is done before the ATTACH operation.
1723 ** In the second form this pragma sets the text encoding to be used in
1724 ** new database files created using this database handle. It is only
1725 ** useful if invoked immediately after the main database i
1727 case PragTyp_ENCODING
: {
1728 static const struct EncName
{
1732 { "UTF8", SQLITE_UTF8
},
1733 { "UTF-8", SQLITE_UTF8
}, /* Must be element [1] */
1734 { "UTF-16le", SQLITE_UTF16LE
}, /* Must be element [2] */
1735 { "UTF-16be", SQLITE_UTF16BE
}, /* Must be element [3] */
1736 { "UTF16le", SQLITE_UTF16LE
},
1737 { "UTF16be", SQLITE_UTF16BE
},
1738 { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */
1739 { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */
1742 const struct EncName
*pEnc
;
1743 if( !zRight
){ /* "PRAGMA encoding" */
1744 if( sqlite3ReadSchema(pParse
) ) goto pragma_out
;
1745 assert( encnames
[SQLITE_UTF8
].enc
==SQLITE_UTF8
);
1746 assert( encnames
[SQLITE_UTF16LE
].enc
==SQLITE_UTF16LE
);
1747 assert( encnames
[SQLITE_UTF16BE
].enc
==SQLITE_UTF16BE
);
1748 returnSingleText(v
, encnames
[ENC(pParse
->db
)].zName
);
1749 }else{ /* "PRAGMA encoding = XXX" */
1750 /* Only change the value of sqlite.enc if the database handle is not
1751 ** initialized. If the main database exists, the new sqlite.enc value
1752 ** will be overwritten when the schema is next loaded. If it does not
1753 ** already exists, it will be created to use the new encoding value.
1756 !(DbHasProperty(db
, 0, DB_SchemaLoaded
)) ||
1757 DbHasProperty(db
, 0, DB_Empty
)
1759 for(pEnc
=&encnames
[0]; pEnc
->zName
; pEnc
++){
1760 if( 0==sqlite3StrICmp(zRight
, pEnc
->zName
) ){
1761 SCHEMA_ENC(db
) = ENC(db
) =
1762 pEnc
->enc
? pEnc
->enc
: SQLITE_UTF16NATIVE
;
1767 sqlite3ErrorMsg(pParse
, "unsupported encoding: %s", zRight
);
1773 #endif /* SQLITE_OMIT_UTF16 */
1775 #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
1777 ** PRAGMA [schema.]schema_version
1778 ** PRAGMA [schema.]schema_version = <integer>
1780 ** PRAGMA [schema.]user_version
1781 ** PRAGMA [schema.]user_version = <integer>
1783 ** PRAGMA [schema.]freelist_count
1785 ** PRAGMA [schema.]data_version
1787 ** PRAGMA [schema.]application_id
1788 ** PRAGMA [schema.]application_id = <integer>
1790 ** The pragma's schema_version and user_version are used to set or get
1791 ** the value of the schema-version and user-version, respectively. Both
1792 ** the schema-version and the user-version are 32-bit signed integers
1793 ** stored in the database header.
1795 ** The schema-cookie is usually only manipulated internally by SQLite. It
1796 ** is incremented by SQLite whenever the database schema is modified (by
1797 ** creating or dropping a table or index). The schema version is used by
1798 ** SQLite each time a query is executed to ensure that the internal cache
1799 ** of the schema used when compiling the SQL query matches the schema of
1800 ** the database against which the compiled query is actually executed.
1801 ** Subverting this mechanism by using "PRAGMA schema_version" to modify
1802 ** the schema-version is potentially dangerous and may lead to program
1803 ** crashes or database corruption. Use with caution!
1805 ** The user-version is not used internally by SQLite. It may be used by
1806 ** applications for any purpose.
1808 case PragTyp_HEADER_VALUE
: {
1809 int iCookie
= pPragma
->iArg
; /* Which cookie to read or write */
1810 sqlite3VdbeUsesBtree(v
, iDb
);
1811 if( zRight
&& (pPragma
->mPragFlg
& PragFlg_ReadOnly
)==0 ){
1812 /* Write the specified cookie value */
1813 static const VdbeOpList setCookie
[] = {
1814 { OP_Transaction
, 0, 1, 0}, /* 0 */
1815 { OP_SetCookie
, 0, 0, 0}, /* 1 */
1818 sqlite3VdbeVerifyNoMallocRequired(v
, ArraySize(setCookie
));
1819 aOp
= sqlite3VdbeAddOpList(v
, ArraySize(setCookie
), setCookie
, 0);
1820 if( ONLY_IF_REALLOC_STRESS(aOp
==0) ) break;
1823 aOp
[1].p2
= iCookie
;
1824 aOp
[1].p3
= sqlite3Atoi(zRight
);
1826 /* Read the specified cookie value */
1827 static const VdbeOpList readCookie
[] = {
1828 { OP_Transaction
, 0, 0, 0}, /* 0 */
1829 { OP_ReadCookie
, 0, 1, 0}, /* 1 */
1830 { OP_ResultRow
, 1, 1, 0}
1833 sqlite3VdbeVerifyNoMallocRequired(v
, ArraySize(readCookie
));
1834 aOp
= sqlite3VdbeAddOpList(v
, ArraySize(readCookie
),readCookie
,0);
1835 if( ONLY_IF_REALLOC_STRESS(aOp
==0) ) break;
1838 aOp
[1].p3
= iCookie
;
1839 sqlite3VdbeReusable(v
);
1843 #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
1845 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1847 ** PRAGMA compile_options
1849 ** Return the names of all compile-time options used in this build,
1850 ** one option per row.
1852 case PragTyp_COMPILE_OPTIONS
: {
1856 while( (zOpt
= sqlite3_compileoption_get(i
++))!=0 ){
1857 sqlite3VdbeLoadString(v
, 1, zOpt
);
1858 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, 1);
1860 sqlite3VdbeReusable(v
);
1863 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1865 #ifndef SQLITE_OMIT_WAL
1867 ** PRAGMA [schema.]wal_checkpoint = passive|full|restart|truncate
1869 ** Checkpoint the database.
1871 case PragTyp_WAL_CHECKPOINT
: {
1872 int iBt
= (pId2
->z
?iDb
:SQLITE_MAX_ATTACHED
);
1873 int eMode
= SQLITE_CHECKPOINT_PASSIVE
;
1875 if( sqlite3StrICmp(zRight
, "full")==0 ){
1876 eMode
= SQLITE_CHECKPOINT_FULL
;
1877 }else if( sqlite3StrICmp(zRight
, "restart")==0 ){
1878 eMode
= SQLITE_CHECKPOINT_RESTART
;
1879 }else if( sqlite3StrICmp(zRight
, "truncate")==0 ){
1880 eMode
= SQLITE_CHECKPOINT_TRUNCATE
;
1884 sqlite3VdbeAddOp3(v
, OP_Checkpoint
, iBt
, eMode
, 1);
1885 sqlite3VdbeAddOp2(v
, OP_ResultRow
, 1, 3);
1890 ** PRAGMA wal_autocheckpoint
1891 ** PRAGMA wal_autocheckpoint = N
1893 ** Configure a database connection to automatically checkpoint a database
1894 ** after accumulating N frames in the log. Or query for the current value
1897 case PragTyp_WAL_AUTOCHECKPOINT
: {
1899 sqlite3_wal_autocheckpoint(db
, sqlite3Atoi(zRight
));
1902 db
->xWalCallback
==sqlite3WalDefaultHook
?
1903 SQLITE_PTR_TO_INT(db
->pWalArg
) : 0);
1909 ** PRAGMA shrink_memory
1911 ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database
1912 ** connection on which it is invoked to free up as much memory as it
1913 ** can, by calling sqlite3_db_release_memory().
1915 case PragTyp_SHRINK_MEMORY
: {
1916 sqlite3_db_release_memory(db
);
1922 ** PRAGMA optimize(MASK)
1923 ** PRAGMA schema.optimize
1924 ** PRAGMA schema.optimize(MASK)
1926 ** Attempt to optimize the database. All schemas are optimized in the first
1927 ** two forms, and only the specified schema is optimized in the latter two.
1929 ** The details of optimizations performed by this pragma are expected
1930 ** to change and improve over time. Applications should anticipate that
1931 ** this pragma will perform new optimizations in future releases.
1933 ** The optional argument is a bitmask of optimizations to perform:
1935 ** 0x0001 Debugging mode. Do not actually perform any optimizations
1936 ** but instead return one line of text for each optimization
1937 ** that would have been done. Off by default.
1939 ** 0x0002 Run ANALYZE on tables that might benefit. On by default.
1940 ** See below for additional information.
1942 ** 0x0004 (Not yet implemented) Record usage and performance
1943 ** information from the current session in the
1944 ** database file so that it will be available to "optimize"
1945 ** pragmas run by future database connections.
1947 ** 0x0008 (Not yet implemented) Create indexes that might have
1948 ** been helpful to recent queries
1950 ** The default MASK is and always shall be 0xfffe. 0xfffe means perform all
1951 ** of the optimizations listed above except Debug Mode, including new
1952 ** optimizations that have not yet been invented. If new optimizations are
1953 ** ever added that should be off by default, those off-by-default
1954 ** optimizations will have bitmasks of 0x10000 or larger.
1956 ** DETERMINATION OF WHEN TO RUN ANALYZE
1958 ** In the current implementation, a table is analyzed if only if all of
1959 ** the following are true:
1961 ** (1) MASK bit 0x02 is set.
1963 ** (2) The query planner used sqlite_stat1-style statistics for one or
1964 ** more indexes of the table at some point during the lifetime of
1965 ** the current connection.
1967 ** (3) One or more indexes of the table are currently unanalyzed OR
1968 ** the number of rows in the table has increased by 25 times or more
1969 ** since the last time ANALYZE was run.
1971 ** The rules for when tables are analyzed are likely to change in
1974 case PragTyp_OPTIMIZE
: {
1975 int iDbLast
; /* Loop termination point for the schema loop */
1976 int iTabCur
; /* Cursor for a table whose size needs checking */
1977 HashElem
*k
; /* Loop over tables of a schema */
1978 Schema
*pSchema
; /* The current schema */
1979 Table
*pTab
; /* A table in the schema */
1980 Index
*pIdx
; /* An index of the table */
1981 LogEst szThreshold
; /* Size threshold above which reanalysis is needd */
1982 char *zSubSql
; /* SQL statement for the OP_SqlExec opcode */
1983 u32 opMask
; /* Mask of operations to perform */
1986 opMask
= (u32
)sqlite3Atoi(zRight
);
1987 if( (opMask
& 0x02)==0 ) break;
1991 iTabCur
= pParse
->nTab
++;
1992 for(iDbLast
= zDb
?iDb
:db
->nDb
-1; iDb
<=iDbLast
; iDb
++){
1993 if( iDb
==1 ) continue;
1994 sqlite3CodeVerifySchema(pParse
, iDb
);
1995 pSchema
= db
->aDb
[iDb
].pSchema
;
1996 for(k
=sqliteHashFirst(&pSchema
->tblHash
); k
; k
=sqliteHashNext(k
)){
1997 pTab
= (Table
*)sqliteHashData(k
);
1999 /* If table pTab has not been used in a way that would benefit from
2000 ** having analysis statistics during the current session, then skip it.
2001 ** This also has the effect of skipping virtual tables and views */
2002 if( (pTab
->tabFlags
& TF_StatsUsed
)==0 ) continue;
2004 /* Reanalyze if the table is 25 times larger than the last analysis */
2005 szThreshold
= pTab
->nRowLogEst
+ 46; assert( sqlite3LogEst(25)==46 );
2006 for(pIdx
=pTab
->pIndex
; pIdx
; pIdx
=pIdx
->pNext
){
2007 if( !pIdx
->hasStat1
){
2008 szThreshold
= 0; /* Always analyze if any index lacks statistics */
2013 sqlite3OpenTable(pParse
, iTabCur
, iDb
, pTab
, OP_OpenRead
);
2014 sqlite3VdbeAddOp3(v
, OP_IfSmaller
, iTabCur
,
2015 sqlite3VdbeCurrentAddr(v
)+2+(opMask
&1), szThreshold
);
2018 zSubSql
= sqlite3MPrintf(db
, "ANALYZE \"%w\".\"%w\"",
2019 db
->aDb
[iDb
].zDbSName
, pTab
->zName
);
2020 if( opMask
& 0x01 ){
2021 int r1
= sqlite3GetTempReg(pParse
);
2022 sqlite3VdbeAddOp4(v
, OP_String8
, 0, r1
, 0, zSubSql
, P4_DYNAMIC
);
2023 sqlite3VdbeAddOp2(v
, OP_ResultRow
, r1
, 1);
2025 sqlite3VdbeAddOp4(v
, OP_SqlExec
, 0, 0, 0, zSubSql
, P4_DYNAMIC
);
2029 sqlite3VdbeAddOp0(v
, OP_Expire
);
2034 ** PRAGMA busy_timeout
2035 ** PRAGMA busy_timeout = N
2037 ** Call sqlite3_busy_timeout(db, N). Return the current timeout value
2038 ** if one is set. If no busy handler or a different busy handler is set
2039 ** then 0 is returned. Setting the busy_timeout to 0 or negative
2040 ** disables the timeout.
2042 /*case PragTyp_BUSY_TIMEOUT*/ default: {
2043 assert( pPragma
->ePragTyp
==PragTyp_BUSY_TIMEOUT
);
2045 sqlite3_busy_timeout(db
, sqlite3Atoi(zRight
));
2047 returnSingleInt(v
, db
->busyTimeout
);
2052 ** PRAGMA soft_heap_limit
2053 ** PRAGMA soft_heap_limit = N
2055 ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the
2056 ** sqlite3_soft_heap_limit64() interface with the argument N, if N is
2057 ** specified and is a non-negative integer.
2058 ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always
2059 ** returns the same integer that would be returned by the
2060 ** sqlite3_soft_heap_limit64(-1) C-language function.
2062 case PragTyp_SOFT_HEAP_LIMIT
: {
2064 if( zRight
&& sqlite3DecOrHexToI64(zRight
, &N
)==SQLITE_OK
){
2065 sqlite3_soft_heap_limit64(N
);
2067 returnSingleInt(v
, sqlite3_soft_heap_limit64(-1));
2073 ** PRAGMA threads = N
2075 ** Configure the maximum number of worker threads. Return the new
2076 ** maximum, which might be less than requested.
2078 case PragTyp_THREADS
: {
2081 && sqlite3DecOrHexToI64(zRight
, &N
)==SQLITE_OK
2084 sqlite3_limit(db
, SQLITE_LIMIT_WORKER_THREADS
, (int)(N
&0x7fffffff));
2086 returnSingleInt(v
, sqlite3_limit(db
, SQLITE_LIMIT_WORKER_THREADS
, -1));
2090 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
2092 ** Report the current state of file logs for all databases
2094 case PragTyp_LOCK_STATUS
: {
2095 static const char *const azLockName
[] = {
2096 "unlocked", "shared", "reserved", "pending", "exclusive"
2100 for(i
=0; i
<db
->nDb
; i
++){
2102 const char *zState
= "unknown";
2104 if( db
->aDb
[i
].zDbSName
==0 ) continue;
2105 pBt
= db
->aDb
[i
].pBt
;
2106 if( pBt
==0 || sqlite3BtreePager(pBt
)==0 ){
2108 }else if( sqlite3_file_control(db
, i
? db
->aDb
[i
].zDbSName
: 0,
2109 SQLITE_FCNTL_LOCKSTATE
, &j
)==SQLITE_OK
){
2110 zState
= azLockName
[j
];
2112 sqlite3VdbeMultiLoad(v
, 1, "ss", db
->aDb
[i
].zDbSName
, zState
);
2118 #ifdef SQLITE_HAS_CODEC
2120 if( zRight
) sqlite3_key_v2(db
, zDb
, zRight
, sqlite3Strlen30(zRight
));
2123 case PragTyp_REKEY
: {
2124 if( zRight
) sqlite3_rekey_v2(db
, zDb
, zRight
, sqlite3Strlen30(zRight
));
2127 case PragTyp_HEXKEY
: {
2132 for(i
=0, iByte
=0; i
<sizeof(zKey
)*2 && sqlite3Isxdigit(zRight
[i
]); i
++){
2133 iByte
= (iByte
<<4) + sqlite3HexToInt(zRight
[i
]);
2134 if( (i
&1)!=0 ) zKey
[i
/2] = iByte
;
2136 if( (zLeft
[3] & 0xf)==0xb ){
2137 sqlite3_key_v2(db
, zDb
, zKey
, i
/2);
2139 sqlite3_rekey_v2(db
, zDb
, zKey
, i
/2);
2145 #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)
2146 case PragTyp_ACTIVATE_EXTENSIONS
: if( zRight
){
2147 #ifdef SQLITE_HAS_CODEC
2148 if( sqlite3StrNICmp(zRight
, "see-", 4)==0 ){
2149 sqlite3_activate_see(&zRight
[4]);
2152 #ifdef SQLITE_ENABLE_CEROD
2153 if( sqlite3StrNICmp(zRight
, "cerod-", 6)==0 ){
2154 sqlite3_activate_cerod(&zRight
[6]);
2161 } /* End of the PRAGMA switch */
2163 /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only
2164 ** purpose is to execute assert() statements to verify that if the
2165 ** PragFlg_NoColumns1 flag is set and the caller specified an argument
2166 ** to the PRAGMA, the implementation has not added any OP_ResultRow
2167 ** instructions to the VM. */
2168 if( (pPragma
->mPragFlg
& PragFlg_NoColumns1
) && zRight
){
2169 sqlite3VdbeVerifyNoResultRow(v
);
2173 sqlite3DbFree(db
, zLeft
);
2174 sqlite3DbFree(db
, zRight
);
2176 #ifndef SQLITE_OMIT_VIRTUALTABLE
2177 /*****************************************************************************
2178 ** Implementation of an eponymous virtual table that runs a pragma.
2181 typedef struct PragmaVtab PragmaVtab
;
2182 typedef struct PragmaVtabCursor PragmaVtabCursor
;
2184 sqlite3_vtab base
; /* Base class. Must be first */
2185 sqlite3
*db
; /* The database connection to which it belongs */
2186 const PragmaName
*pName
; /* Name of the pragma */
2187 u8 nHidden
; /* Number of hidden columns */
2188 u8 iHidden
; /* Index of the first hidden column */
2190 struct PragmaVtabCursor
{
2191 sqlite3_vtab_cursor base
; /* Base class. Must be first */
2192 sqlite3_stmt
*pPragma
; /* The pragma statement to run */
2193 sqlite_int64 iRowid
; /* Current rowid */
2194 char *azArg
[2]; /* Value of the argument and schema */
2198 ** Pragma virtual table module xConnect method.
2200 static int pragmaVtabConnect(
2203 int argc
, const char *const*argv
,
2204 sqlite3_vtab
**ppVtab
,
2207 const PragmaName
*pPragma
= (const PragmaName
*)pAux
;
2208 PragmaVtab
*pTab
= 0;
2215 UNUSED_PARAMETER(argc
);
2216 UNUSED_PARAMETER(argv
);
2217 sqlite3StrAccumInit(&acc
, 0, zBuf
, sizeof(zBuf
), 0);
2218 sqlite3StrAccumAppendAll(&acc
, "CREATE TABLE x");
2219 for(i
=0, j
=pPragma
->iPragCName
; i
<pPragma
->nPragCName
; i
++, j
++){
2220 sqlite3XPrintf(&acc
, "%c\"%s\"", cSep
, pragCName
[j
]);
2224 sqlite3XPrintf(&acc
, "(\"%s\"", pPragma
->zName
);
2229 if( pPragma
->mPragFlg
& PragFlg_Result1
){
2230 sqlite3StrAccumAppendAll(&acc
, ",arg HIDDEN");
2233 if( pPragma
->mPragFlg
& (PragFlg_SchemaOpt
|PragFlg_SchemaReq
) ){
2234 sqlite3StrAccumAppendAll(&acc
, ",schema HIDDEN");
2237 sqlite3StrAccumAppend(&acc
, ")", 1);
2238 sqlite3StrAccumFinish(&acc
);
2239 assert( strlen(zBuf
) < sizeof(zBuf
)-1 );
2240 rc
= sqlite3_declare_vtab(db
, zBuf
);
2241 if( rc
==SQLITE_OK
){
2242 pTab
= (PragmaVtab
*)sqlite3_malloc(sizeof(PragmaVtab
));
2246 memset(pTab
, 0, sizeof(PragmaVtab
));
2247 pTab
->pName
= pPragma
;
2253 *pzErr
= sqlite3_mprintf("%s", sqlite3_errmsg(db
));
2256 *ppVtab
= (sqlite3_vtab
*)pTab
;
2261 ** Pragma virtual table module xDisconnect method.
2263 static int pragmaVtabDisconnect(sqlite3_vtab
*pVtab
){
2264 PragmaVtab
*pTab
= (PragmaVtab
*)pVtab
;
2269 /* Figure out the best index to use to search a pragma virtual table.
2271 ** There are not really any index choices. But we want to encourage the
2272 ** query planner to give == constraints on as many hidden parameters as
2273 ** possible, and especially on the first hidden parameter. So return a
2274 ** high cost if hidden parameters are unconstrained.
2276 static int pragmaVtabBestIndex(sqlite3_vtab
*tab
, sqlite3_index_info
*pIdxInfo
){
2277 PragmaVtab
*pTab
= (PragmaVtab
*)tab
;
2278 const struct sqlite3_index_constraint
*pConstraint
;
2282 pIdxInfo
->estimatedCost
= (double)1;
2283 if( pTab
->nHidden
==0 ){ return SQLITE_OK
; }
2284 pConstraint
= pIdxInfo
->aConstraint
;
2287 for(i
=0; i
<pIdxInfo
->nConstraint
; i
++, pConstraint
++){
2288 if( pConstraint
->usable
==0 ) continue;
2289 if( pConstraint
->op
!=SQLITE_INDEX_CONSTRAINT_EQ
) continue;
2290 if( pConstraint
->iColumn
< pTab
->iHidden
) continue;
2291 j
= pConstraint
->iColumn
- pTab
->iHidden
;
2296 pIdxInfo
->estimatedCost
= (double)2147483647;
2297 pIdxInfo
->estimatedRows
= 2147483647;
2301 pIdxInfo
->aConstraintUsage
[j
].argvIndex
= 1;
2302 pIdxInfo
->aConstraintUsage
[j
].omit
= 1;
2303 if( seen
[1]==0 ) return SQLITE_OK
;
2304 pIdxInfo
->estimatedCost
= (double)20;
2305 pIdxInfo
->estimatedRows
= 20;
2307 pIdxInfo
->aConstraintUsage
[j
].argvIndex
= 2;
2308 pIdxInfo
->aConstraintUsage
[j
].omit
= 1;
2312 /* Create a new cursor for the pragma virtual table */
2313 static int pragmaVtabOpen(sqlite3_vtab
*pVtab
, sqlite3_vtab_cursor
**ppCursor
){
2314 PragmaVtabCursor
*pCsr
;
2315 pCsr
= (PragmaVtabCursor
*)sqlite3_malloc(sizeof(*pCsr
));
2316 if( pCsr
==0 ) return SQLITE_NOMEM
;
2317 memset(pCsr
, 0, sizeof(PragmaVtabCursor
));
2318 pCsr
->base
.pVtab
= pVtab
;
2319 *ppCursor
= &pCsr
->base
;
2323 /* Clear all content from pragma virtual table cursor. */
2324 static void pragmaVtabCursorClear(PragmaVtabCursor
*pCsr
){
2326 sqlite3_finalize(pCsr
->pPragma
);
2328 for(i
=0; i
<ArraySize(pCsr
->azArg
); i
++){
2329 sqlite3_free(pCsr
->azArg
[i
]);
2334 /* Close a pragma virtual table cursor */
2335 static int pragmaVtabClose(sqlite3_vtab_cursor
*cur
){
2336 PragmaVtabCursor
*pCsr
= (PragmaVtabCursor
*)cur
;
2337 pragmaVtabCursorClear(pCsr
);
2342 /* Advance the pragma virtual table cursor to the next row */
2343 static int pragmaVtabNext(sqlite3_vtab_cursor
*pVtabCursor
){
2344 PragmaVtabCursor
*pCsr
= (PragmaVtabCursor
*)pVtabCursor
;
2347 /* Increment the xRowid value */
2349 assert( pCsr
->pPragma
);
2350 if( SQLITE_ROW
!=sqlite3_step(pCsr
->pPragma
) ){
2351 rc
= sqlite3_finalize(pCsr
->pPragma
);
2353 pragmaVtabCursorClear(pCsr
);
2359 ** Pragma virtual table module xFilter method.
2361 static int pragmaVtabFilter(
2362 sqlite3_vtab_cursor
*pVtabCursor
,
2363 int idxNum
, const char *idxStr
,
2364 int argc
, sqlite3_value
**argv
2366 PragmaVtabCursor
*pCsr
= (PragmaVtabCursor
*)pVtabCursor
;
2367 PragmaVtab
*pTab
= (PragmaVtab
*)(pVtabCursor
->pVtab
);
2373 UNUSED_PARAMETER(idxNum
);
2374 UNUSED_PARAMETER(idxStr
);
2375 pragmaVtabCursorClear(pCsr
);
2376 j
= (pTab
->pName
->mPragFlg
& PragFlg_Result1
)!=0 ? 0 : 1;
2377 for(i
=0; i
<argc
; i
++, j
++){
2378 const char *zText
= (const char*)sqlite3_value_text(argv
[i
]);
2379 assert( j
<ArraySize(pCsr
->azArg
) );
2380 assert( pCsr
->azArg
[j
]==0 );
2382 pCsr
->azArg
[j
] = sqlite3_mprintf("%s", zText
);
2383 if( pCsr
->azArg
[j
]==0 ){
2384 return SQLITE_NOMEM
;
2388 sqlite3StrAccumInit(&acc
, 0, 0, 0, pTab
->db
->aLimit
[SQLITE_LIMIT_SQL_LENGTH
]);
2389 sqlite3StrAccumAppendAll(&acc
, "PRAGMA ");
2390 if( pCsr
->azArg
[1] ){
2391 sqlite3XPrintf(&acc
, "%Q.", pCsr
->azArg
[1]);
2393 sqlite3StrAccumAppendAll(&acc
, pTab
->pName
->zName
);
2394 if( pCsr
->azArg
[0] ){
2395 sqlite3XPrintf(&acc
, "=%Q", pCsr
->azArg
[0]);
2397 zSql
= sqlite3StrAccumFinish(&acc
);
2398 if( zSql
==0 ) return SQLITE_NOMEM
;
2399 rc
= sqlite3_prepare_v2(pTab
->db
, zSql
, -1, &pCsr
->pPragma
, 0);
2401 if( rc
!=SQLITE_OK
){
2402 pTab
->base
.zErrMsg
= sqlite3_mprintf("%s", sqlite3_errmsg(pTab
->db
));
2405 return pragmaVtabNext(pVtabCursor
);
2409 ** Pragma virtual table module xEof method.
2411 static int pragmaVtabEof(sqlite3_vtab_cursor
*pVtabCursor
){
2412 PragmaVtabCursor
*pCsr
= (PragmaVtabCursor
*)pVtabCursor
;
2413 return (pCsr
->pPragma
==0);
2416 /* The xColumn method simply returns the corresponding column from
2419 static int pragmaVtabColumn(
2420 sqlite3_vtab_cursor
*pVtabCursor
,
2421 sqlite3_context
*ctx
,
2424 PragmaVtabCursor
*pCsr
= (PragmaVtabCursor
*)pVtabCursor
;
2425 PragmaVtab
*pTab
= (PragmaVtab
*)(pVtabCursor
->pVtab
);
2426 if( i
<pTab
->iHidden
){
2427 sqlite3_result_value(ctx
, sqlite3_column_value(pCsr
->pPragma
, i
));
2429 sqlite3_result_text(ctx
, pCsr
->azArg
[i
-pTab
->iHidden
],-1,SQLITE_TRANSIENT
);
2435 ** Pragma virtual table module xRowid method.
2437 static int pragmaVtabRowid(sqlite3_vtab_cursor
*pVtabCursor
, sqlite_int64
*p
){
2438 PragmaVtabCursor
*pCsr
= (PragmaVtabCursor
*)pVtabCursor
;
2443 /* The pragma virtual table object */
2444 static const sqlite3_module pragmaVtabModule
= {
2446 0, /* xCreate - create a table */
2447 pragmaVtabConnect
, /* xConnect - connect to an existing table */
2448 pragmaVtabBestIndex
, /* xBestIndex - Determine search strategy */
2449 pragmaVtabDisconnect
, /* xDisconnect - Disconnect from a table */
2450 0, /* xDestroy - Drop a table */
2451 pragmaVtabOpen
, /* xOpen - open a cursor */
2452 pragmaVtabClose
, /* xClose - close a cursor */
2453 pragmaVtabFilter
, /* xFilter - configure scan constraints */
2454 pragmaVtabNext
, /* xNext - advance a cursor */
2455 pragmaVtabEof
, /* xEof */
2456 pragmaVtabColumn
, /* xColumn - read data */
2457 pragmaVtabRowid
, /* xRowid - read data */
2458 0, /* xUpdate - write data */
2459 0, /* xBegin - begin transaction */
2460 0, /* xSync - sync transaction */
2461 0, /* xCommit - commit transaction */
2462 0, /* xRollback - rollback transaction */
2463 0, /* xFindFunction - function overloading */
2464 0, /* xRename - rename the table */
2471 ** Check to see if zTabName is really the name of a pragma. If it is,
2472 ** then register an eponymous virtual table for that pragma and return
2473 ** a pointer to the Module object for the new virtual table.
2475 Module
*sqlite3PragmaVtabRegister(sqlite3
*db
, const char *zName
){
2476 const PragmaName
*pName
;
2477 assert( sqlite3_strnicmp(zName
, "pragma_", 7)==0 );
2478 pName
= pragmaLocate(zName
+7);
2479 if( pName
==0 ) return 0;
2480 if( (pName
->mPragFlg
& (PragFlg_Result0
|PragFlg_Result1
))==0 ) return 0;
2481 assert( sqlite3HashFind(&db
->aModule
, zName
)==0 );
2482 return sqlite3VtabCreateModule(db
, zName
, &pragmaVtabModule
, (void*)pName
, 0);
2485 #endif /* SQLITE_OMIT_VIRTUALTABLE */
2487 #endif /* SQLITE_OMIT_PRAGMA */