|
S10000 |
The SQLite library shall translate high-level SQL statements into
low-level I/O calls to persistent storage.
No parents Children: S10100 S10200 S10300 S10500 S10600 S10700 H12100 H12101 H12102 H12104 H12105 H12107 H12110 H12113 H12116 H12119 H12122 H12125 H12131 H12134 H12137 H12138 H12370 H12371 H12373 H12374 H12376 H12379 H12382 H13010 H13011 H13012 H13013 H13014 H13015 H13016 H13019 H13021 H13200 H13202 H15304 H15306 H15308 H15310 |
S10100 |
The SQLite library shall accepts a well-defined dialect of SQL
that conforms to published SQL standards.
Parents: S10000 |
S10110 |
The SQLite library shall support BLOB, CLOB, integer, and floating-point
datatypes.
Parents: S10100 |
S10120 |
The SQLite library shall implement the standard SQL interpretation
of NULL values.
Parents: S10100 Children: H10265 |
S10200 |
The SQLite library shall communicate directly with database files
in persistent storage.
Parents: S10000 No children |
S10300 |
The SQLite library shall implement ACID transactions.
Parents: S10000 No children |
S10500 |
The SQLite library shall implement transactions that are robust
across application crashes, operating-system crashes, and power
failures.
Parents: S10000 No children |
S10600 |
The SQLite library shall support simultaneous access to multiple
database files on the same database connection.
Parents: S10000 |
S10700 |
The SQLite library shall provide interfaces that allow the application
to obtain the status and results of SQL operations.
Parents: S10000 Children: H10210 H10220 H10223 H10224 H10225 H10226 H12200 H12201 H12202 H12220 H12221 H12223 H13710 H13711 H13720 H13721 H13723 H13724 H13725 H13726 H13727 H13740 H13741 H13742 H13743 H13744 H13745 H13746 H13748 H13760 H13761 H13762 H13763 H13770 H13771 H13772 H13800 H13803 H13806 H13809 H13812 H13815 H13818 H13821 H13824 H13827 H13830 |
S20000 |
The SQLite library shall be extensible and configurable.
No parents Children: S20100 S20200 S20300 S20400 S20500 S20600 H10130 H10160 H10170 H10310 H14100 H14103 H14106 H14120 H14123 H14126 H14129 H14132 H14135 H14138 H14141 H14144 H14147 H14150 H14153 H14156 H14159 H14162 H14165 H14168 H14200 H14203 H14206 H14209 H14212 H14215 H17000 H17300 H17303 H17304 H17305 H17306 H17310 H17312 H17315 H17318 H17321 H17322 H17323 H17390 H17392 H17400 |
S20100 |
The SQLite library shall provide interfaces that permit the application
to override interfaces to the platform on which the application is running.
Parents: S20000 Children: S20110 S20120 S20130 H11140 H11200 H11203 H11206 H11209 H11212 H11215 H11218 |
S20110 |
The SQLite library shall provide interfaces that permit the application
to override the interfaces used to read and write persistent storage.
Parents: S20100 |
S20120 |
The SQLite library shall provide interfaces that permit the application
to override the interfaces used for memory allocation.
Parents: S20100 Children: H10155 |
S20130 |
The SQLite library shall provide interfaces that permit the application
to override the interfaces used for controlling mutexes.
Parents: S20100 |
S20200 |
The SQLite library shall provide interfaces that permit the application
to create new SQL functions.
Parents: S20000 Children: S60600 H15000 H15100 H15103 H15106 H15109 H15112 H15115 H15118 H15121 H15124 H15127 H15130 H15133 H15136 H16001 H16100 H16103 H16106 H16109 H16112 H16118 H16121 H16124 H16127 H16130 H16133 H16136 H16139 H16142 H16210 H16211 H16213 H16215 H16217 H16240 H16243 H16250 H16270 H16272 H16274 H16276 H16277 H16278 H16279 H16400 H16403 H16406 H16409 H16412 H16415 H16418 H16421 H16424 H16427 H16430 H16433 H16436 H16439 H16442 H16445 H16448 H16451 H16454 H16457 H16460 H16463 |
S20300 |
The SQLite library shall provide interfaces that permit the application
to create new text collating sequences.
Parents: S20000 Children: H16600 H16603 H16604 H16606 H16609 H16612 H16615 H16618 H16621 H16624 H16627 H16630 H16700 H16702 H16704 H16706 |
S20400 |
The SQLite library shall provide interfaces that permit the application
to create new classes of virtual SQL tables.
Parents: S20000 Children: H18000 H18010 H18020 H18100 H18200 H18210 H18280 H18300 |
S20500 |
The SQLite library shall provide interfaces that permit the application
to load extensions at run-time using shared libraries.
Parents: S20000 |
S20600 |
The SQLite library shall provide interfaces that permit the application
to dynamically query and modify size limits.
Parents: S20000 |
S30000 |
The SQLite library shall be safe for use in long-running,
low-resource, high-reliability applications.
No parents Children: S30100 S30200 S30300 S30400 S30500 S30600 S30700 S30800 S30900 S70300 |
S30100 |
The SQLite library shall release all system resources it holds
when it is properly shutdown.
Parents: S30000 Children: H10130 H10280 H12010 H12011 H12012 H12013 H12014 H12015 H12019 H13300 |
S30200 |
The SQLite library shall be configurable so that it is guaranteed
to never fail a memory allocation as long as the application does
not request resources in excess of reasonable and published limits.
Parents: S30000 |
S30210 |
The SQLite library shall be provide instrumentation that can alert
the application when its resource usages nears or exceeds the limits
of the memory breakdown guarantee.
Parents: S30200 |
S30220 |
The SQLite library shall be provide facilities to automatically
recycle memory when usage nears preset limits.
Parents: S30200 Children: H16342 H16351 H16352 H16353 H16354 H16355 H16358 H17340 H17341 H17350 |
S30230 |
The SQLite library shall be permit BLOB and CLOB objects to be
read and written incrementally using small memory buffers.
Parents: S30200 Children: H17800 H17810 H17813 H17814 H17816 H17819 H17821 H17824 H17830 H17833 H17836 H17839 H17840 H17843 H17850 H17853 H17856 H17859 H17862 H17863 H17865 H17868 H17870 H17873 H17874 H17875 H17876 H17877 H17879 H17882 H17885 H17888 |
S30300 |
When a memory allocation fails, SQLite shall either silently make
due without the requested memory or else it shall report the error
back to the application.
Parents: S30000 No children |
S30400 |
When a I/O operation fails, SQLite shall either silently
recover or else it shall report the error
back to the application.
Parents: S30000 No children |
S30500 |
SQLite shall provide the capability to monitor
the progress and interrupt the evaluation of a long-running query.
Parents: S30000 |
S30600 |
All unused portions of a well-formed SQLite database file shall
be available for reuse.
Parents: S30000 No children |
S30700 |
SQLite shall provide the capability to incrementally decrease the
size of the persistent storage file as information is removed from
the database.
Parents: S30000 No children |
S30800 |
SQLite shall provide the interfaces that support testing and
validation of the library code in an as-delivered configuration.
Parents: S30000 |
S30900 |
SQLite shall provide the ability for separate database connections
within the same process to share resources.
Parents: S30000 |
S40000 |
The SQLite library shall be safe for use in applications that
make concurrent access to the underlying database from different
threads and/or processes.
No parents |
S40100 |
The SQLite library shall be configurable to operate correctly in
a multi-threaded application.
Parents: S40000 No children |
S40200 |
The SQLite library shall support multiple independent database
connections per thread and per process.
Parents: S40000 Children: H12000 H12010 H12700 H12701 H12702 H12703 H12704 H12706 H12707 H12709 H12711 H12712 H12713 H12714 H12717 H12719 H12721 H12723 |
S40300 |
The SQLite library shall automatically control access to common
databases from different connections in different threads or processes.
Parents: S40000 No children |
S40400 |
The SQLite library shall notify the application if an operation can
not be completed due to concurrent access constraints.
Parents: S40000 |
S40410 |
The SQLite library shall provide interfaces to assist the application
in responding appropriately when an operation can
not be completed due to concurrent access constraints.
Parents: S40000 |
S50000 |
The SQLite library shall be cross-platform.
No parents |
S50100 |
The SQLite library shall be implemented in ANSI-C.
Parents: S50000 No children |
S50200 |
The SQLite library shall support text encoded as UTF-8,
UTF-16le, or UTF-16be.
Parents: S50000 Children: H10267 |
S50300 |
SQLite database files shall be processor and byte-order independent.
Parents: S50000 No children |
S60000 |
The SQLite library shall provide introspection capabilities to the
application.
No parents |
S60100 |
The SQLite library shall provide interfaces that an application can
use to discover fixed, compile-time characteristics of the
SQLite library.
Parents: S60000 Children: H10010 H10011 H10014 H10020 H10021 H10022 H10023 H10100 H10101 H10102 |
S60200 |
The SQLite library shall provide interfaces that an application can
use to find run-time performance characteristics and status of the
SQLite library.
Parents: S60000 Children: H12800 H12801 H12802 H12803 H12807 H12808 H12809 H12930 H12931 H12932 H12933 H12934 H17200 H17500 H17550 |
S60300 |
The SQLite library shall provide interfaces that permit an application
to query the schema of a database.
Parents: S60000 Children: H12850 |
S60400 |
The SQLite library shall provide interfaces that allow an application
to monitor sequence of queries and progress of submitted to SQLite.
Parents: S60000 Children: H12280 H12281 H12282 H12283 H12284 H12285 H12287 H12288 H12289 H12290 H12910 H12911 H12912 H12913 H12914 H12915 H12916 H12917 H12918 H12950 H12951 H12952 H12953 H12954 H12955 H12961 H12962 H12963 H12964 H12970 H12971 H12973 H12975 H12977 H12979 H12981 H12983 H12985 |
S60500 |
The SQLite library shall provide interfaces that allow an application
to discover the algorithms that SQLite has chosen to implement specific
SQL statements.
Parents: S60000 No children |
S60600 |
The SQLite library shall provide interfaces that allow an application
to discover relationships between SQLite objects.
Children: H13120 H13123 H13140 H13143 H13146 H13149 H13152 H16250 H16253 |
S70000 |
The SQLite library shall provide interfaces that promote the safe
construction and processing of SQL statements and data from
untrusted sources.
No parents |
S70100 |
The SQLite library shall provide the application means by which the
application can test and enforce compliance with database access
policies for any particular SQL statement.
Parents: S70000 Children: H12500 H12501 H12502 H12503 H12504 H12505 H12506 H12507 H12510 H12511 H12512 H12520 H12521 H12522 |
S70200 |
The SQLite library shall provide interfaces that test to see if an
SQL statement being received incrementally is complete.
Parents: S70000 |
S70300 |
The SQLite library shall support prepared statement objects with
late parameter binding
Children: H11302 H11304 H13300 H13330 H13500 H13506 H13509 H13512 H13515 H13518 H13521 H13524 H13527 H13530 H13533 H13536 H13539 H13542 H13545 H13548 H13551 H13600 H13601 H13620 H13621 H13640 H13641 H13660 H13661 |
S80000 |
SQLite shall exhibit ductile failure characteristics
No parents Children: S80100 |
S80100 |
SQLite shall make anomalies visible to the application
Parents: S80000 No children |
H10010 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_VERSION "3.6.6" #define SQLITE_VERSION_NUMBER 3006006 Parents: S60100 No children |
H10011 |
The SQLITE_VERSION #define in the sqlite3.h header file shall
evaluate to a string literal that is the SQLite version
with which the header file is associated.
Parents: S60100 No children |
H10014 |
The SQLITE_VERSION_NUMBER #define shall resolve to an integer
with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z
are the major version, minor version, and release number.
Parents: S60100 No children |
H10020 |
The sqlite3.h header file shall define the
the following interfaces:
SQLITE_EXTERN const char sqlite3_version[]; const char *sqlite3_libversion(void); int sqlite3_libversion_number(void); Parents: S60100 No children |
H10021 |
The sqlite3_libversion_number() interface shall return
an integer equal to SQLITE_VERSION_NUMBER.
Parents: S60100 No children |
H10022 |
The sqlite3_version string constant shall contain
the text of the SQLITE_VERSION string.
Parents: S60100 No children |
H10023 |
The sqlite3_libversion() function shall return
a pointer to the sqlite3_version string constant.
Parents: S60100 No children |
H10100 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_threadsafe(void); Parents: S60100 No children |
H10101 |
The sqlite3_threadsafe() function shall return zero if
and only if SQLite was compiled with mutexing code omitted.
Parents: S60100 No children |
H10102 |
The value returned by the sqlite3_threadsafe() function
shall remain the same across calls to sqlite3_config().
Parents: S60100 No children |
H10130 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_initialize(void); int sqlite3_shutdown(void); int sqlite3_os_init(void); int sqlite3_os_end(void); No children |
H10155 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_mem_methods sqlite3_mem_methods; struct sqlite3_mem_methods { void *(*xMalloc)(int); /* Memory allocation function */ void (*xFree)(void*); /* Free a prior allocation */ void *(*xRealloc)(void*,int); /* Resize an allocation */ int (*xSize)(void*); /* Return the size of an allocation */ int (*xRoundup)(int); /* Round up request size to allocation size */ int (*xInit)(void*); /* Initialize the memory allocator */ void (*xShutdown)(void*); /* Deinitialize the memory allocator */ void *pAppData; /* Argument to xInit() and xShutdown() */ }; Parents: S20120 No children |
H10160 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ #define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ #define SQLITE_CONFIG_SERIALIZED 3 /* nil */ #define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ #define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ #define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ #define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ #define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ #define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ #define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ /* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ #define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ #define SQLITE_CONFIG_PCACHE 14 /* sqlite3_pcache_methods* */ #define SQLITE_CONFIG_GETPCACHE 15 /* sqlite3_pcache_methods* */ Parents: S20000 No children |
H10170 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ Parents: S20000 No children |
H10200 |
The sqlite3.h header file shall define the
the following interfaces:
#ifdef SQLITE_INT64_TYPE typedef SQLITE_INT64_TYPE sqlite_int64; typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; #elif defined(_MSC_VER) || defined(__BORLANDC__) typedef __int64 sqlite_int64; typedef unsigned __int64 sqlite_uint64; #else typedef long long int sqlite_int64; typedef unsigned long long int sqlite_uint64; #endif typedef sqlite_int64 sqlite3_int64; typedef sqlite_uint64 sqlite3_uint64; Parents: S10110 No children |
H10201 |
The sqlite_int64 and sqlite3_int64 type shall specify
a 64-bit signed integer.
Parents: S10110 No children |
H10202 |
The sqlite_uint64 and sqlite3_uint64 type shall specify
a 64-bit unsigned integer.
Parents: S10110 No children |
H10210 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_OK 0 /* Successful result */ /* beginning-of-error-codes */ #define SQLITE_ERROR 1 /* SQL error or missing database */ #define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ #define SQLITE_PERM 3 /* Access permission denied */ #define SQLITE_ABORT 4 /* Callback routine requested an abort */ #define SQLITE_BUSY 5 /* The database file is locked */ #define SQLITE_LOCKED 6 /* A table in the database is locked */ #define SQLITE_NOMEM 7 /* A malloc() failed */ #define SQLITE_READONLY 8 /* Attempt to write a readonly database */ #define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ #define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ #define SQLITE_CORRUPT 11 /* The database disk image is malformed */ #define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ #define SQLITE_FULL 13 /* Insertion failed because database is full */ #define SQLITE_CANTOPEN 14 /* Unable to open the database file */ #define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ #define SQLITE_EMPTY 16 /* Database is empty */ #define SQLITE_SCHEMA 17 /* The database schema changed */ #define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ #define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ #define SQLITE_MISMATCH 20 /* Data type mismatch */ #define SQLITE_MISUSE 21 /* Library used incorrectly */ #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ #define SQLITE_AUTH 23 /* Authorization denied */ #define SQLITE_FORMAT 24 /* Auxiliary database format error */ #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ #define SQLITE_NOTADB 26 /* File opened that is not a database file */ #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ /* end-of-error-codes */ Parents: S10700 No children |
H10220 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) #define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) #define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) #define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) #define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) Parents: S10700 No children |
H10223 |
The symbolic name for an extended result code shall contains
a related primary result code as a prefix.
Parents: S10700 No children |
H10224 |
Primary result code names shall contain a single "_" character.
Parents: S10700 No children |
H10225 |
Extended result code names shall contain two or more "_" characters.
Parents: S10700 No children |
H10226 |
The numeric value of an extended result code shall contain the
numeric value of its corresponding primary result code in
its least significant 8 bits.
Parents: S10700 No children |
H10230 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_OPEN_READONLY 0x00000001 #define SQLITE_OPEN_READWRITE 0x00000002 #define SQLITE_OPEN_CREATE 0x00000004 #define SQLITE_OPEN_DELETEONCLOSE 0x00000008 #define SQLITE_OPEN_EXCLUSIVE 0x00000010 #define SQLITE_OPEN_MAIN_DB 0x00000100 #define SQLITE_OPEN_TEMP_DB 0x00000200 #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 #define SQLITE_OPEN_SUBJOURNAL 0x00002000 #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 #define SQLITE_OPEN_NOMUTEX 0x00008000 #define SQLITE_OPEN_FULLMUTEX 0x00010000 No children |
H10240 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_IOCAP_ATOMIC 0x00000001 #define SQLITE_IOCAP_ATOMIC512 0x00000002 #define SQLITE_IOCAP_ATOMIC1K 0x00000004 #define SQLITE_IOCAP_ATOMIC2K 0x00000008 #define SQLITE_IOCAP_ATOMIC4K 0x00000010 #define SQLITE_IOCAP_ATOMIC8K 0x00000020 #define SQLITE_IOCAP_ATOMIC16K 0x00000040 #define SQLITE_IOCAP_ATOMIC32K 0x00000080 #define SQLITE_IOCAP_ATOMIC64K 0x00000100 #define SQLITE_IOCAP_SAFE_APPEND 0x00000200 #define SQLITE_IOCAP_SEQUENTIAL 0x00000400 Parents: H11120 No children |
H10250 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_LOCK_NONE 0 #define SQLITE_LOCK_SHARED 1 #define SQLITE_LOCK_RESERVED 2 #define SQLITE_LOCK_PENDING 3 #define SQLITE_LOCK_EXCLUSIVE 4 No children |
H10260 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_SYNC_NORMAL 0x00002 #define SQLITE_SYNC_FULL 0x00003 #define SQLITE_SYNC_DATAONLY 0x00010 Parents: H11120 No children |
H10265 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_INTEGER 1 #define SQLITE_FLOAT 2 #define SQLITE_BLOB 4 #define SQLITE_NULL 5 #ifdef SQLITE_TEXT # undef SQLITE_TEXT #else # define SQLITE_TEXT 3 #endif #define SQLITE3_TEXT 3 No children |
H10267 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_UTF8 1 #define SQLITE_UTF16LE 2 #define SQLITE_UTF16BE 3 #define SQLITE_UTF16 4 /* Use native byte order */ #define SQLITE_ANY 5 /* sqlite3_create_function only */ #define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ No children |
H10280 |
The sqlite3.h header file shall define the
the following interfaces:
typedef void (*sqlite3_destructor_type)(void*); #define SQLITE_STATIC ((sqlite3_destructor_type)0) #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) Parents: S30100 No children |
H10310 |
The sqlite3.h header file shall define the
the following interfaces:
SQLITE_EXTERN char *sqlite3_temp_directory; Parents: S20000 No children |
H10330 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_enable_shared_cache(int); Parents: S30900 No children |
H10331 |
A successful invocation of sqlite3_enable_shared_cache(B)
will enable or disable shared cache mode for any subsequently
created database connection in the same process.
Parents: S30900 No children |
H10336 |
When shared cache is enabled, the sqlite3_create_module()
interface will always return an error.
Parents: S30900 No children |
H10337 |
The sqlite3_enable_shared_cache(B) interface returns
SQLITE_OK if shared cache was enabled or disabled successfully.
Parents: S30900 No children |
H10339 |
Shared cache is disabled by default.
Parents: S30900 No children |
H10510 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_complete(const char *sql); int sqlite3_complete16(const void *sql); Parents: S70200 No children |
H10511 |
A successful evaluation of sqlite3_complete() or
sqlite3_complete16() functions shall
return a numeric 1 if and only if the last non-whitespace
token in their input is a semicolon that is not in between
the BEGIN and END of a CREATE TRIGGER statement.
Parents: S70200 No children |
H10512 |
If a memory allocation error occurs during an invocation
of sqlite3_complete() or sqlite3_complete16() then the
routine shall return SQLITE_NOMEM.
Parents: S70200 No children |
H10530 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_sleep(int); Parents: S40410 No children |
H10533 |
The sqlite3_sleep(M) interface invokes the xSleep
method of the default VFS in order to
suspend execution of the current thread for at least
M milliseconds.
Parents: S40410 No children |
H10536 |
The sqlite3_sleep(M) interface returns the number of
milliseconds of sleep actually requested of the operating
system, which might be larger than the parameter M.
Parents: S40410 No children |
H11110 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_file sqlite3_file; struct sqlite3_file { const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ }; Parents: S20110 No children |
H11120 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_io_methods sqlite3_io_methods; struct sqlite3_io_methods { int iVersion; int (*xClose)(sqlite3_file*); int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); int (*xSync)(sqlite3_file*, int flags); int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); int (*xLock)(sqlite3_file*, int); int (*xUnlock)(sqlite3_file*, int); int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); int (*xFileControl)(sqlite3_file*, int op, void *pArg); int (*xSectorSize)(sqlite3_file*); int (*xDeviceCharacteristics)(sqlite3_file*); /* Additional methods may be added in future releases */ }; Parents: S20110 |
H11140 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_vfs sqlite3_vfs; struct sqlite3_vfs { int iVersion; /* Structure version number */ int szOsFile; /* Size of subclassed sqlite3_file */ int mxPathname; /* Maximum file pathname length */ sqlite3_vfs *pNext; /* Next registered VFS */ const char *zName; /* Name of this virtual file system */ void *pAppData; /* Pointer to application-specific data */ int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, int flags, int *pOutFlags); int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); void (*xDlClose)(sqlite3_vfs*, void*); int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); int (*xSleep)(sqlite3_vfs*, int microseconds); int (*xCurrentTime)(sqlite3_vfs*, double*); int (*xGetLastError)(sqlite3_vfs*, int, char *); /* New fields may be appended in figure versions. The iVersion ** value will increment whenever this happens. */ }; Parents: S20100 Children: H11190 |
H11190 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_ACCESS_EXISTS 0 #define SQLITE_ACCESS_READWRITE 1 #define SQLITE_ACCESS_READ 2 Parents: H11140 No children |
H11200 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); int sqlite3_vfs_unregister(sqlite3_vfs*); Parents: S20100 No children |
H11203 |
The sqlite3_vfs_find(N) interface returns a pointer to the
registered sqlite3_vfs object whose name exactly matches
the zero-terminated UTF-8 string N, or it returns NULL if
there is no match.
Parents: S20100 No children |
H11206 |
If the N parameter to sqlite3_vfs_find(N) is NULL then
the function returns a pointer to the default sqlite3_vfs
object if there is one, or NULL if there is no default
sqlite3_vfs object.
Parents: S20100 No children |
H11209 |
The sqlite3_vfs_register(P,F) interface registers the
well-formed sqlite3_vfs object P using the name given
by the zName field of the object.
Parents: S20100 No children |
H11212 |
Using the sqlite3_vfs_register(P,F) interface to register
the same sqlite3_vfs object multiple times is a harmless no-op.
Parents: S20100 No children |
H11215 |
The sqlite3_vfs_register(P,F) interface makes the sqlite3_vfs
object P the default sqlite3_vfs object if F is non-zero.
Parents: S20100 No children |
H11218 |
The sqlite3_vfs_unregister(P) interface unregisters the
sqlite3_vfs object P so that it is no longer returned by
subsequent calls to sqlite3_vfs_find().
Parents: S20100 No children |
H11300 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); Parents: S30800 No children |
H11302 |
The sqlite3_finalize(S) interface destroys the
prepared statement S and releases all
memory and file resources held by that object.
Parents: S70300 No children |
H11304 |
If the most recent call to sqlite3_step(S) for the
prepared statement S returned an error,
then sqlite3_finalize(S) returns that same error.
Parents: S70300 No children |
H11310 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_FCNTL_LOCKSTATE 1 #define SQLITE_GET_LOCKPROXYFILE 2 #define SQLITE_SET_LOCKPROXYFILE 3 #define SQLITE_LAST_ERRNO 4 Parents: S30800 Children: H10250 |
H11400 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_test_control(int op, ...); Parents: S30800 Children: H11410 |
H11410 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_TESTCTRL_PRNG_SAVE 5 #define SQLITE_TESTCTRL_PRNG_RESTORE 6 #define SQLITE_TESTCTRL_PRNG_RESET 7 #define SQLITE_TESTCTRL_BITVEC_TEST 8 #define SQLITE_TESTCTRL_FAULT_INSTALL 9 #define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 Parents: H11400 No children |
H12000 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3 sqlite3; Parents: S40200 No children |
H12010 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_close(sqlite3 *); No children |
H12011 |
A successful call to sqlite3_close(C) shall destroy the
database connection object C.
Parents: S30100 No children |
H12012 |
A successful call to sqlite3_close(C) shall return SQLITE_OK.
Parents: S30100 No children |
H12013 |
A successful call to sqlite3_close(C) shall release all
memory and system resources associated with database connection
C.
Parents: S30100 No children |
H12014 |
A call to sqlite3_close(C) on a database connection C that
has one or more open prepared statements shall fail with
an SQLITE_BUSY error code.
Parents: S30100 No children |
H12015 |
A call to sqlite3_close(C) where C is a NULL pointer shall
be a harmless no-op returning SQLITE_OK.
Parents: S30100 No children |
H12019 |
When sqlite3_close(C) is invoked on a database connection C
that has a pending transaction, the transaction shall be
rolled back.
Parents: S30100 No children |
H12100 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_exec( sqlite3*, /* An open database */ const char *sql, /* SQL to be evaluated */ int (*callback)(void*,int,char**,char**), /* Callback function */ void *, /* 1st argument to callback */ char **errmsg /* Error msg written here */ ); Parents: S10000 No children |
H12101 |
A successful invocation of sqlite3_exec(D,S,C,A,E)
shall sequentially evaluate all of the UTF-8 encoded,
semicolon-separated SQL statements in the zero-terminated
string S within the context of the database connection D.
Parents: S10000 No children |
H12102 |
If the S parameter to sqlite3_exec(D,S,C,A,E) is NULL then
the actions of the interface shall be the same as if the
S parameter were an empty string.
Parents: S10000 No children |
H12104 |
The return value of sqlite3_exec() shall be SQLITE_OK if all
SQL statements run successfully and to completion.
Parents: S10000 No children |
H12105 |
The return value of sqlite3_exec() shall be an appropriate
non-zero error code if any SQL statement fails.
Parents: S10000 No children |
H12107 |
If one or more of the SQL statements handed to sqlite3_exec()
return results and the 3rd parameter is not NULL, then
the callback function specified by the 3rd parameter shall be
invoked once for each row of result.
Parents: S10000 No children |
H12110 |
If the callback returns a non-zero value then sqlite3_exec()
shall abort the SQL statement it is currently evaluating,
skip all subsequent SQL statements, and return SQLITE_ABORT.
Parents: S10000 No children |
H12113 |
The sqlite3_exec() routine shall pass its 4th parameter through
as the 1st parameter of the callback.
Parents: S10000 No children |
H12116 |
The sqlite3_exec() routine shall set the 2nd parameter of its
callback to be the number of columns in the current row of
result.
Parents: S10000 No children |
H12119 |
The sqlite3_exec() routine shall set the 3rd parameter of its
callback to be an array of pointers to strings holding the
values for each column in the current result set row as
obtained from sqlite3_column_text().
Parents: S10000 No children |
H12122 |
The sqlite3_exec() routine shall set the 4th parameter of its
callback to be an array of pointers to strings holding the
names of result columns as obtained from sqlite3_column_name().
Parents: S10000 No children |
H12125 |
If the 3rd parameter to sqlite3_exec() is NULL then
sqlite3_exec() shall silently discard query results.
Parents: S10000 No children |
H12131 |
If an error occurs while parsing or evaluating any of the SQL
statements in the S parameter of sqlite3_exec(D,S,C,A,E) and if
the E parameter is not NULL, then sqlite3_exec() shall store
in *E an appropriate error message written into memory obtained
from sqlite3_malloc().
Parents: S10000 No children |
H12134 |
The sqlite3_exec(D,S,C,A,E) routine shall set the value of
*E to NULL if E is not NULL and there are no errors.
Parents: S10000 No children |
H12137 |
The sqlite3_exec(D,S,C,A,E) function shall set the error code
and message accessible via sqlite3_errcode(),
sqlite3_extended_errcode(),
sqlite3_errmsg(), and sqlite3_errmsg16().
Parents: S10000 No children |
H12138 |
If the S parameter to sqlite3_exec(D,S,C,A,E) is NULL or an
empty string or contains nothing other than whitespace, comments,
and/or semicolons, then results of sqlite3_errcode(),
sqlite3_extended_errcode(),
sqlite3_errmsg(), and sqlite3_errmsg16()
shall reset to indicate no errors.
Parents: S10000 No children |
H12200 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_extended_result_codes(sqlite3*, int onoff); Parents: S10700 No children |
H12201 |
Each new database connection shall have the
extended result codes feature disabled by default.
Parents: S10700 No children |
H12202 |
The sqlite3_extended_result_codes(D,F) interface shall enable
extended result codes for the database connection D
if the F parameter is true, or disable them if F is false.
Parents: S10700 No children |
H12220 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); Parents: S10700 No children |
H12221 |
The sqlite3_last_insert_rowid() function shall return the rowid
of the most recent successful INSERT performed on the same
database connection and within the same or higher level
trigger context, or zero if there have been no qualifying
INSERT statements.
Parents: S10700 No children |
H12223 |
The sqlite3_last_insert_rowid() function shall return the
same value when called from the same trigger context
immediately before and after a ROLLBACK.
Parents: S10700 No children |
H12240 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_changes(sqlite3*); Parents: S10600 No children |
H12241 |
The sqlite3_changes() function shall return the number of
row changes caused by the most recent INSERT, UPDATE,
or DELETE statement on the same database connection and
within the same or higher trigger context, or zero if there have
not been any qualifying row changes.
Parents: S10600 No children |
H12243 |
Statements of the form "DELETE FROM tablename" with no
WHERE clause shall cause subsequent calls to
sqlite3_changes() to return zero, regardless of the
number of rows originally in the table.
Parents: S10600 No children |
H12260 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_total_changes(sqlite3*); Parents: S10600 No children |
H12261 |
The sqlite3_total_changes() returns the total number
of row changes caused by INSERT, UPDATE, and/or DELETE
statements on the same database connection, in any
trigger context, since the database connection was created.
Parents: S10600 No children |
H12263 |
Statements of the form "DELETE FROM tablename" with no
WHERE clause shall not change the value returned
by sqlite3_total_changes().
Parents: S10600 No children |
H12270 |
The sqlite3.h header file shall define the
the following interfaces:
void sqlite3_interrupt(sqlite3*); Parents: S30500 No children |
H12271 |
The sqlite3_interrupt() interface will force all running
SQL statements associated with the same database connection
to halt after processing at most one additional row of data.
Parents: S30500 No children |
H12272 |
Any SQL statement that is interrupted by sqlite3_interrupt()
will return SQLITE_INTERRUPT.
Parents: S30500 No children |
H12280 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); void *sqlite3_profile(sqlite3*, void(*xProfile)(void*,const char*,sqlite3_uint64), void*); Parents: S60400 No children |
H12281 |
The callback function registered by sqlite3_trace()
shall be invoked
whenever an SQL statement first begins to execute and
whenever a trigger subprogram first begins to run.
Parents: S60400 No children |
H12282 |
Each call to sqlite3_trace() shall override the previously
registered trace callback.
Parents: S60400 No children |
H12283 |
A NULL trace callback shall disable tracing.
Parents: S60400 No children |
H12284 |
The first argument to the trace callback shall be a copy of
the pointer which was the 3rd argument to sqlite3_trace().
Parents: S60400 No children |
H12285 |
The second argument to the trace callback is a
zero-terminated UTF-8 string containing the original text
of the SQL statement as it was passed into sqlite3_prepare_v2()
or the equivalent, or an SQL comment indicating the beginning
of a trigger subprogram.
Parents: S60400 No children |
H12287 |
The callback function registered by sqlite3_profile() is invoked
as each SQL statement finishes.
Parents: S60400 No children |
H12288 |
The first parameter to the profile callback is a copy of
the 3rd parameter to sqlite3_profile().
Parents: S60400 No children |
H12289 |
The second parameter to the profile callback is a
zero-terminated UTF-8 string that contains the complete text of
the SQL statement as it was processed by sqlite3_prepare_v2()
or the equivalent.
Parents: S60400 No children |
H12290 |
The third parameter to the profile callback is an estimate
of the number of nanoseconds of wall-clock time required to
run the SQL statement from start to finish.
Parents: S60400 No children |
H12310 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); Parents: S40400 No children |
H12311 |
The sqlite3_busy_handler(D,C,A) function shall replace
busy callback in the database connection D with a new
a new busy handler C and application data pointer A.
Parents: S40400 No children |
H12312 |
Newly created database connections shall have a busy
handler of NULL.
Parents: S40400 No children |
H12314 |
When two or more database connections share a
common cache,
the busy handler for the database connection currently using
the cache shall be invoked when the cache encounters a lock.
Parents: S40400 No children |
H12316 |
If a busy handler callback returns zero, then the SQLite interface
that provoked the locking event shall return SQLITE_BUSY.
Parents: S40400 No children |
H12318 |
SQLite shall invokes the busy handler with two arguments which
are a copy of the pointer supplied by the 3rd parameter to
sqlite3_busy_handler() and a count of the number of prior
invocations of the busy handler for the same locking event.
Parents: S40400 No children |
H12340 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_busy_timeout(sqlite3*, int ms); Parents: S40410 No children |
H12341 |
The sqlite3_busy_timeout() function shall override any prior
sqlite3_busy_timeout() or sqlite3_busy_handler() setting
on the same database connection.
Parents: S40410 No children |
H12343 |
If the 2nd parameter to sqlite3_busy_timeout() is less than
or equal to zero, then the busy handler shall be cleared so that
all subsequent locking events immediately return SQLITE_BUSY.
Parents: S40410 No children |
H12344 |
If the 2nd parameter to sqlite3_busy_timeout() is a positive
number N, then a busy handler shall be set that repeatedly calls
the xSleep() method in the VFS interface until
either the lock clears or until the cumulative sleep time
reported back by xSleep() exceeds N milliseconds.
Parents: S40410 No children |
H12370 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_get_table( sqlite3 *db, /* An open database */ const char *zSql, /* SQL to be evaluated */ char ***pazResult, /* Results of the query */ int *pnRow, /* Number of result rows written here */ int *pnColumn, /* Number of result columns written here */ char **pzErrmsg /* Error msg written here */ ); void sqlite3_free_table(char **result); Parents: S10000 No children |
H12371 |
If a sqlite3_get_table() fails a memory allocation, then
it shall free the result table under construction, abort the
query in process, skip any subsequent queries, set the
*pazResult output pointer to NULL and return SQLITE_NOMEM.
Parents: S10000 No children |
H12373 |
If the pnColumn parameter to sqlite3_get_table() is not NULL
then a successful invocation of sqlite3_get_table() shall
write the number of columns in the
result set of the query into *pnColumn.
Parents: S10000 No children |
H12374 |
If the pnRow parameter to sqlite3_get_table() is not NULL
then a successful invocation of sqlite3_get_table() shall
writes the number of rows in the
result set of the query into *pnRow.
Parents: S10000 No children |
H12376 |
A successful invocation of sqlite3_get_table() that computes
N rows of result with C columns per row shall make *pazResult
point to an array of pointers to (N+1)*C strings where the first
C strings are column names as obtained from
sqlite3_column_name() and the rest are column result values
obtained from sqlite3_column_text().
Parents: S10000 No children |
H12379 |
The values in the pazResult array returned by sqlite3_get_table()
shall remain valid until cleared by sqlite3_free_table().
Parents: S10000 No children |
H12382 |
When an error occurs during evaluation of sqlite3_get_table()
the function shall set *pazResult to NULL, write an error message
into memory obtained from sqlite3_malloc(), make
**pzErrmsg point to that error message, and return a
appropriate error code.
Parents: S10000 No children |
H12500 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_set_authorizer( sqlite3*, int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), void *pUserData ); Parents: S70100 |
H12501 |
The sqlite3_set_authorizer(D,...) interface registers a
authorizer callback with database connection D.
Parents: S70100 No children |
H12502 |
The authorizer callback is invoked as SQL statements are
being parseed and compiled.
Parents: S70100 No children |
H12503 |
If the authorizer callback returns any value other than
SQLITE_IGNORE, SQLITE_OK, or SQLITE_DENY, then
the application interface call that caused
the authorizer callback to run shall fail with an
SQLITE_ERROR error code and an appropriate error message.
Parents: S70100 No children |
H12504 |
When the authorizer callback returns SQLITE_OK, the operation
described is processed normally.
Parents: S70100 No children |
H12505 |
When the authorizer callback returns SQLITE_DENY, the
application interface call that caused the
authorizer callback to run shall fail
with an SQLITE_ERROR error code and an error message
explaining that access is denied.
Parents: S70100 No children |
H12506 |
If the authorizer code (the 2nd parameter to the authorizer
callback) is SQLITE_READ and the authorizer callback returns
SQLITE_IGNORE, then the prepared statement is constructed to
insert a NULL value in place of the table column that would have
been read if SQLITE_OK had been returned.
Parents: S70100 No children |
H12507 |
If the authorizer code (the 2nd parameter to the authorizer
callback) is anything other than SQLITE_READ, then
a return of SQLITE_IGNORE has the same effect as SQLITE_DENY.
Parents: S70100 No children |
H12510 |
The first parameter to the authorizer callback is a copy of
the third parameter to the sqlite3_set_authorizer() interface.
Parents: S70100 No children |
H12511 |
The second parameter to the callback is an integer
action code that specifies the particular action
to be authorized.
Parents: S70100 No children |
H12512 |
The third through sixth parameters to the callback are
zero-terminated strings that contain
additional details about the action to be authorized.
Parents: S70100 No children |
H12520 |
Each call to sqlite3_set_authorizer() overrides
any previously installed authorizer.
Parents: S70100 No children |
H12521 |
A NULL authorizer means that no authorization
callback is invoked.
Parents: S70100 No children |
H12522 |
The default authorizer is NULL.
Parents: S70100 No children |
H12550 |
The sqlite3.h header file shall define the
the following interfaces:
/******************************************* 3rd ************ 4th ***********/ #define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ #define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ #define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ #define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ #define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ #define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ #define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ #define SQLITE_CREATE_VIEW 8 /* View Name NULL */ #define SQLITE_DELETE 9 /* Table Name NULL */ #define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ #define SQLITE_DROP_TABLE 11 /* Table Name NULL */ #define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ #define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ #define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ #define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ #define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ #define SQLITE_DROP_VIEW 17 /* View Name NULL */ #define SQLITE_INSERT 18 /* Table Name NULL */ #define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ #define SQLITE_READ 20 /* Table Name Column Name */ #define SQLITE_SELECT 21 /* NULL NULL */ #define SQLITE_TRANSACTION 22 /* NULL NULL */ #define SQLITE_UPDATE 23 /* Table Name Column Name */ #define SQLITE_ATTACH 24 /* Filename NULL */ #define SQLITE_DETACH 25 /* Database Name NULL */ #define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ #define SQLITE_REINDEX 27 /* Index Name NULL */ #define SQLITE_ANALYZE 28 /* Table Name NULL */ #define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ #define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ #define SQLITE_FUNCTION 31 /* NULL Function Name */ #define SQLITE_COPY 0 /* No longer used */ Parents: H12500 No children |
H12551 |
The second parameter to an
authorizer callback shall be an integer
authorizer code that specifies what action
is being authorized.
Parents: H12500 No children |
H12552 |
The 3rd and 4th parameters to the
authorization callback
shall be parameters or NULL depending on which
authorizer code is used as the second parameter.
Parents: H12500 No children |
H12553 |
The 5th parameter to the
authorizer callback shall be the name
of the database (example: "main", "temp", etc.) if applicable.
Parents: H12500 No children |
H12554 |
The 6th parameter to the
authorizer callback shall be the name
of the inner-most trigger or view that is responsible for
the access attempt or NULL if this access attempt is directly from
top-level SQL code.
Parents: H12500 No children |
H12590 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ Parents: H12500 No children |
H12600 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_load_extension( sqlite3 *db, /* Load the extension into this database connection */ const char *zFile, /* Name of the shared library containing extension */ const char *zProc, /* Entry point. Derived from zFile if 0 */ char **pzErrMsg /* Put error message here if not 0 */ ); Parents: S20500 No children |
H12620 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_enable_load_extension(sqlite3 *db, int onoff); Parents: S20500 No children |
H12640 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_auto_extension(void (*xEntryPoint)(void)); Parents: S20500 No children |
H12660 |
The sqlite3.h header file shall define the
the following interfaces:
void sqlite3_reset_auto_extension(void); Parents: S20500 No children |
H12700 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_open( const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb /* OUT: SQLite db handle */ ); int sqlite3_open16( const void *filename, /* Database filename (UTF-16) */ sqlite3 **ppDb /* OUT: SQLite db handle */ ); int sqlite3_open_v2( const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb, /* OUT: SQLite db handle */ int flags, /* Flags */ const char *zVfs /* Name of VFS module to use */ ); Parents: S40200 Children: H10230 |
H12701 |
The sqlite3_open(), sqlite3_open16(), and
sqlite3_open_v2() interfaces create a new
database connection associated with
the database file given in their first parameter.
Parents: S40200 No children |
H12702 |
The filename argument is interpreted as UTF-8
for sqlite3_open() and sqlite3_open_v2() and as UTF-16
in the native byte order for sqlite3_open16().
Parents: S40200 No children |
H12703 |
A successful invocation of sqlite3_open(), sqlite3_open16(),
or sqlite3_open_v2() writes a pointer to a new
database connection into *ppDb.
Parents: S40200 No children |
H12704 |
The sqlite3_open(), sqlite3_open16(), and
sqlite3_open_v2() interfaces return SQLITE_OK upon success,
or an appropriate error code on failure.
Parents: S40200 No children |
H12706 |
The default text encoding for a new database created using
sqlite3_open() or sqlite3_open_v2() will be UTF-8.
Parents: S40200 No children |
H12707 |
The default text encoding for a new database created using
sqlite3_open16() will be UTF-16.
Parents: S40200 No children |
H12709 |
The sqlite3_open(F,D) interface is equivalent to
sqlite3_open_v2(F,D,G,0) where the G parameter is
SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE.
Parents: S40200 No children |
H12711 |
If the G parameter to sqlite3_open_v2(F,D,G,V) contains the
bit value SQLITE_OPEN_READONLY then the database is opened
for reading only.
Parents: S40200 No children |
H12712 |
If the G parameter to sqlite3_open_v2(F,D,G,V) contains the
bit value SQLITE_OPEN_READWRITE then the database is opened
reading and writing if possible, or for reading only if the
file is write protected by the operating system.
Parents: S40200 No children |
H12713 |
If the G parameter to sqlite3_open_v2(F,D,G,V) omits the
bit value SQLITE_OPEN_CREATE and the database does not
previously exist, an error is returned.
Parents: S40200 No children |
H12714 |
If the G parameter to sqlite3_open_v2(F,D,G,V) contains the
bit value SQLITE_OPEN_CREATE and the database does not
previously exist, then an attempt is made to create and
initialize the database.
Parents: S40200 No children |
H12717 |
If the filename argument to sqlite3_open(), sqlite3_open16(),
or sqlite3_open_v2() is ":memory:", then an private,
ephemeral, in-memory database is created for the connection.
Parents: S40200 No children |
H12719 |
If the filename is NULL or an empty string, then a private,
ephemeral on-disk database will be created.
Parents: S40200 No children |
H12721 |
The database connection created by sqlite3_open_v2(F,D,G,V)
will use the sqlite3_vfs object identified by the V parameter,
or the default sqlite3_vfs object if V is a NULL pointer.
Parents: S40200 No children |
H12723 |
Two database connections will share a common cache if both were
opened with the same VFS while shared cache mode was enabled and
if both filenames compare equal using memcmp() after having been
processed by the xFullPathname method of the VFS.
Parents: S40200 No children |
H12760 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_limit(sqlite3*, int id, int newVal); Parents: S20600 Children: H12790 |
H12762 |
A successful call to sqlite3_limit(D,C,V) where V is
positive changes the limit on the size of construct C in the
database connection D to the lesser of V and the hard upper
bound on the size of C that is set at compile-time.
Parents: S20600 No children |
H12766 |
A successful call to sqlite3_limit(D,C,V) where V is negative
leaves the state of the database connection D unchanged.
Parents: S20600 No children |
H12769 |
A successful call to sqlite3_limit(D,C,V) returns the
value of the limit on the size of construct C in the
database connection D as it was prior to the call.
Parents: S20600 No children |
H12790 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_LIMIT_LENGTH 0 #define SQLITE_LIMIT_SQL_LENGTH 1 #define SQLITE_LIMIT_COLUMN 2 #define SQLITE_LIMIT_EXPR_DEPTH 3 #define SQLITE_LIMIT_COMPOUND_SELECT 4 #define SQLITE_LIMIT_VDBE_OP 5 #define SQLITE_LIMIT_FUNCTION_ARG 6 #define SQLITE_LIMIT_ATTACHED 7 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 #define SQLITE_LIMIT_VARIABLE_NUMBER 9 Parents: H12760 No children |
H12800 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_errcode(sqlite3 *db); int sqlite3_extended_errcode(sqlite3 *db); const char *sqlite3_errmsg(sqlite3*); const void *sqlite3_errmsg16(sqlite3*); Parents: S60200 No children |
H12801 |
The sqlite3_errcode(D) interface returns the numeric
result code or extended result code for the most recently
failed interface call associated with the database connection D.
Parents: S60200 No children |
H12802 |
The sqlite3_extended_errcode(D) interface returns the numeric
extended result code for the most recently
failed interface call associated with the database connection D.
Parents: S60200 No children |
H12803 |
The sqlite3_errmsg(D) and sqlite3_errmsg16(D)
interfaces return English-language text that describes
the error in the mostly recently failed interface call,
encoded as either UTF-8 or UTF-16 respectively.
Parents: S60200 No children |
H12807 |
The strings returned by sqlite3_errmsg() and sqlite3_errmsg16()
are valid until the next SQLite interface call.
Parents: S60200 No children |
H12808 |
Calls to API routines that do not return an error code
(example: sqlite3_data_count()) do not
change the error code or message returned by
sqlite3_errcode(), sqlite3_extended_errcode(),
sqlite3_errmsg(), or sqlite3_errmsg16().
Parents: S60200 No children |
H12809 |
Interfaces that are not associated with a specific
database connection (examples:
sqlite3_mprintf() or sqlite3_enable_shared_cache()
do not change the values returned by
sqlite3_errcode(), sqlite3_extended_errcode(),
sqlite3_errmsg(), or sqlite3_errmsg16().
Parents: S60200 No children |
H12850 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_table_column_metadata( sqlite3 *db, /* Connection handle */ const char *zDbName, /* Database name or NULL */ const char *zTableName, /* Table name */ const char *zColumnName, /* Column name */ char const **pzDataType, /* OUTPUT: Declared data type */ char const **pzCollSeq, /* OUTPUT: Collation sequence name */ int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ int *pPrimaryKey, /* OUTPUT: True if column part of PK */ int *pAutoinc /* OUTPUT: True if column is auto-increment */ ); Parents: S60300 No children |
H12910 |
The sqlite3.h header file shall define the
the following interfaces:
void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); Parents: S60400 No children |
H12911 |
The callback function registered by sqlite3_progress_handler()
is invoked periodically during long running calls to
sqlite3_step().
Parents: S60400 No children |
H12912 |
The progress callback is invoked once for every N virtual
machine opcodes, where N is the second argument to
the sqlite3_progress_handler() call that registered
the callback. If N is less than 1, sqlite3_progress_handler()
acts as if a NULL progress handler had been specified.
Parents: S60400 No children |
H12913 |
The progress callback itself is identified by the third
argument to sqlite3_progress_handler().
Parents: S60400 No children |
H12914 |
The fourth argument to sqlite3_progress_handler() is a
void pointer passed to the progress callback
function each time it is invoked.
Parents: S60400 No children |
H12915 |
If a call to sqlite3_step() results in fewer than N opcodes
being executed, then the progress callback is never invoked.
Parents: S60400 No children |
H12916 |
Every call to sqlite3_progress_handler()
overwrites any previously registered progress handler.
Parents: S60400 No children |
H12917 |
If the progress handler callback is NULL then no progress
handler is invoked.
Parents: S60400 No children |
H12918 |
If the progress callback returns a result other than 0, then
the behavior is a if sqlite3_interrupt() had been called.
No children |
H12930 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_get_autocommit(sqlite3*); Parents: S60200 No children |
H12931 |
The sqlite3_get_autocommit(D) interface returns non-zero or
zero if the database connection D is or is not in autocommit
mode, respectively.
Parents: S60200 No children |
H12932 |
Autocommit mode is on by default.
Parents: S60200 No children |
H12933 |
Autocommit mode is disabled by a successful BEGIN statement.
Parents: S60200 No children |
H12934 |
Autocommit mode is enabled by a successful COMMIT or ROLLBACK
statement.
Parents: S60200 No children |
H12950 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); Parents: S60400 No children |
H12951 |
The sqlite3_commit_hook(D,F,P) interface registers the
callback function F to be invoked with argument P whenever
a transaction commits on the database connection D.
Parents: S60400 No children |
H12952 |
The sqlite3_commit_hook(D,F,P) interface returns the P argument
from the previous call with the same database connection D,
or NULL on the first call for a particular database connection D.
Parents: S60400 No children |
H12953 |
Each call to sqlite3_commit_hook() overwrites the callback
registered by prior calls.
Parents: S60400 No children |
H12954 |
If the F argument to sqlite3_commit_hook(D,F,P) is NULL
then the commit hook callback is canceled and no callback
is invoked when a transaction commits.
Parents: S60400 No children |
H12955 |
If the commit callback returns non-zero then the commit is
converted into a rollback.
Parents: S60400 No children |
H12961 |
The sqlite3_rollback_hook(D,F,P) interface registers the
callback function F to be invoked with argument P whenever
a transaction rolls back on the database connection D.
Parents: S60400 No children |
H12962 |
The sqlite3_rollback_hook(D,F,P) interface returns the P
argument from the previous call with the same
database connection D, or NULL on the first call
for a particular database connection D.
Parents: S60400 No children |
H12963 |
Each call to sqlite3_rollback_hook() overwrites the callback
registered by prior calls.
Parents: S60400 No children |
H12964 |
If the F argument to sqlite3_rollback_hook(D,F,P) is NULL
then the rollback hook callback is canceled and no callback
is invoked when a transaction rolls back.
Parents: S60400 No children |
H12970 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_update_hook( sqlite3*, void(*)(void *,int ,char const *,char const *,sqlite3_int64), void* ); Parents: S60400 No children |
H12971 |
The sqlite3_update_hook(D,F,P) interface causes the callback
function F to be invoked with first parameter P whenever
a table row is modified, inserted, or deleted on
the database connection D.
Parents: S60400 No children |
H12973 |
The sqlite3_update_hook(D,F,P) interface returns the value
of P for the previous call on the same database connection D,
or NULL for the first call.
Parents: S60400 No children |
H12975 |
If the update hook callback F in sqlite3_update_hook(D,F,P)
is NULL then the no update callbacks are made.
Parents: S60400 No children |
H12977 |
Each call to sqlite3_update_hook(D,F,P) overrides prior calls
to the same interface on the same database connection D.
Parents: S60400 No children |
H12979 |
The update hook callback is not invoked when internal system
tables such as sqlite_master and sqlite_sequence are modified.
Parents: S60400 No children |
H12981 |
The second parameter to the update callback
is one of SQLITE_INSERT, SQLITE_DELETE or SQLITE_UPDATE,
depending on the operation that caused the callback to be invoked.
Parents: S60400 No children |
H12983 |
The third and fourth arguments to the callback contain pointers
to zero-terminated UTF-8 strings which are the names of the
database and table that is being updated.
Parents: S60400 No children |
H12985 |
The final callback parameter is the rowid of the row after
the change occurs.
Parents: S60400 No children |
H13000 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_stmt sqlite3_stmt; Parents: H13010 |
H13010 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_prepare( sqlite3 *db, /* Database handle */ const char *zSql, /* SQL statement, UTF-8 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const char **pzTail /* OUT: Pointer to unused portion of zSql */ ); int sqlite3_prepare_v2( sqlite3 *db, /* Database handle */ const char *zSql, /* SQL statement, UTF-8 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const char **pzTail /* OUT: Pointer to unused portion of zSql */ ); int sqlite3_prepare16( sqlite3 *db, /* Database handle */ const void *zSql, /* SQL statement, UTF-16 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); int sqlite3_prepare16_v2( sqlite3 *db, /* Database handle */ const void *zSql, /* SQL statement, UTF-16 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); Parents: S10000 Children: H13000 |
H13011 |
The sqlite3_prepare(db,zSql,...) and
sqlite3_prepare_v2(db,zSql,...) interfaces interpret the
text in their zSql parameter as UTF-8.
Parents: S10000 No children |
H13012 |
The sqlite3_prepare16(db,zSql,...) and
sqlite3_prepare16_v2(db,zSql,...) interfaces interpret the
text in their zSql parameter as UTF-16 in the native byte order.
Parents: S10000 No children |
H13013 |
If the nByte argument to sqlite3_prepare_v2(db,zSql,nByte,...)
and its variants is less than zero, the SQL text is
read from zSql is read up to the first zero terminator.
Parents: S10000 No children |
H13014 |
If the nByte argument to sqlite3_prepare_v2(db,zSql,nByte,...)
and its variants is non-negative, then at most nBytes bytes of
SQL text is read from zSql.
Parents: S10000 No children |
H13015 |
In sqlite3_prepare_v2(db,zSql,N,P,pzTail) and its variants
if the zSql input text contains more than one SQL statement
and pzTail is not NULL, then *pzTail is made to point to the
first byte past the end of the first SQL statement in zSql.
Parents: S10000 No children |
H13016 |
A successful call to sqlite3_prepare_v2(db,zSql,N,ppStmt,...)
or one of its variants writes into *ppStmt a pointer to a new
prepared statement or a pointer to NULL if zSql contains
nothing other than whitespace or comments.
Parents: S10000 No children |
H13019 |
The sqlite3_prepare_v2() interface and its variants return
SQLITE_OK or an appropriate error code upon failure.
Parents: S10000 No children |
H13021 |
Before sqlite3_prepare(db,zSql,nByte,ppStmt,pzTail) or its
variants returns an error (any value other than SQLITE_OK),
they first set *ppStmt to NULL.
Parents: S10000 No children |
H13100 |
The sqlite3.h header file shall define the
the following interfaces:
const char *sqlite3_sql(sqlite3_stmt *pStmt); Parents: H13000 No children |
H13101 |
If the prepared statement passed as the argument to
sqlite3_sql() was compiled using either sqlite3_prepare_v2() or
sqlite3_prepare16_v2(), then sqlite3_sql() returns
a pointer to a zero-terminated string containing a UTF-8 rendering
of the original SQL statement.
Parents: H13000 No children |
H13102 |
If the prepared statement passed as the argument to
sqlite3_sql() was compiled using either sqlite3_prepare() or
sqlite3_prepare16(), then sqlite3_sql() returns a NULL pointer.
Parents: H13000 No children |
H13103 |
The string returned by sqlite3_sql(S) is valid until the
prepared statement S is deleted using sqlite3_finalize(S).
Parents: H13000 No children |
H13120 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3 *sqlite3_db_handle(sqlite3_stmt*); Parents: S60600 No children |
H13123 |
The sqlite3_db_handle(S) interface returns a pointer
to the database connection associated with the
prepared statement S.
Parents: S60600 No children |
H13140 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); Parents: S60600 No children |
H13143 |
If D is a database connection that holds one or more
unfinalized prepared statements and S is a NULL pointer,
then sqlite3_next_stmt(D, S) routine shall return a pointer
to one of the prepared statements associated with D.
Parents: S60600 No children |
H13146 |
If D is a database connection that holds no unfinalized
prepared statements and S is a NULL pointer, then
sqlite3_next_stmt(D, S) routine shall return a NULL pointer.
Parents: S60600 No children |
H13149 |
If S is a prepared statement in the database connection D
and S is not the last prepared statement in D, then
sqlite3_next_stmt(D, S) routine shall return a pointer
to the next prepared statement in D after S.
Parents: S60600 No children |
H13152 |
If S is the last prepared statement in the
database connection D then the sqlite3_next_stmt(D, S)
routine shall return a NULL pointer.
Parents: S60600 No children |
H13200 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_step(sqlite3_stmt*); Parents: S10000 No children |
H13202 |
If the prepared statement S is ready to be run, then
sqlite3_step(S) advances that prepared statement until
completion or until it is ready to return another row of the
result set, or until an interrupt
or a run-time error occurs.
Parents: S10000 No children |
H13300 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_finalize(sqlite3_stmt *pStmt); No children |
H13330 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_reset(sqlite3_stmt *pStmt); Parents: S70300 No children |
H13500 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); int sqlite3_bind_double(sqlite3_stmt*, int, double); int sqlite3_bind_int(sqlite3_stmt*, int, int); int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); int sqlite3_bind_null(sqlite3_stmt*, int); int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); Parents: S70300 No children |
H13506 |
The SQL statement compiler recognizes tokens of the forms
"?", "?NNN", "$VVV", ":VVV", and "@VVV" as SQL parameters,
where NNN is any sequence of one or more digits
and where VVV is any sequence of one or more alphanumeric
characters or "::" optionally followed by a string containing
no spaces and contained within parentheses.
Parents: S70300 No children |
H13509 |
The initial value of an SQL parameter is NULL.
Parents: S70300 No children |
H13512 |
The index of an "?" SQL parameter is one larger than the
largest index of SQL parameter to the left, or 1 if
the "?" is the leftmost SQL parameter.
Parents: S70300 No children |
H13515 |
The index of an "?NNN" SQL parameter is the integer NNN.
Parents: S70300 No children |
H13518 |
The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is
the same as the index of leftmost occurrences of the same
parameter, or one more than the largest index over all
parameters to the left if this is the first occurrence
of this parameter, or 1 if this is the leftmost parameter.
Parents: S70300 No children |
H13521 |
The SQL statement compiler fails with an SQLITE_RANGE
error if the index of an SQL parameter is less than 1
or greater than the compile-time SQLITE_MAX_VARIABLE_NUMBER
parameter.
Parents: S70300 No children |
H13524 |
Calls to sqlite3_bind(S,N,V,...)
associate the value V with all SQL parameters having an
index of N in the prepared statement S.
Parents: S70300 No children |
H13527 |
Calls to sqlite3_bind(S,N,...)
override prior calls with the same values of S and N.
Parents: S70300 No children |
H13530 |
Bindings established by sqlite3_bind(S,...)
persist across calls to sqlite3_reset(S).
Parents: S70300 No children |
H13533 |
In calls to sqlite3_bind_blob(S,N,V,L,D),
sqlite3_bind_text(S,N,V,L,D), or
sqlite3_bind_text16(S,N,V,L,D) SQLite binds the first L
bytes of the BLOB or string pointed to by V, when L
is non-negative.
Parents: S70300 No children |
H13536 |
In calls to sqlite3_bind_text(S,N,V,L,D) or
sqlite3_bind_text16(S,N,V,L,D) SQLite binds characters
from V through the first zero character when L is negative.
Parents: S70300 No children |
H13539 |
In calls to sqlite3_bind_blob(S,N,V,L,D),
sqlite3_bind_text(S,N,V,L,D), or
sqlite3_bind_text16(S,N,V,L,D) when D is the special
constant SQLITE_STATIC, SQLite assumes that the value V
is held in static unmanaged space that will not change
during the lifetime of the binding.
Parents: S70300 No children |
H13542 |
In calls to sqlite3_bind_blob(S,N,V,L,D),
sqlite3_bind_text(S,N,V,L,D), or
sqlite3_bind_text16(S,N,V,L,D) when D is the special
constant SQLITE_TRANSIENT, the routine makes a
private copy of the value V before it returns.
Parents: S70300 No children |
H13545 |
In calls to sqlite3_bind_blob(S,N,V,L,D),
sqlite3_bind_text(S,N,V,L,D), or
sqlite3_bind_text16(S,N,V,L,D) when D is a pointer to
a function, SQLite invokes that function to destroy the
value V after it has finished using the value V.
Parents: S70300 No children |
H13548 |
In calls to sqlite3_bind_zeroblob(S,N,V,L) the value bound
is a BLOB of L bytes, or a zero-length BLOB if L is negative.
Parents: S70300 No children |
H13551 |
In calls to sqlite3_bind_value(S,N,V) the V argument may
be either a protected sqlite3_value object or an
unprotected sqlite3_value object.
Parents: S70300 No children |
H13600 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_bind_parameter_count(sqlite3_stmt*); Parents: S70300 No children |
H13601 |
The sqlite3_bind_parameter_count(S) interface returns
the largest index of all SQL parameters in the
prepared statement S, or 0 if S contains no SQL parameters.
Parents: S70300 No children |
H13620 |
The sqlite3.h header file shall define the
the following interfaces:
const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); Parents: S70300 No children |
H13621 |
The sqlite3_bind_parameter_name(S,N) interface returns
a UTF-8 rendering of the name of the SQL parameter in
the prepared statement S having index N, or
NULL if there is no SQL parameter with index N or if the
parameter with index N is an anonymous parameter "?".
Parents: S70300 No children |
H13640 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); Parents: S70300 No children |
H13641 |
The sqlite3_bind_parameter_index(S,N) interface returns
the index of SQL parameter in the prepared statement
S whose name matches the UTF-8 string N, or 0 if there is
no match.
Parents: S70300 No children |
H13660 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_clear_bindings(sqlite3_stmt*); Parents: S70300 No children |
H13661 |
The sqlite3_clear_bindings(S) interface resets all SQL
parameter bindings in the prepared statement S back to NULL.
Parents: S70300 No children |
H13710 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_column_count(sqlite3_stmt *pStmt); Parents: S10700 No children |
H13711 |
The sqlite3_column_count(S) interface returns the number of
columns in the result set generated by the prepared statement S,
or 0 if S does not generate a result set.
Parents: S10700 No children |
H13720 |
The sqlite3.h header file shall define the
the following interfaces:
const char *sqlite3_column_name(sqlite3_stmt*, int N); const void *sqlite3_column_name16(sqlite3_stmt*, int N); Parents: S10700 No children |
H13721 |
A successful invocation of the sqlite3_column_name(S,N)
interface returns the name of the Nth column (where 0 is
the leftmost column) for the result set of the
prepared statement S as a zero-terminated UTF-8 string.
Parents: S10700 No children |
H13723 |
A successful invocation of the sqlite3_column_name16(S,N)
interface returns the name of the Nth column (where 0 is
the leftmost column) for the result set of the
prepared statement S as a zero-terminated UTF-16 string
in the native byte order.
Parents: S10700 No children |
H13724 |
The sqlite3_column_name() and sqlite3_column_name16()
interfaces return a NULL pointer if they are unable to
allocate memory to hold their normal return strings.
Parents: S10700 No children |
H13725 |
If the N parameter to sqlite3_column_name(S,N) or
sqlite3_column_name16(S,N) is out of range, then the
interfaces return a NULL pointer.
Parents: S10700 No children |
H13726 |
The strings returned by sqlite3_column_name(S,N) and
sqlite3_column_name16(S,N) are valid until the next
call to either routine with the same S and N parameters
or until sqlite3_finalize(S) is called.
Parents: S10700 No children |
H13727 |
When a result column of a SELECT statement contains
an AS clause, the name of that column is the identifier
to the right of the AS keyword.
Parents: S10700 No children |
H13740 |
The sqlite3.h header file shall define the
the following interfaces:
const char *sqlite3_column_database_name(sqlite3_stmt*,int); const void *sqlite3_column_database_name16(sqlite3_stmt*,int); const char *sqlite3_column_table_name(sqlite3_stmt*,int); const void *sqlite3_column_table_name16(sqlite3_stmt*,int); const char *sqlite3_column_origin_name(sqlite3_stmt*,int); const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); Parents: S10700 No children |
H13741 |
The sqlite3_column_database_name(S,N) interface returns either
the UTF-8 zero-terminated name of the database from which the
Nth result column of the prepared statement S is extracted,
or NULL if the Nth column of S is a general expression
or if unable to allocate memory to store the name.
Parents: S10700 No children |
H13742 |
The sqlite3_column_database_name16(S,N) interface returns either
the UTF-16 native byte order zero-terminated name of the database
from which the Nth result column of the prepared statement S is
extracted, or NULL if the Nth column of S is a general expression
or if unable to allocate memory to store the name.
Parents: S10700 No children |
H13743 |
The sqlite3_column_table_name(S,N) interface returns either
the UTF-8 zero-terminated name of the table from which the
Nth result column of the prepared statement S is extracted,
or NULL if the Nth column of S is a general expression
or if unable to allocate memory to store the name.
Parents: S10700 No children |
H13744 |
The sqlite3_column_table_name16(S,N) interface returns either
the UTF-16 native byte order zero-terminated name of the table
from which the Nth result column of the prepared statement S is
extracted, or NULL if the Nth column of S is a general expression
or if unable to allocate memory to store the name.
Parents: S10700 No children |
H13745 |
The sqlite3_column_origin_name(S,N) interface returns either
the UTF-8 zero-terminated name of the table column from which the
Nth result column of the prepared statement S is extracted,
or NULL if the Nth column of S is a general expression
or if unable to allocate memory to store the name.
Parents: S10700 No children |
H13746 |
The sqlite3_column_origin_name16(S,N) interface returns either
the UTF-16 native byte order zero-terminated name of the table
column from which the Nth result column of the
prepared statement S is extracted, or NULL if the Nth column
of S is a general expression or if unable to allocate memory
to store the name.
Parents: S10700 No children |
H13748 |
The return values from
column metadata interfaces
are valid for the lifetime of the prepared statement
or until the encoding is changed by another metadata
interface call for the same prepared statement and column.
Parents: S10700 No children |
H13760 |
The sqlite3.h header file shall define the
the following interfaces:
const char *sqlite3_column_decltype(sqlite3_stmt*,int); const void *sqlite3_column_decltype16(sqlite3_stmt*,int); Parents: S10700 No children |
H13761 |
A successful call to sqlite3_column_decltype(S,N) returns a
zero-terminated UTF-8 string containing the declared datatype
of the table column that appears as the Nth column (numbered
from 0) of the result set to the prepared statement S.
Parents: S10700 No children |
H13762 |
A successful call to sqlite3_column_decltype16(S,N)
returns a zero-terminated UTF-16 native byte order string
containing the declared datatype of the table column that appears
as the Nth column (numbered from 0) of the result set to the
prepared statement S.
Parents: S10700 No children |
H13763 |
If N is less than 0 or N is greater than or equal to
the number of columns in the prepared statement S,
or if the Nth column of S is an expression or subquery rather
than a table column, or if a memory allocation failure
occurs during encoding conversions, then
calls to sqlite3_column_decltype(S,N) or
sqlite3_column_decltype16(S,N) return NULL.
Parents: S10700 No children |
H13770 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_data_count(sqlite3_stmt *pStmt); Parents: S10700 No children |
H13771 |
After a call to sqlite3_step(S) that returns SQLITE_ROW,
the sqlite3_data_count(S) routine will return the same value
as the sqlite3_column_count(S) function.
Parents: S10700 No children |
H13772 |
After sqlite3_step(S) has returned any value other than
SQLITE_ROW or before sqlite3_step(S) has been called on the
prepared statement for the first time since it was
prepared or reset,
the sqlite3_data_count(S) routine returns zero.
Parents: S10700 No children |
H13800 |
The sqlite3.h header file shall define the
the following interfaces:
const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); int sqlite3_column_bytes(sqlite3_stmt*, int iCol); int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); double sqlite3_column_double(sqlite3_stmt*, int iCol); int sqlite3_column_int(sqlite3_stmt*, int iCol); sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); int sqlite3_column_type(sqlite3_stmt*, int iCol); sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); Parents: S10700 No children |
H13803 |
The sqlite3_column_blob(S,N) interface converts the
Nth column in the current row of the result set for
the prepared statement S into a BLOB and then returns a
pointer to the converted value.
Parents: S10700 No children |
H13806 |
The sqlite3_column_bytes(S,N) interface returns the
number of bytes in the BLOB or string (exclusive of the
zero terminator on the string) that was returned by the
most recent call to sqlite3_column_blob(S,N) or
sqlite3_column_text(S,N).
Parents: S10700 No children |
H13809 |
The sqlite3_column_bytes16(S,N) interface returns the
number of bytes in the string (exclusive of the
zero terminator on the string) that was returned by the
most recent call to sqlite3_column_text16(S,N).
Parents: S10700 No children |
H13812 |
The sqlite3_column_double(S,N) interface converts the
Nth column in the current row of the result set for the
prepared statement S into a floating point value and
returns a copy of that value.
Parents: S10700 No children |
H13815 |
The sqlite3_column_int(S,N) interface converts the
Nth column in the current row of the result set for the
prepared statement S into a 64-bit signed integer and
returns the lower 32 bits of that integer.
Parents: S10700 No children |
H13818 |
The sqlite3_column_int64(S,N) interface converts the
Nth column in the current row of the result set for the
prepared statement S into a 64-bit signed integer and
returns a copy of that integer.
Parents: S10700 No children |
H13821 |
The sqlite3_column_text(S,N) interface converts the
Nth column in the current row of the result set for
the prepared statement S into a zero-terminated UTF-8
string and returns a pointer to that string.
Parents: S10700 No children |
H13824 |
The sqlite3_column_text16(S,N) interface converts the
Nth column in the current row of the result set for the
prepared statement S into a zero-terminated 2-byte
aligned UTF-16 native byte order string and returns
a pointer to that string.
Parents: S10700 No children |
H13827 |
The sqlite3_column_type(S,N) interface returns
one of SQLITE_NULL, SQLITE_INTEGER, SQLITE_FLOAT,
SQLITE_TEXT, or SQLITE_BLOB as appropriate for
the Nth column in the current row of the result set for
the prepared statement S.
Parents: S10700 No children |
H13830 |
The sqlite3_column_value(S,N) interface returns a
pointer to an unprotected sqlite3_value object for the
Nth column in the current row of the result set for
the prepared statement S.
Parents: S10700 No children |
H14100 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_config(int, ...); No children |
H14103 |
A successful invocation of sqlite3_config() shall return
SQLITE_OK.
Parents: S20000 No children |
H14106 |
The sqlite3_config() interface shall return SQLITE_MISUSE
if it is invoked in between calls to sqlite3_initialize() and
sqlite3_shutdown().
Parents: S20000 No children |
H14120 |
A successful call to sqlite3_config(SQLITE_CONFIG_SINGLETHREAD)
shall set the default threading mode to Single-thread.
Parents: S20000 No children |
H14123 |
A successful call to sqlite3_config(SQLITE_CONFIG_MULTITHREAD)
shall set the default threading mode to Multi-thread.
Parents: S20000 No children |
H14126 |
A successful call to sqlite3_config(SQLITE_CONFIG_SERIALIZED)
shall set the default threading mode to Serialized.
Parents: S20000 No children |
H14129 |
A successful call to sqlite3_config(SQLITE_CONFIG_MUTEX,X)
where X is a pointer to an initialized sqlite3_mutex_methods
object shall cause all subsequent mutex operations performed
by SQLite to use the mutex methods that were present in X
during the call to sqlite3_config().
Parents: S20000 No children |
H14132 |
A successful call to sqlite3_config(SQLITE_CONFIG_GETMUTEX,X)
where X is a pointer to an sqlite3_mutex_methods object
shall overwrite the content of sqlite3_mutex_methods object
with the mutex methods currently in use by SQLite.
Parents: S20000 No children |
H14135 |
A successful call to sqlite3_config(SQLITE_CONFIG_MALLOC,M)
where M is a pointer to an initialized sqlite3_mem_methods
object shall cause all subsequent memory allocation operations
performed by SQLite to use the methods that were present in
M during the call to sqlite3_config().
Parents: S20000 No children |
H14138 |
A successful call to sqlite3_config(SQLITE_CONFIG_GETMALLOC,M)
where M is a pointer to an sqlite3_mem_methods object shall
overwrite the content of sqlite3_mem_methods object with
the memory allocation methods currently in use by
SQLite.
Parents: S20000 No children |
H14141 |
A successful call to sqlite3_config(SQLITE_CONFIG_MEMSTATUS,1)
shall enable the memory allocation status collection logic.
Parents: S20000 No children |
H14144 |
A successful call to sqlite3_config(SQLITE_CONFIG_MEMSTATUS,0)
shall disable the memory allocation status collection logic.
Parents: S20000 No children |
H14147 |
The memory allocation status collection logic shall be
enabled by default.
Parents: S20000 No children |
H14150 |
A successful call to sqlite3_config(SQLITE_CONFIG_SCRATCH,S,Z,N)
where Z and N are non-negative integers and
S is a pointer to an aligned memory buffer not less than
Z*N bytes in size shall cause S to be used by the
scratch memory allocator for as many as N simulataneous
allocations each of size Z.
Parents: S20000 No children |
H14153 |
A successful call to sqlite3_config(SQLITE_CONFIG_SCRATCH,S,Z,N)
where S is a NULL pointer shall disable the
scratch memory allocator.
Parents: S20000 No children |
H14156 |
A successful call to
sqlite3_config(SQLITE_CONFIG_PAGECACHE,S,Z,N)
where Z and N are non-negative integers and
S is a pointer to an aligned memory buffer not less than
Z*N bytes in size shall cause S to be used by the
pagecache memory allocator for as many as N simulataneous
allocations each of size Z.
Parents: S20000 No children |
H14159 |
A successful call to
sqlite3_config(SQLITE_CONFIG_PAGECACHE,S,Z,N)
where S is a NULL pointer shall disable the
pagecache memory allocator.
Parents: S20000 No children |
H14162 |
A successful call to sqlite3_config(SQLITE_CONFIG_HEAP,H,Z,N)
where Z and N are non-negative integers and
H is a pointer to an aligned memory buffer not less than
Z bytes in size shall enable the memsys5 memory allocator
and cause it to use buffer S as its memory source and to use
a minimum allocation size of N.
Parents: S20000 No children |
H14165 |
A successful call to sqlite3_config(SQLITE_CONFIG_HEAP,H,Z,N)
where H is a NULL pointer shall disable the
memsys5 memory allocator.
Parents: S20000 No children |
H14168 |
A successful call to sqlite3_config(SQLITE_CONFIG_LOOKASIDE,Z,N)
shall cause the default lookaside memory allocator configuration
for new database connections to be N slots of Z bytes each.
Parents: S20000 No children |
H14200 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_db_config(sqlite3*, int op, ...); Parents: S20000 No children |
H14203 |
A call to sqlite3_db_config(D,V,...) shall return SQLITE_OK
if and only if the call is successful.
Parents: S20000 No children |
H14206 |
If one or more slots of the lookaside memory allocator for
database connection D are in use, then a call to
sqlite3_db_config(D,SQLITE_DBCONFIG_LOOKASIDE,...) shall
fail with an SQLITE_BUSY return code.
Parents: S20000 No children |
H14209 |
A successful call to
sqlite3_db_config(D,SQLITE_DBCONFIG_LOOKASIDE,B,Z,N) where
D is an open database connection and Z and N are positive
integers and B is an aligned buffer at least Z*N bytes in size
shall cause the lookaside memory allocator for D to use buffer B
with N slots of Z bytes each.
Parents: S20000 No children |
H14212 |
A successful call to
sqlite3_db_config(D,SQLITE_DBCONFIG_LOOKASIDE,B,Z,N) where
D is an open database connection and Z and N are positive
integers and B is NULL pointer shall cause the
lookaside memory allocator for D to a obtain Z*N byte buffer
from the primary memory allocator and use that buffer
with N lookaside slots of Z bytes each.
Parents: S20000 No children |
H14215 |
A successful call to
sqlite3_db_config(D,SQLITE_DBCONFIG_LOOKASIDE,B,Z,N) where
D is an open database connection and Z and N are zero shall
disable the lookaside memory allocator for D.
Parents: S20000 No children |
H15000 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct Mem sqlite3_value; Parents: S20200 No children |
H15100 |
The sqlite3.h header file shall define the
the following interfaces:
const void *sqlite3_value_blob(sqlite3_value*); int sqlite3_value_bytes(sqlite3_value*); int sqlite3_value_bytes16(sqlite3_value*); double sqlite3_value_double(sqlite3_value*); int sqlite3_value_int(sqlite3_value*); sqlite3_int64 sqlite3_value_int64(sqlite3_value*); const unsigned char *sqlite3_value_text(sqlite3_value*); const void *sqlite3_value_text16(sqlite3_value*); const void *sqlite3_value_text16le(sqlite3_value*); const void *sqlite3_value_text16be(sqlite3_value*); int sqlite3_value_type(sqlite3_value*); int sqlite3_value_numeric_type(sqlite3_value*); Parents: S20200 No children |
H15103 |
The sqlite3_value_blob(V) interface converts the
protected sqlite3_value object V into a BLOB and then
returns a pointer to the converted value.
Parents: S20200 No children |
H15106 |
The sqlite3_value_bytes(V) interface returns the
number of bytes in the BLOB or string (exclusive of the
zero terminator on the string) that was returned by the
most recent call to sqlite3_value_blob(V) or
sqlite3_value_text(V).
Parents: S20200 No children |
H15109 |
The sqlite3_value_bytes16(V) interface returns the
number of bytes in the string (exclusive of the
zero terminator on the string) that was returned by the
most recent call to sqlite3_value_text16(V),
sqlite3_value_text16be(V), or sqlite3_value_text16le(V).
Parents: S20200 No children |
H15112 |
The sqlite3_value_double(V) interface converts the
protected sqlite3_value object V into a floating point value and
returns a copy of that value.
Parents: S20200 No children |
H15115 |
The sqlite3_value_int(V) interface converts the
protected sqlite3_value object V into a 64-bit signed integer and
returns the lower 32 bits of that integer.
Parents: S20200 No children |
H15118 |
The sqlite3_value_int64(V) interface converts the
protected sqlite3_value object V into a 64-bit signed integer and
returns a copy of that integer.
Parents: S20200 No children |
H15121 |
The sqlite3_value_text(V) interface converts the
protected sqlite3_value object V into a zero-terminated UTF-8
string and returns a pointer to that string.
Parents: S20200 No children |
H15124 |
The sqlite3_value_text16(V) interface converts the
protected sqlite3_value object V into a zero-terminated 2-byte
aligned UTF-16 native byte order
string and returns a pointer to that string.
Parents: S20200 No children |
H15127 |
The sqlite3_value_text16be(V) interface converts the
protected sqlite3_value object V into a zero-terminated 2-byte
aligned UTF-16 big-endian
string and returns a pointer to that string.
Parents: S20200 No children |
H15130 |
The sqlite3_value_text16le(V) interface converts the
protected sqlite3_value object V into a zero-terminated 2-byte
aligned UTF-16 little-endian
string and returns a pointer to that string.
Parents: S20200 No children |
H15133 |
The sqlite3_value_type(V) interface returns
one of SQLITE_NULL, SQLITE_INTEGER, SQLITE_FLOAT,
SQLITE_TEXT, or SQLITE_BLOB as appropriate for
the sqlite3_value object V.
Parents: S20200 No children |
H15136 |
The sqlite3_value_numeric_type(V) interface converts
the protected sqlite3_value object V into either an integer or
a floating point value if it can do so without loss of
information, and returns one of SQLITE_NULL,
SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, or
SQLITE_BLOB as appropriate for the
protected sqlite3_value object V after the conversion attempt.
Parents: S20200 No children |
H15304 |
When a call to sqlite3_step(S) causes the prepared statement
S to run to completion, the function returns SQLITE_DONE.
Parents: S10000 No children |
H15306 |
When a call to sqlite3_step(S) stops because it is ready to
return another row of the result set, it returns SQLITE_ROW.
Parents: S10000 No children |
H15308 |
If a call to sqlite3_step(S) encounters an
interrupt or a run-time error,
it returns an appropriate error code that is not one of
SQLITE_OK, SQLITE_ROW, or SQLITE_DONE.
Parents: S10000 No children |
H15310 |
If an interrupt or a run-time error
occurs during a call to sqlite3_step(S)
for a prepared statement S created using
legacy interfaces sqlite3_prepare() or
sqlite3_prepare16(), then the function returns either
SQLITE_ERROR, SQLITE_BUSY, or SQLITE_MISUSE.
Parents: S10000 No children |
H16001 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_context sqlite3_context; Parents: S20200 No children |
H16100 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_create_function( sqlite3 *db, const char *zFunctionName, int nArg, int eTextRep, void *pApp, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ); int sqlite3_create_function16( sqlite3 *db, const void *zFunctionName, int nArg, int eTextRep, void *pApp, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ); Parents: S20200 Children: H10267 |
H16103 |
The sqlite3_create_function16(D,X,...) interface shall behave
as sqlite3_create_function(D,X,...) in every way except that it
interprets the X argument as zero-terminated UTF-16
native byte order instead of as zero-terminated UTF-8.
Parents: S20200 No children |
H16106 |
A successful invocation of the
sqlite3_create_function(D,X,N,E,...) interface shall register
or replaces callback functions in the database connection D
used to implement the SQL function named X with N parameters
and having a preferred text encoding of E.
Parents: S20200 No children |
H16109 |
A successful call to sqlite3_create_function(D,X,N,E,P,F,S,L)
shall replace the P, F, S, and L values from any prior calls with
the same D, X, N, and E values.
Parents: S20200 No children |
H16112 |
The sqlite3_create_function(D,X,...) interface shall fail
if the SQL function name X is
longer than 255 bytes exclusive of the zero terminator.
Parents: S20200 No children |
H16118 |
The sqlite3_create_function(D,X,N,E,P,F,S,L) interface
shall fail unless either F is NULL and S and L are non-NULL or
F is non-NULL and S and L are NULL.
Parents: S20200 No children |
H16121 |
The sqlite3_create_function(D,...) interface shall fails with an
error code of SQLITE_BUSY if there exist prepared statements
associated with the database connection D.
Parents: S20200 No children |
H16124 |
The sqlite3_create_function(D,X,N,...) interface shall fail with
an error code of SQLITE_ERROR if parameter N is less
than -1 or greater than 127.
Parents: S20200 No children |
H16127 |
When N is non-negative, the sqlite3_create_function(D,X,N,...)
interface shall register callbacks to be invoked for the
SQL function
named X when the number of arguments to the SQL function is
exactly N.
Parents: S20200 No children |
H16130 |
When N is -1, the sqlite3_create_function(D,X,N,...)
interface shall register callbacks to be invoked for the SQL
function named X with any number of arguments.
Parents: S20200 No children |
H16133 |
When calls to sqlite3_create_function(D,X,N,...)
specify multiple implementations of the same function X
and when one implementation has N>=0 and the other has N=(-1)
the implementation with a non-zero N shall be preferred.
Parents: S20200 No children |
H16136 |
When calls to sqlite3_create_function(D,X,N,E,...)
specify multiple implementations of the same function X with
the same number of arguments N but with different
encodings E, then the implementation where E matches the
database encoding shall preferred.
Parents: S20200 No children |
H16139 |
For an aggregate SQL function created using
sqlite3_create_function(D,X,N,E,P,0,S,L) the finalizer
function L shall always be invoked exactly once if the
step function S is called one or more times.
Parents: S20200 No children |
H16142 |
When SQLite invokes either the xFunc or xStep function of
an application-defined SQL function or aggregate created
by sqlite3_create_function() or sqlite3_create_function16(),
then the array of sqlite3_value objects passed as the
third parameter shall be protected sqlite3_value objects.
Parents: S20200 No children |
H16210 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); Parents: S20200 No children |
H16211 |
The first invocation of sqlite3_aggregate_context(C,N) for
a particular instance of an aggregate function (for a particular
context C) causes SQLite to allocate N bytes of memory,
zero that memory, and return a pointer to the allocated memory.
Parents: S20200 No children |
H16213 |
If a memory allocation error occurs during
sqlite3_aggregate_context(C,N) then the function returns 0.
Parents: S20200 No children |
H16215 |
Second and subsequent invocations of
sqlite3_aggregate_context(C,N) for the same context pointer C
ignore the N parameter and return a pointer to the same
block of memory returned by the first invocation.
Parents: S20200 No children |
H16217 |
The memory allocated by sqlite3_aggregate_context(C,N) is
automatically freed on the next call to sqlite3_reset()
or sqlite3_finalize() for the prepared statement containing
the aggregate function associated with context C.
Parents: S20200 No children |
H16240 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_user_data(sqlite3_context*); Parents: S20200 No children |
H16243 |
The sqlite3_user_data(C) interface returns a copy of the
P pointer from the sqlite3_create_function(D,X,N,E,P,F,S,L)
or sqlite3_create_function16(D,X,N,E,P,F,S,L) call that
registered the SQL function associated with sqlite3_context C.
Parents: S20200 No children |
H16250 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3 *sqlite3_context_db_handle(sqlite3_context*); No children |
H16253 |
The sqlite3_context_db_handle(C) interface returns a copy of the
D pointer from the sqlite3_create_function(D,X,N,E,P,F,S,L)
or sqlite3_create_function16(D,X,N,E,P,F,S,L) call that
registered the SQL function associated with sqlite3_context C.
Parents: S60600 No children |
H16270 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_get_auxdata(sqlite3_context*, int N); void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); Parents: S20200 No children |
H16272 |
The sqlite3_get_auxdata(C,N) interface returns a pointer
to metadata associated with the Nth parameter of the SQL function
whose context is C, or NULL if there is no metadata associated
with that parameter.
Parents: S20200 No children |
H16274 |
The sqlite3_set_auxdata(C,N,P,D) interface assigns a metadata
pointer P to the Nth parameter of the SQL function with context C.
Parents: S20200 No children |
H16276 |
SQLite will invoke the destructor D with a single argument
which is the metadata pointer P following a call to
sqlite3_set_auxdata(C,N,P,D) when SQLite ceases to hold
the metadata.
Parents: S20200 No children |
H16277 |
SQLite ceases to hold metadata for an SQL function parameter
when the value of that parameter changes.
Parents: S20200 No children |
H16278 |
When sqlite3_set_auxdata(C,N,P,D) is invoked, the destructor
is called for any prior metadata associated with the same function
context C and parameter N.
Parents: S20200 No children |
H16279 |
SQLite will call destructors for any metadata it is holding
in a particular prepared statement S when either
sqlite3_reset(S) or sqlite3_finalize(S) is called.
Parents: S20200 No children |
H16342 |
The sqlite3_release_memory(N) returns the number
of bytes actually freed, which might be more or less
than the amount requested.
Parents: S30220 No children |
H16351 |
The sqlite3_soft_heap_limit(N) interface places a soft limit
of N bytes on the amount of heap memory that may be allocated
using sqlite3_malloc() or sqlite3_realloc() at any point
in time.
Parents: S30220 No children |
H16352 |
If a call to sqlite3_malloc() or sqlite3_realloc() would
cause the total amount of allocated memory to exceed the
soft heap limit, then sqlite3_release_memory() is invoked
in an attempt to reduce the memory usage prior to proceeding
with the memory allocation attempt.
Parents: S30220 No children |
H16353 |
Calls to sqlite3_malloc() or sqlite3_realloc() that trigger
attempts to reduce memory usage through the soft heap limit
mechanism continue even if the attempt to reduce memory
usage is unsuccessful.
Parents: S30220 No children |
H16354 |
A negative or zero value for N in a call to
sqlite3_soft_heap_limit(N) means that there is no soft
heap limit and sqlite3_release_memory() will only be
called when memory is completely exhausted.
Parents: S30220 No children |
H16355 |
The default value for the soft heap limit is zero.
Parents: S30220 No children |
H16358 |
Each call to sqlite3_soft_heap_limit(N) overrides the
values set by all prior calls.
Parents: S30220 No children |
H16400 |
The sqlite3.h header file shall define the
the following interfaces:
void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); void sqlite3_result_double(sqlite3_context*, double); void sqlite3_result_error(sqlite3_context*, const char*, int); void sqlite3_result_error16(sqlite3_context*, const void*, int); void sqlite3_result_error_toobig(sqlite3_context*); void sqlite3_result_error_nomem(sqlite3_context*); void sqlite3_result_error_code(sqlite3_context*, int); void sqlite3_result_int(sqlite3_context*, int); void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); void sqlite3_result_null(sqlite3_context*); void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); void sqlite3_result_value(sqlite3_context*, sqlite3_value*); void sqlite3_result_zeroblob(sqlite3_context*, int n); Parents: S20200 No children |
H16403 |
The default return value from any SQL function is NULL.
Parents: S20200 No children |
H16406 |
The sqlite3_result_blob(C,V,N,D) interface changes the
return value of function C to be a BLOB that is N bytes
in length and with content pointed to by V.
Parents: S20200 No children |
H16409 |
The sqlite3_result_double(C,V) interface changes the
return value of function C to be the floating point value V.
Parents: S20200 No children |
H16412 |
The sqlite3_result_error(C,V,N) interface changes the return
value of function C to be an exception with error code
SQLITE_ERROR and a UTF-8 error message copied from V up to the
first zero byte or until N bytes are read if N is positive.
Parents: S20200 No children |
H16415 |
The sqlite3_result_error16(C,V,N) interface changes the return
value of function C to be an exception with error code
SQLITE_ERROR and a UTF-16 native byte order error message
copied from V up to the first zero terminator or until N bytes
are read if N is positive.
Parents: S20200 No children |
H16418 |
The sqlite3_result_error_toobig(C) interface changes the return
value of the function C to be an exception with error code
SQLITE_TOOBIG and an appropriate error message.
Parents: S20200 No children |
H16421 |
The sqlite3_result_error_nomem(C) interface changes the return
value of the function C to be an exception with error code
SQLITE_NOMEM and an appropriate error message.
Parents: S20200 No children |
H16424 |
The sqlite3_result_error_code(C,E) interface changes the return
value of the function C to be an exception with error code E.
The error message text is unchanged.
Parents: S20200 No children |
H16427 |
The sqlite3_result_int(C,V) interface changes the
return value of function C to be the 32-bit integer value V.
Parents: S20200 No children |
H16430 |
The sqlite3_result_int64(C,V) interface changes the
return value of function C to be the 64-bit integer value V.
Parents: S20200 No children |
H16433 |
The sqlite3_result_null(C) interface changes the
return value of function C to be NULL.
Parents: S20200 No children |
H16436 |
The sqlite3_result_text(C,V,N,D) interface changes the
return value of function C to be the UTF-8 string
V up to the first zero if N is negative
or the first N bytes of V if N is non-negative.
Parents: S20200 No children |
H16439 |
The sqlite3_result_text16(C,V,N,D) interface changes the
return value of function C to be the UTF-16 native byte order
string V up to the first zero if N is negative
or the first N bytes of V if N is non-negative.
Parents: S20200 No children |
H16442 |
The sqlite3_result_text16be(C,V,N,D) interface changes the
return value of function C to be the UTF-16 big-endian
string V up to the first zero if N is negative
or the first N bytes or V if N is non-negative.
Parents: S20200 No children |
H16445 |
The sqlite3_result_text16le(C,V,N,D) interface changes the
return value of function C to be the UTF-16 little-endian
string V up to the first zero if N is negative
or the first N bytes of V if N is non-negative.
Parents: S20200 No children |
H16448 |
The sqlite3_result_value(C,V) interface changes the
return value of function C to be the unprotected sqlite3_value
object V.
Parents: S20200 No children |
H16451 |
The sqlite3_result_zeroblob(C,N) interface changes the
return value of function C to be an N-byte BLOB of all zeros.
Parents: S20200 No children |
H16454 |
The sqlite3_result_error() and sqlite3_result_error16()
interfaces make a copy of their error message strings before
returning.
Parents: S20200 No children |
H16457 |
If the D destructor parameter to sqlite3_result_blob(C,V,N,D),
sqlite3_result_text(C,V,N,D), sqlite3_result_text16(C,V,N,D),
sqlite3_result_text16be(C,V,N,D), or
sqlite3_result_text16le(C,V,N,D) is the constant SQLITE_STATIC
then no destructor is ever called on the pointer V and SQLite
assumes that V is immutable.
Parents: S20200 No children |
H16460 |
If the D destructor parameter to sqlite3_result_blob(C,V,N,D),
sqlite3_result_text(C,V,N,D), sqlite3_result_text16(C,V,N,D),
sqlite3_result_text16be(C,V,N,D), or
sqlite3_result_text16le(C,V,N,D) is the constant
SQLITE_TRANSIENT then the interfaces makes a copy of the
content of V and retains the copy.
Parents: S20200 No children |
H16463 |
If the D destructor parameter to sqlite3_result_blob(C,V,N,D),
sqlite3_result_text(C,V,N,D), sqlite3_result_text16(C,V,N,D),
sqlite3_result_text16be(C,V,N,D), or
sqlite3_result_text16le(C,V,N,D) is some value other than
the constants SQLITE_STATIC and SQLITE_TRANSIENT then
SQLite will invoke the destructor D with V as its only argument
when it has finished with the V value.
Parents: S20200 No children |
H16600 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_create_collation( sqlite3*, const char *zName, int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); int sqlite3_create_collation_v2( sqlite3*, const char *zName, int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*), void(*xDestroy)(void*) ); int sqlite3_create_collation16( sqlite3*, const void *zName, int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); Parents: S20300 No children |
H16603 |
A successful call to the
sqlite3_create_collation_v2(B,X,E,P,F,D) interface
registers function F as the comparison function used to
implement collation X on the database connection B for
databases having encoding E.
Parents: S20300 No children |
H16604 |
SQLite understands the X parameter to
sqlite3_create_collation_v2(B,X,E,P,F,D) as a zero-terminated
UTF-8 string in which case is ignored for ASCII characters and
is significant for non-ASCII characters.
Parents: S20300 No children |
H16606 |
Successive calls to sqlite3_create_collation_v2(B,X,E,P,F,D)
with the same values for B, X, and E, override prior values
of P, F, and D.
Parents: S20300 No children |
H16609 |
If the destructor D in sqlite3_create_collation_v2(B,X,E,P,F,D)
is not NULL then it is called with argument P when the
collating function is dropped by SQLite.
Parents: S20300 No children |
H16612 |
A collating function is dropped when it is overloaded.
Parents: S20300 No children |
H16615 |
A collating function is dropped when the database connection
is closed using sqlite3_close().
Parents: S20300 No children |
H16618 |
The pointer P in sqlite3_create_collation_v2(B,X,E,P,F,D)
is passed through as the first parameter to the comparison
function F for all subsequent invocations of F.
Parents: S20300 No children |
H16621 |
A call to sqlite3_create_collation(B,X,E,P,F) is exactly
the same as a call to sqlite3_create_collation_v2() with
the same parameters and a NULL destructor.
Parents: S20300 No children |
H16624 |
Following a sqlite3_create_collation_v2(B,X,E,P,F,D),
SQLite uses the comparison function F for all text comparison
operations on the database connection B on text values that
use the collating sequence named X.
Parents: S20300 No children |
H16627 |
The sqlite3_create_collation16(B,X,E,P,F) works the same
as sqlite3_create_collation(B,X,E,P,F) except that the
collation name X is understood as UTF-16 in native byte order
instead of UTF-8.
Parents: S20300 No children |
H16630 |
When multiple comparison functions are available for the same
collating sequence, SQLite chooses the one whose text encoding
requires the least amount of conversion from the default
text encoding of the database.
Parents: S20300 No children |
H16700 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_collation_needed( sqlite3*, void*, void(*)(void*,sqlite3*,int eTextRep,const char*) ); int sqlite3_collation_needed16( sqlite3*, void*, void(*)(void*,sqlite3*,int eTextRep,const void*) ); Parents: S20300 No children |
H16702 |
A successful call to sqlite3_collation_needed(D,P,F)
or sqlite3_collation_needed16(D,P,F) causes
the database connection D to invoke callback F with first
parameter P whenever it needs a comparison function for a
collating sequence that it does not know about.
Parents: S20300 No children |
H16704 |
Each successful call to sqlite3_collation_needed() or
sqlite3_collation_needed16() overrides the callback registered
on the same database connection by prior calls to either
interface.
Parents: S20300 No children |
H16706 |
The name of the requested collating function passed in the
4th parameter to the callback is in UTF-8 if the callback
was registered using sqlite3_collation_needed() and
is in UTF-16 native byte order if the callback was
registered using sqlite3_collation_needed16().
Parents: S20300 No children |
H17000 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3_mutex *sqlite3_mutex_alloc(int); void sqlite3_mutex_free(sqlite3_mutex*); void sqlite3_mutex_enter(sqlite3_mutex*); int sqlite3_mutex_try(sqlite3_mutex*); void sqlite3_mutex_leave(sqlite3_mutex*); Parents: S20000 |
H17001 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_MUTEX_FAST 0 #define SQLITE_MUTEX_RECURSIVE 1 #define SQLITE_MUTEX_STATIC_MASTER 2 #define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ #define SQLITE_MUTEX_STATIC_MEM2 4 /* sqlite3_release_memory() */ #define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ #define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ #define SQLITE_MUTEX_STATIC_LRU2 7 /* lru page list */ Parents: H17000 No children |
H17002 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3_mutex *sqlite3_db_mutex(sqlite3*); Parents: H17000 No children |
H17080 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_mutex_held(sqlite3_mutex*); int sqlite3_mutex_notheld(sqlite3_mutex*); No children |
H17110 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_mutex sqlite3_mutex; Parents: S20130 No children |
H17120 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; struct sqlite3_mutex_methods { int (*xMutexInit)(void); int (*xMutexEnd)(void); sqlite3_mutex *(*xMutexAlloc)(int); void (*xMutexFree)(sqlite3_mutex *); void (*xMutexEnter)(sqlite3_mutex *); int (*xMutexTry)(sqlite3_mutex *); void (*xMutexLeave)(sqlite3_mutex *); int (*xMutexHeld)(sqlite3_mutex *); int (*xMutexNotheld)(sqlite3_mutex *); }; Parents: S20130 No children |
H17200 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); Parents: S60200 Children: H17250 |
H17250 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_STATUS_MEMORY_USED 0 #define SQLITE_STATUS_PAGECACHE_USED 1 #define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 #define SQLITE_STATUS_SCRATCH_USED 3 #define SQLITE_STATUS_SCRATCH_OVERFLOW 4 #define SQLITE_STATUS_MALLOC_SIZE 5 #define SQLITE_STATUS_PARSER_STACK 6 #define SQLITE_STATUS_PAGECACHE_SIZE 7 #define SQLITE_STATUS_SCRATCH_SIZE 8 Parents: H17200 No children |
H17300 |
The sqlite3.h header file shall define the
the following interfaces:
void *sqlite3_malloc(int); void *sqlite3_realloc(void*, int); void sqlite3_free(void*); Parents: S20000 No children |
H17303 |
The sqlite3_malloc(N) interface returns either a pointer to
a newly checked-out block of at least N bytes of memory
that is 8-byte aligned, or it returns NULL if it is unable
to fulfill the request.
Parents: S20000 No children |
H17304 |
The sqlite3_malloc(N) interface returns a NULL pointer if
N is less than or equal to zero.
Parents: S20000 No children |
H17305 |
The sqlite3_free(P) interface releases memory previously
returned from sqlite3_malloc() or sqlite3_realloc(),
making it available for reuse.
Parents: S20000 No children |
H17306 |
A call to sqlite3_free(NULL) is a harmless no-op.
Parents: S20000 No children |
H17310 |
A call to sqlite3_realloc(0,N) is equivalent to a call
to sqlite3_malloc(N).
Parents: S20000 No children |
H17312 |
A call to sqlite3_realloc(P,0) is equivalent to a call
to sqlite3_free(P).
Parents: S20000 No children |
H17315 |
The SQLite core uses sqlite3_malloc(), sqlite3_realloc(),
and sqlite3_free() for all of its memory allocation and
deallocation needs.
Parents: S20000 No children |
H17318 |
The sqlite3_realloc(P,N) interface returns either a pointer
to a block of checked-out memory of at least N bytes in size
that is 8-byte aligned, or a NULL pointer.
Parents: S20000 No children |
H17321 |
When sqlite3_realloc(P,N) returns a non-NULL pointer, it first
copies the first K bytes of content from P into the newly
allocated block, where K is the lesser of N and the size of
the buffer P.
Parents: S20000 No children |
H17322 |
When sqlite3_realloc(P,N) returns a non-NULL pointer, it first
releases the buffer P.
Parents: S20000 No children |
H17323 |
When sqlite3_realloc(P,N) returns NULL, the buffer P is
not modified or released.
Parents: S20000 No children |
H17340 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_release_memory(int); Parents: S30220 No children |
H17341 |
The sqlite3_release_memory(N) interface attempts to
free N bytes of heap memory by deallocating non-essential
memory allocations held by the database library.
Parents: S30220 No children |
H17350 |
The sqlite3.h header file shall define the
the following interfaces:
void sqlite3_soft_heap_limit(int); Parents: S30220 No children |
H17370 |
The sqlite3.h header file shall define the
the following interfaces:
sqlite3_int64 sqlite3_memory_used(void); sqlite3_int64 sqlite3_memory_highwater(int resetFlag); Parents: S30210 No children |
H17371 |
The sqlite3_memory_used() routine returns the number of bytes
of memory currently outstanding (malloced but not freed).
Parents: S30210 No children |
H17373 |
The sqlite3_memory_highwater() routine returns the maximum
value of sqlite3_memory_used() since the high-water mark
was last reset.
Parents: S30210 No children |
H17374 |
The values returned by sqlite3_memory_used() and
sqlite3_memory_highwater() include any overhead
added by SQLite in its implementation of sqlite3_malloc(),
but not overhead added by the any underlying system library
routines that sqlite3_malloc() may call.
Parents: S30210 No children |
H17375 |
The memory high-water mark is reset to the current value of
sqlite3_memory_used() if and only if the parameter to
sqlite3_memory_highwater() is true. The value returned
by sqlite3_memory_highwater(1) is the high-water mark
prior to the reset.
Parents: S30210 No children |
H17390 |
The sqlite3.h header file shall define the
the following interfaces:
void sqlite3_randomness(int N, void *P); Parents: S20000 No children |
H17392 |
The sqlite3_randomness(N,P) interface writes N bytes of
high-quality pseudo-randomness into buffer P.
Parents: S20000 No children |
H17400 |
The sqlite3.h header file shall define the
the following interfaces:
char *sqlite3_mprintf(const char*,...); char *sqlite3_vmprintf(const char*, va_list); char *sqlite3_snprintf(int,char*,const char*, ...); No children |
H17403 |
The sqlite3_mprintf() and sqlite3_vmprintf() interfaces
return either pointers to zero-terminated UTF-8 strings held in
memory obtained from sqlite3_malloc() or NULL pointers if
a call to sqlite3_malloc() fails.
Parents: S70000 No children |
H17406 |
The sqlite3_snprintf() interface writes a zero-terminated
UTF-8 string into the buffer pointed to by the second parameter
provided that the first parameter is greater than zero.
Parents: S70000 No children |
H17407 |
The sqlite3_snprintf() interface does not write slots of
its output buffer (the second parameter) outside the range
of 0 through N-1 (where N is the first parameter)
regardless of the length of the string
requested by the format specification.
Parents: S70000 No children |
H17500 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); Parents: S60200 Children: H17520 |
H17520 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 Parents: H17500 No children |
H17550 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); Parents: S60200 Children: H17570 |
H17570 |
The sqlite3.h header file shall define the
the following interfaces:
#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 #define SQLITE_STMTSTATUS_SORT 2 Parents: H17550 No children |
H17800 |
The sqlite3.h header file shall define the
the following interfaces:
typedef struct sqlite3_blob sqlite3_blob; Parents: S30230 No children |
H17810 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_blob_open( sqlite3*, const char *zDb, const char *zTable, const char *zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob ); Parents: S30230 No children |
H17813 |
A successful invocation of the sqlite3_blob_open(D,B,T,C,R,F,P)
interface shall open an sqlite3_blob object P on the BLOB
in column C of the table T in the database B on
the database connection D.
Parents: S30230 No children |
H17814 |
A successful invocation of sqlite3_blob_open(D,...) shall start
a new transaction on the database connection D if that
connection is not already in a transaction.
Parents: S30230 No children |
H17816 |
The sqlite3_blob_open(D,B,T,C,R,F,P) interface shall open
the BLOB for read and write access if and only if the F
parameter is non-zero.
Parents: S30230 No children |
H17819 |
The sqlite3_blob_open() interface shall return SQLITE_OK on
success and an appropriate error code on failure.
Parents: S30230 No children |
H17821 |
If an error occurs during evaluation of sqlite3_blob_open(D,...)
then subsequent calls to sqlite3_errcode(D),
sqlite3_extended_errcode(),
sqlite3_errmsg(D), and sqlite3_errmsg16(D) shall return
information appropriate for that error.
Parents: S30230 No children |
H17824 |
If any column in the row that a sqlite3_blob has open is
changed by a separate UPDATE or DELETE statement or by
an ON CONFLICT side effect, then the sqlite3_blob shall
be marked as invalid.
Parents: S30230 No children |
H17830 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_blob_close(sqlite3_blob *); Parents: S30230 No children |
H17833 |
The sqlite3_blob_close(P) interface closes an sqlite3_blob
object P previously opened using sqlite3_blob_open().
Parents: S30230 No children |
H17836 |
Closing an sqlite3_blob object using
sqlite3_blob_close() shall cause the current transaction to
commit if there are no other open sqlite3_blob objects
or prepared statements on the same database connection and
the database connection is in autocommit mode.
Parents: S30230 No children |
H17839 |
The sqlite3_blob_close(P) interfaces shall close the
sqlite3_blob object P unconditionally, even if
sqlite3_blob_close(P) returns something other than SQLITE_OK.
Parents: S30230 No children |
H17840 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_blob_bytes(sqlite3_blob *); Parents: S30230 No children |
H17843 |
The sqlite3_blob_bytes(P) interface returns the size
in bytes of the BLOB that the sqlite3_blob object P
refers to.
Parents: S30230 No children |
H17850 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); Parents: S30230 No children |
H17853 |
A successful invocation of sqlite3_blob_read(P,Z,N,X)
shall reads N bytes of data out of the BLOB referenced by
BLOB handle P beginning at offset X and store those bytes
into buffer Z.
Parents: S30230 No children |
H17856 |
In sqlite3_blob_read(P,Z,N,X) if the size of the BLOB
is less than N+X bytes, then the function shall leave the
Z buffer unchanged and return SQLITE_ERROR.
Parents: S30230 No children |
H17859 |
In sqlite3_blob_read(P,Z,N,X) if X or N is less than zero
then the function shall leave the Z buffer unchanged
and return SQLITE_ERROR.
Parents: S30230 No children |
H17862 |
The sqlite3_blob_read(P,Z,N,X) interface shall return SQLITE_OK
if N bytes are successfully read into buffer Z.
Parents: S30230 No children |
H17863 |
If the BLOB handle P is expired and X and N are within bounds
then sqlite3_blob_read(P,Z,N,X) shall leave the Z buffer
unchanged and return SQLITE_ABORT.
Parents: S30230 No children |
H17865 |
If the requested read could not be completed,
the sqlite3_blob_read(P,Z,N,X) interface shall return an
appropriate error code or extended error code.
Parents: S30230 No children |
H17868 |
If an error occurs during evaluation of sqlite3_blob_read(P,...)
then subsequent calls to sqlite3_errcode(D),
sqlite3_extended_errcode(),
sqlite3_errmsg(D), and sqlite3_errmsg16(D) shall return
information appropriate for that error, where D is the
database connection that was used to open the BLOB handle P.
Parents: S30230 No children |
H17870 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); Parents: S30230 No children |
H17873 |
A successful invocation of sqlite3_blob_write(P,Z,N,X)
shall write N bytes of data from buffer Z into the BLOB
referenced by BLOB handle P beginning at offset X into
the BLOB.
Parents: S30230 No children |
H17874 |
In the absence of other overridding changes, the changes
written to a BLOB by sqlite3_blob_write() shall
remain in effect after the associated BLOB handle expires.
Parents: S30230 No children |
H17875 |
If the BLOB handle P was opened for reading only then
an invocation of sqlite3_blob_write(P,Z,N,X) shall leave
the referenced BLOB unchanged and return SQLITE_READONLY.
Parents: S30230 No children |
H17876 |
If the size of the BLOB referenced by BLOB handle P is
less than N+X bytes then sqlite3_blob_write(P,Z,N,X) shall
leave the BLOB unchanged and return SQLITE_ERROR.
Parents: S30230 No children |
H17877 |
If the BLOB handle P is expired and X and N are within bounds
then sqlite3_blob_read(P,Z,N,X) shall leave the BLOB
unchanged and return SQLITE_ABORT.
Parents: S30230 No children |
H17879 |
If X or N are less than zero then sqlite3_blob_write(P,Z,N,X)
shall leave the BLOB referenced by BLOB handle P unchanged
and return SQLITE_ERROR.
Parents: S30230 No children |
H17882 |
The sqlite3_blob_write(P,Z,N,X) interface shall return
SQLITE_OK if N bytes where successfully written into the BLOB.
Parents: S30230 No children |
H17885 |
If the requested write could not be completed,
the sqlite3_blob_write(P,Z,N,X) interface shall return an
appropriate error code or extended error code.
Parents: S30230 No children |
H17888 |
If an error occurs during evaluation of sqlite3_blob_write(D,...)
then subsequent calls to sqlite3_errcode(D),
sqlite3_extended_errcode(),
sqlite3_errmsg(D), and sqlite3_errmsg16(D) shall return
information appropriate for that error.
Parents: S30230 No children |
H18000 |
The sqlite3.h header file shall define the
the following interfaces:
struct sqlite3_module { int iVersion; int (*xCreate)(sqlite3*, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char**); int (*xConnect)(sqlite3*, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char**); int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); int (*xDisconnect)(sqlite3_vtab *pVTab); int (*xDestroy)(sqlite3_vtab *pVTab); int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); int (*xClose)(sqlite3_vtab_cursor*); int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, int argc, sqlite3_value **argv); int (*xNext)(sqlite3_vtab_cursor*); int (*xEof)(sqlite3_vtab_cursor*); int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); int (*xBegin)(sqlite3_vtab *pVTab); int (*xSync)(sqlite3_vtab *pVTab); int (*xCommit)(sqlite3_vtab *pVTab); int (*xRollback)(sqlite3_vtab *pVTab); int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), void **ppArg); int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); }; Parents: S20400 No children |
H18010 |
The sqlite3.h header file shall define the
the following interfaces:
struct sqlite3_vtab { const sqlite3_module *pModule; /* The module for this virtual table */ int nRef; /* Used internally */ char *zErrMsg; /* Error message from sqlite3_mprintf() */ /* Virtual table implementations will typically add additional fields */ }; Parents: S20400 No children |
H18020 |
The sqlite3.h header file shall define the
the following interfaces:
struct sqlite3_vtab_cursor { sqlite3_vtab *pVtab; /* Virtual table of this cursor */ /* Virtual table implementations will typically add additional fields */ }; Parents: S20400 No children |
H18100 |
The sqlite3.h header file shall define the
the following interfaces:
struct sqlite3_index_info { /* Inputs */ int nConstraint; /* Number of entries in aConstraint */ struct sqlite3_index_constraint { int iColumn; /* Column on left-hand side of constraint */ unsigned char op; /* Constraint operator */ unsigned char usable; /* True if this constraint is usable */ int iTermOffset; /* Used internally - xBestIndex should ignore */ } *aConstraint; /* Table of WHERE clause constraints */ int nOrderBy; /* Number of terms in the ORDER BY clause */ struct sqlite3_index_orderby { int iColumn; /* Column number */ unsigned char desc; /* True for DESC. False for ASC. */ } *aOrderBy; /* The ORDER BY clause */ /* Outputs */ struct sqlite3_index_constraint_usage { int argvIndex; /* if >0, constraint is part of argv to xFilter */ unsigned char omit; /* Do not code a test for this constraint */ } *aConstraintUsage; int idxNum; /* Number used to identify the index */ char *idxStr; /* String, possibly obtained from sqlite3_malloc */ int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ int orderByConsumed; /* True if output is already ordered */ double estimatedCost; /* Estimated cost of using this index */ }; #define SQLITE_INDEX_CONSTRAINT_EQ 2 #define SQLITE_INDEX_CONSTRAINT_GT 4 #define SQLITE_INDEX_CONSTRAINT_LE 8 #define SQLITE_INDEX_CONSTRAINT_LT 16 #define SQLITE_INDEX_CONSTRAINT_GE 32 #define SQLITE_INDEX_CONSTRAINT_MATCH 64 Parents: S20400 No children |
H18200 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_create_module( sqlite3 *db, /* SQLite connection to register module with */ const char *zName, /* Name of the module */ const sqlite3_module *, /* Methods for the module */ void * /* Client data for xCreate/xConnect */ ); Parents: S20400 No children |
H18210 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_create_module_v2( sqlite3 *db, /* SQLite connection to register module with */ const char *zName, /* Name of the module */ const sqlite3_module *, /* Methods for the module */ void *, /* Client data for xCreate/xConnect */ void(*xDestroy)(void*) /* Module destructor function */ ); Parents: S20400 No children |
H18280 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable); Parents: S20400 No children |
H18300 |
The sqlite3.h header file shall define the
the following interfaces:
int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); Parents: S20400 No children |
H30010 |
The system shall ensure that at the successful conclusion of a
database transaction the contents of the database file constitute
a well-formed SQLite database file.
No parents No children |
H30020 |
The system shall ensure that at the successful conclusion of a
database transaction the contents of the database file are a valid
serialization of the contents of the logical SQL database produced
by the transaction.
No parents No children |
H30030 |
The first 16 bytes of a well-formed database file contain the UTF-8
encoding of the string "SQLite format 3" followed by a single
nul-terminator byte.
No parents No children |
H30040 |
The 19th byte (byte offset 18), the file-format write version,
of a well-formed database file contains the value 0x01.
No parents No children |
H30050 |
The 20th byte (byte offset 19), the file-format read version,
of a well-formed database file contains the value 0x01.
No parents No children |
H30060 |
The 21st byte (byte offset 20), the number of unused bytes on each
page, of a well-formed database file shall contain the value 0x00.
No parents No children |
H30070 |
The 22nd byte (byte offset 21), the maximum fraction of an index
B-Tree page to use for embedded content, of a well-formed database
file shall contain the value 0x40.
No parents No children |
H30080 |
The 23rd byte (byte offset 22), the minimum fraction of an index
B-Tree page to use for embedded content when using overflow pages,
of a well-formed database file contains the value 0x20.
No parents No children |
H30090 |
The 24th byte (byte offset 23), the minimum fraction of a table
B-Tree page to use for embedded content when using overflow pages,
of a well-formed database file contains the value 0x20.
No parents No children |
H30100 |
The 4 byte block starting at byte offset 24 of a well-formed
database file contains the file change counter formatted
as a 4-byte big-endian integer.
No parents No children |
H30110 |
The 4 byte block starting at byte offset 40 of a well-formed
database file contains the schema version formatted
as a 4-byte big-endian integer.
No parents No children |
H30120 |
The 4 byte block starting at byte offset 44 of a well-formed
database file, the schema layer file format, contains a
big-endian integer value between 1 and 4, inclusive.
No parents No children |
H30130 |
The 4 byte block starting at byte offset 48 of a well-formed
database file contains the default pager cache size formatted
as a 4-byte big-endian integer.
No parents No children |
H30140 |
The 4 byte block starting at byte offset 52 of a well-formed
database file contains the auto-vacuum last root-page
formatted as a 4-byte big-endian integer. If this value is non-zero,
the database is said to be an auto-vacuum database.
No parents No children |
H30150 |
The 4 byte block starting at byte offset 56 of a well-formed
database file, the text encoding contains a big-endian integer
value between 1 and 3, inclusive.
No parents No children |
H30160 |
The 4 byte block starting at byte offset 60 of a well-formed
database file contains the user cookie formatted
as a 4-byte big-endian integer.
No parents No children |
H30170 |
The 4 byte block starting at byte offset 64 of a well-formed
database file, the incremental vaccum flag contains a big-endian
integer value between 0 and 1, inclusive.
No parents No children |
H30180 |
In a well-formed non-autovacuum database (one with a zero stored
in the 4-byte big-endian integer value beginning at byte offset
52 of the database file header, the incremental vacuum flag is
set to 0.
No parents No children |
H30190 |
The database page size of a well-formed database, stored as a
2-byte big-endian unsigned integer at byte offset 16 of the file,
shall be an integer power of 2 between 512 and 32768, inclusive.
No parents No children |
H30200 |
The size of a well formed database file shall be an integer
multiple of the database page size.
No parents No children |
H30210 |
Each page of a well formed database file is exactly one of a
B-Tree page, an overflow page, a free page, a
pointer-map page or the locking page.
No parents No children |
H30220 |
The database page that starts at byte offset 230, the
locking page, is never used for any purpose.
No parents No children |
H30230 |
In a well-formed database file, the portion of the first
database page not consumed by the database file-header (all but the
first 100 bytes) contains the root node of a table B-Tree,
the schema table.
No parents No children |
H30240 |
All records stored in the schema table contain exactly five
fields.
No parents No children |
H30250 |
For each SQL table in the database apart from itself
("sqlite_master"), the schema table of a well-formed
database file contains an associated record.
No parents No children |
H30260 |
The first field of each schema table record associated with an
SQL table shall be the text value "table".
No parents No children |
H30270 |
The second field of each schema table record associated with an
SQL table shall be a text value set to the name of the SQL table.
No parents No children |
H30280 |
In a well-formed database file, the third field of all
schema table records associated with SQL tables shall contain
the same value as the second field.
No parents No children |
H30290 |
In a well-formed database file, the fourth field of all
schema table records associated with SQL tables that are not
virtual tables contains the page number (an integer value) of the root
page of the associated table B-Tree structure within the
database file.
No parents No children |
H30300 |
If the associated database table is a virtual table, the fourth
field of the schema table record shall contain an SQL NULL
value.
No parents No children |
H30310 |
In a well-formed database, the fifth field of all schema table
records associated with SQL tables shall contain a "CREATE TABLE"
or "CREATE VIRTUAL TABLE" statment (a text value). The details
of the statement shall be such that executing the statement
would create a table of precisely the same name and schema as the
existing database table.
No parents No children |
H30320 |
For each PRIMARY KEY or UNIQUE constraint present in the definition
of each SQL table in the database, the schema table of a well-formed
database shall contain a record with the first field set to the text
value "index", and the second field set to a text value containing a
string of the form "sqlite_autoindex_<name>_<idx>", where
<name> is the name of the SQL table and <idx> is an
integer value.
No parents No children |
H30330 |
In a well-formed database, the third field of all schema table
records associated with SQL PRIMARY KEY or UNIQUE constraints shall
contain the name of the table to which the constraint applies (a
text value).
No parents No children |
H30340 |
In a well-formed database, the fourth field of all schema table
records associated with SQL PRIMARY KEY or UNIQUE constraints shall
contain the page number (an integer value) of the root page of the
associated index B-Tree structure.
No parents No children |
H30350 |
In a well-formed database, the fifth field of all schema table
records associated with SQL PRIMARY KEY or UNIQUE constraints shall
contain an SQL NULL value.
No parents No children |
H30360 |
For each SQL index in the database, the schema table of a well-formed
database shall contain a record with the first field set to the text
value "index" and the second field set to a text value containing the
name of the SQL index.
No parents No children |
H30370 |
In a well-formed database, the third field of all schema table
records associated with SQL indexes shall contain the name of the
SQL table that the index applies to.
No parents No children |
H30380 |
In a well-formed database, the fourth field of all schema table
records associated with SQL indexes shall contain the page number
(an integer value) of the root page of the associated index B-Tree
structure.
No parents No children |
H30390 |
In a well-formed database, the fifth field of all schema table
records associated with SQL indexes shall contain an SQL "CREATE
INDEX" statement (a text value). The details of the statement shall
be such that executing the statement would create an index of
precisely the same name and content as the existing database index.
No parents No children |
H30400 |
For each SQL view in the database, the schema table of a well-formed
database shall contain a record with the first field set to the text
value "view" and the second field set to a text value containing the
name of the SQL view.
No parents No children |
H30410 |
In a well-formed database, the third field of all schema table
records associated with SQL views shall contain the same value as
the second field.
No parents No children |
H30420 |
In a well-formed database, the third field of all schema table
records associated with SQL views shall contain the integer value 0.
No parents No children |
H30430 |
In a well-formed database, the fifth field of all schema table
records associated with SQL indexes shall contain an SQL "CREATE
VIEW" statement (a text value). The details of the statement shall
be such that executing the statement would create a view of
precisely the same name and definition as the existing database view.
No parents No children |
H30440 |
For each SQL trigger in the database, the schema table of a well-formed
database shall contain a record with the first field set to the text
value "trigger" and the second field set to a text value containing the
name of the SQL trigger.
No parents No children |
H30450 |
In a well-formed database, the third field of all schema table
records associated with SQL triggers shall contain the name of the
database table or view to which the trigger applies.
No parents No children |
H30460 |
In a well-formed database, the third field of all schema table
records associated with SQL triggers shall contain the integer value 0.
No parents No children |
H30470 |
In a well-formed database, the fifth field of all schema table
records associated with SQL indexes shall contain an SQL "CREATE
TRIGGER" statement (a text value). The details of the statement shall
be such that executing the statement would create a trigger of
precisely the same name and definition as the existing database trigger.
No parents No children |
H30480 |
In an auto-vacuum database, all pages that occur before the page
number stored in the auto-vacuum last root-page field
of the database file header (see H30140) must be either B-Tree root
pages, pointer-map pages or the locking page.
No parents No children |
H30490 |
In an auto-vacuum database, no B-Tree root pages may occur
on or after the page number stored in the auto-vacuum last root-page field
of the database file header (see H30140) must be either B-Tree root
pages, pointer-map pages or the locking page.
No parents No children |
H30500 |
As well as the schema table, a well-formed database file
contains N table B-Tree structures, where N is the
number of non-virtual tables in the logical database, excluding the
sqlite_master table but including sqlite_sequence and other system
tables.
No parents No children |
H30510 |
A well-formed database file contains N table B-Tree structures,
where N is the number of indexes in the logical database,
including indexes created by UNIQUE or PRIMARY KEY clauses in the
declaration of SQL tables.
No parents No children |
H30520 |
A 64-bit signed integer value stored in variable length integer
format consumes from 1 to 9 bytes of space.
No parents No children |
H30530 |
The most significant bit of all bytes except the last in a serialized
variable length integer is always set. Unless the serialized
form consumes the maximum 9 bytes available, then the most significant
bit of the final byte of the representation is always cleared.
No parents No children |
H30540 |
The eight least significant bytes of the 64-bit twos-compliment
representation of a value stored in a 9 byte variable length
integer are stored in the final byte (byte offset 8) of the
serialized variable length integer. The other 56 bits are
stored in the 7 least significant bits of each of the first 8 bytes
of the serialized variable length integer, in order from
most significant to least significant.
No parents No children |
H30550 |
A variable length integer that consumes less than 9 bytes of
space contains a value represented as an N-bit unsigned
integer, where N is equal to the number of bytes consumed by
the serial representation (between 1 and 8) multiplied by 7. The
N bits are stored in the 7 least significant bits of each
byte of the serial representation, from most to least significant.
No parents No children |
H30560 |
A database record consists of a database record header,
followed by database record data. The first part of the
database record header is a variable length integer
containing the total size (including itself) of the header in bytes.
No parents No children |
H30570 |
Following the length field, the remainder of the database record
header is populated with N variable length integer
fields, where N is the number of database values stored in
the record.
No parents No children |
H30580 |
Following the database record header, the database record
data is made up of N variable length blobs of data, where
N is again the number of database values stored in the record.
The n blob contains the data for the nth value in
the database record. The size and format of each blob of data is
encoded in the corresponding variable length integer field
in the database record header.
No parents No children |
H30590 |
A value of 0 stored within the database record header indicates
that the corresponding database value is an SQL NULL. In this case
the blob of data in the data area is 0 bytes in size.
No parents No children |
H30600 |
A value of 1 stored within the database record header indicates
that the corresponding database value is an SQL integer. In this case
the blob of data contains the integer value, formatted as a 1-byte
big-endian signed integer.
No parents No children |
H30610 |
A value of 2 stored within the database record header indicates
that the corresponding database value is an SQL integer. In this case
the blob of data contains the integer value, formatted as a 2-byte
big-endian signed integer.
No parents No children |
H30620 |
A value of 3 stored within the database record header indicates
that the corresponding database value is an SQL integer. In this case
the blob of data contains the integer value, formatted as a 3-byte
big-endian signed integer.
No parents No children |
H30630 |
A value of 4 stored within the database record header indicates
that the corresponding database value is an SQL integer. In this case
the blob of data contains the integer value, formatted as a 4-byte
big-endian signed integer.
No parents No children |
H30640 |
A value of 5 stored within the database record header indicates
that the corresponding database value is an SQL integer. In this case
the blob of data contains the integer value, formatted as a 6-byte
big-endian signed integer.
No parents No children |
H30650 |
A value of 6 stored within the database record header indicates
that the corresponding database value is an SQL integer. In this case
the blob of data contains the integer value, formatted as a 8-byte
big-endian signed integer.
No parents No children |
H30660 |
A value of 7 stored within the database record header indicates
that the corresponding database value is an SQL real (floating
point number). In this case the blob of data contains an 8-byte
IEEE floating point number, stored in big-endian byte order.
No parents No children |
H30670 |
A value of 8 stored within the database record header indicates
that the corresponding database value is an SQL integer, value 0.
In this case the blob of data in the data area is 0 bytes in size.
No parents No children |
H30680 |
A value of 9 stored within the database record header indicates
that the corresponding database value is an SQL integer, value 1.
In this case the blob of data in the data area is 0 bytes in size.
No parents No children |
H30690 |
An even value greater than or equal to 12 stored within the
database record header indicates that the corresponding
database value is an SQL blob field. The blob of data contains the
value data. The blob of data is exactly (n-12)/2 bytes
in size, where n is the integer value stored in the
database record header.
No parents No children |
H30700 |
An odd value greater than or equal to 13 stored within the
database record header indicates that the corresponding
database value is an SQL text field. The blob of data contains the
value text stored using the database encoding, with no
nul-terminator. The blob of data is exactly (n-12)/2 bytes
in size, where n is the integer value stored in the
database record header.
No parents No children |
H30710 |
In a well-formed database file, if the values 8 or 9 appear within
any database record header within the database, then the
schema-layer file format (stored at byte offset 44 of the
database file header) must be set to 4.
No parents No children |
H30720 |
In a well-formed database file, the values 10 and 11, and all
negative values may not appear within any database record header
in the database.
No parents No children |
H30730 |
The pages in an index B-Tree structures are arranged into a tree
structure such that all leaf pages are at the same depth.
No parents No children |
H30740 |
Each leaf node page in an index B-Tree contains one or more
B-Tree cells, where each cell contains a database record.
No parents No children |
H30750 |
Each internal node page in an index B-Tree contains one or more
B-Tree cells, where each cell contains a child page number, C,
and a database record R. All database records stored within
the sub-tree headed by page C are smaller than record R,
according to the index sort order (see below). Additionally, unless
R is the smallest database record stored on the internal node
page, all integer keys within the sub-tree headed by C are
greater than R-1, where R-1 is the
largest database record on the internal node page that is smaller
than R.
No parents No children |
H30760 |
As well as child page numbers associated with B-Tree cells, each
internal node page in an index B-Tree contains the page number
of an extra child page, the right-child page. All database
records stored in all B-Tree cells within the sub-tree headed by the
right-child page are greater than all database records
stored within B-Tree cells on the internal node page.
No parents No children |
H30770 |
In a well-formed database, each index B-Tree contains a single entry
for each row in the indexed logical database table.
No parents No children |
H30780 |
Each database record (key) stored by an index B-Tree in a
well-formed database contains the same number of values, the number
of indexed columns plus one.
No parents No children |
H30790 |
The final value in each database record (key) stored by an
index B-Tree in a well-formed database contains the rowid (an integer
value) of the corresponding logical database row.
No parents No children |
H30800 |
The first N values in each database record (key)
stored in an index B-Tree where N is the number of indexed
columns, contain the values of the indexed columns from the
corresponding logical database row, in the order specified for the
index.
No parents No children |
H30810 |
The b-tree page flags field (the first byte) of each database
page used as an internal node of an index B-Tree structure is set to
0x02.
No parents No children |
H30820 |
The b-tree page flags field (the first byte) of each database
page used as a leaf node of an index B-Tree structure is set to 0x0A.
No parents No children |
H30830 |
The first byte of each database page used as a B-Tree page contains
the b-tree page flags field. On page 1, the b-tree page
flags field is stored directly after the 100 byte file header
at byte offset 100.
No parents No children |
H30840 |
The number of B-Tree cells stored on a B-Tree page is stored as a
2-byte big-endian integer starting at byte offset 3 of the B-Tree
page. On page 1, this field is stored at byte offset 103.
No parents No children |
H30850 |
The 2-byte big-endian integer starting at byte offset 5 of each
B-Tree page contains the byte-offset from the start of the page
to the start of the cell content area, which consumes all space
from this offset to the end of the usable region of the page.
On page 1, this field is stored at byte offset 105. All B-Tree
cells on the page are stored within the cell-content area.
No parents No children |
H30860 |
On each page used as an internal node a of B-Tree structures, the
page number of the rightmost child node in the B-Tree structure is
stored as a 4-byte big-endian unsigned integer beginning at byte
offset 8 of the database page, or byte offset 108 on page 1.
No parents No children |
H30870 |
Immediately following the page header on each B-Tree page is the
cell offset array, consisting of N 2-byte big-endian
unsigned integers, where N is the number of cells stored
on the B-Tree page (H30840). On an internal node B-Tree page,
the cell offset array begins at byte offset 12, or on a leaf
page, byte offset 8. For the B-Tree node on page 1, these
offsets are 112 and 108, respectively.
No parents No children |
H30880 |
The cell offset array and the cell content area (H30850)
may not overlap.
No parents No children |
H30890 |
Each value stored in the cell offset array must be greater
than or equal to the offset to the cell content area (H30850),
and less than the database page size.
No parents No children |
H30900 |
The N values stored within the cell offset array are the
byte offsets from the start of the B-Tree page to the beginning of
each of the N cells stored on the page.
No parents No children |
H30910 |
No two B-Tree cells may overlap.
No parents No children |
H30920 |
Within the cell content area, all blocks of contiguous
free-space (space not used by B-Tree cells) greater than 3 bytes in
size are linked together into a linked list, the free block list.
Such blocks of free space are known as free blocks.
No parents No children |
H30930 |
The first two bytes of each free block contain the offset
of the next free block in the free block list formatted
as a 2-byte big-endian integer, relative to the start of the database
page. If there is no next free block, then the first two
bytes are set to 0x00.
No parents No children |
H30940 |
The second two bytes (byte offsets 2 and 3) of each free block
contain the total size of the free block, formatted as a 2-byte
big-endian integer.
No parents No children |
H30950 |
On all B-Tree pages, the offset of the first free block in the
free block list, relative to the start of the database page,
is stored as a 2-byte big-endian integer starting at byte offset
1 of the database page. If there is no first free block
(because the free block list is empty), then the two bytes
at offsets 1 and 2 of the database page are set to 0x00. On page 1,
this field is stored at byte offset 101 of the page.
No parents No children |
H30960 |
Within the cell-content area, all blocks of contiguous free-space
(space not used by B-Tree cells) less than or equal to 3 bytes in
size are known as fragments. The total size of all
fragments on a B-Tree page is stored as a 1-byte unsigned
integer at byte offset 7 of the database page. On page 1, this
field is stored at byte offset 107.
No parents No children |
H30970 |
Each B-Tree cell belonging to an internal node page of an index
B-Tree consists of a 4-byte big-endian unsigned integer, the
child page number, followed by a variable length integer
field, followed by a database record. The
variable length integer field contains the length of the
database record in bytes.
No parents No children |
H30980 |
Each B-Tree cell belonging to an leaf page of an index B-Tree
consists of a variable length integer field, followed by
a database record. The variable length integer field
contains the length of the database record in bytes.
No parents No children |
H30990 |
If the database record stored in an index B-Tree page is
sufficiently small, then the entire cell is stored within the
index B-Tree page. Sufficiently small is defined as equal to or
less than max-local, where:
max-local := (usable-size - 12) * 64 / 255 - 23
No parents No children |
H31000 |
If the database record stored as part of an index B-Tree cell is too
large to be stored entirely within the B-Tree page (as defined by
H30520), then only a prefix of the database record is stored
within the B-Tree page and the remainder stored in an overflow
chain. In this case, the database record prefix is immediately
followed by the page number of the first page of the
overflow chain, formatted as a 4-byte big-endian unsigned
integer.
No parents No children |
H31010 |
When a database record belonging to a table B-Tree cell is
stored partially within an overflow page chain, the size
of the prefix stored within the index B-Tree page is N bytes,
where N is calculated using the following algorithm:
min-local := (usable-size - 12) * 32 / 255 - 23
max-local := (usable-size - 12) * 64 / 255 - 23
N := min-local + ((record-size - min-local) % (usable-size - 4))
if( N > max-local ) N := min-local
No parents No children |
H31020 |
The pages in a table B-Tree structures are arranged into a tree
structure such that all leaf pages are at the same depth.
No parents No children |
H31030 |
Each leaf page in a table B-Tree structure contains one or more
B-Tree cells, where each cell contains a 64-bit signed integer key
value and a database record.
No parents No children |
H31040 |
Each internal node page in a table B-Tree structure contains one or
more B-Tree cells, where each cell contains a 64-bit signed integer
key value, K, and a child page number, C. All integer key
values in all B-Tree cells within the sub-tree headed by page C
are less than or equal to K. Additionally, unless K
is the smallest integer key value stored on the internal node page,
all integer keys within the sub-tree headed by C are greater
than K-1, where K-1 is the largest
integer key on the internal node page that is smaller than K.
No parents No children |
H31050 |
As well as child page numbers associated with B-Tree cells, each
internal node page in a table B-Tree contains the page number
of an extra child page, the right-child page. All key values
in all B-Tree cells within the sub-tree headed by the right-child
page are greater than all key values stored within B-Tree cells
on the internal node page.
No parents No children |
H31060 |
In a well-formed database, each table B-Tree contains a single entry
for each row in the corresponding logical database table.
No parents No children |
H31070 |
The key value (a 64-bit signed integer) for each B-Tree entry is
the same as the value of the rowid field of the corresponding
logical database row.
No parents No children |
H31080 |
The SQL values serialized to make up each database record
stored as ancillary data in a table B-Tree shall be the equal to the
values taken by the N leftmost columns of the corresponding
logical database row, where N is the number of values in the
database record.
No parents No children |
H31090 |
If a logical database table column is declared as an "INTEGER
PRIMARY KEY", then instead of its integer value, an SQL NULL
shall be stored in its place in any database records used as
ancillary data in a table B-Tree.
No parents No children |
H31100 |
If the database schema layer file-format (the value stored
as a 4-byte integer at byte offset 44 of the file header) is 1,
then all database records stored as ancillary data in a table
B-Tree structure have the same number of fields as there are
columns in the corresponding logical database table.
No parents No children |
H31110 |
If the database schema layer file-format value is two or
greater and the rightmost M columns of a row contain SQL NULL
values, then the corresponding record stored as ancillary data in
the table B-Tree has between N-M and N fields,
where N is the number of columns in the logical database
table.
No parents No children |
H31120 |
If the database schema layer file-format value is three or
greater and the rightmost M columns of a row contain their
default values according to the logical table declaration, then the
corresponding record stored as ancillary data in the table B-Tree
may have as few as N-M fields, where N is the
number of columns in the logical database table.
No parents No children |
H31130 |
In a well-formed database file, the first byte of each page used
as an internal node of a table B-Tree structure is set to 0x05.
No parents No children |
H31140 |
In a well-formed database file, the first byte of each page used
as a leaf node of a table B-Tree structure is set to 0x0D.
No parents No children |
H31150 |
B-Tree cells belonging to table B-Tree internal node pages consist
of exactly two fields, a 4-byte big-endian unsigned integer
immediately followed by a variable length integer. These
fields contain the child page number and key value respectively
(see H31030).
No parents No children |
H31160 |
B-Tree cells belonging to table B-Tree leaf node pages consist
of three fields, two variable length integer values
followed by a database record. The size of the database record
in bytes is stored in the first of the two
variable length integer fields. The second of the two
variable length integer fields contains the 64-bit signed
integer key (see H31030).
No parents No children |
H31170 |
If the size of the record stored in a table B-Tree leaf page cell
is less than or equal to (usable page size-35) bytes, then
the entire cell is stored on the B-Tree leaf page. In a well-formed
database, usable page size is the same as the database
page size.
No parents No children |
H31180 |
If a table B-Tree cell is too large to be stored entirely on
a leaf page (as defined by H31170), then a prefix of the cell
is stored on the leaf page, and the remainder stored in an
overflow page chain. In this case the cell prefix
stored on the B-Tree leaf page is immediately followed by a
4-byte big-endian unsigned integer containing the page number
of the first overflow page in the chain.
No parents No children |
H31190 |
When a table B-Tree cell is stored partially in an
overflow page chain, the prefix stored on the B-Tree
leaf page consists of the two variable length integer fields,
followed by the first N bytes of the database record, where
N is determined by the following algorithm:
min-local := (usable-size - 12) * 255 / 32 - 23
max-local := (usable-size - 35)
N := min-local + (record-size - min-local) % (usable-size - 4)
if( N > max-local ) N := min-local
No parents No children |
H31200 |
A single overflow page may store up to available-space
bytes of database record data, where available-space is equal
to (usable-size - 4).
No parents No children |
H31210 |
When a database record is too large to store within a B-Tree page
(see H31170 and H31000), a prefix of the record is stored within
the B-Tree page and the remainder stored across N overflow
pages. In this case N is the minimum number of pages required
to store the portion of the record not stored on the B-Tree page,
given the maximum payload per overflow page defined by H31200.
No parents No children |
H31220 |
The list of overflow pages used to store a single database record
are linked together in a singly linked list known as an
overflow chain. The first four bytes of each page except the
last in an overflow chain are used to store the page number
of the next page in the linked list, formatted as an unsigned
big-endian integer. The first four bytes of the last page in an
overflow chain are set to 0x00.
No parents No children |
H31230 |
Each overflow page except the last in an overflow chain
contains N bytes of record data starting at byte offset 4 of
the page, where N is the maximum payload per overflow page,
as defined by H31200. The final page in an overflow chain
contains the remaining data, also starting at byte offset 4.
No parents No children |
H31240 |
All free pages in a well-formed database file are part of
the database free page list.
No parents No children |
H31250 |
Each free page is either a free list trunk page or a
free list leaf page.
No parents No children |
H31260 |
All free list trunk pages are linked together into a singly
linked list. The first 4 bytes of each page in the linked list
contains the page number of the next page in the list, formatted
as an unsigned big-endian integer. The first 4 bytes of the last
page in the linked list are set to 0x00.
No parents No children |
H31270 |
The second 4 bytes of each free list trunk page contains
the number of free list leaf page numbers stored on the free list
trunk page, formatted as an unsigned big-endian integer.
No parents No children |
H31280 |
Beginning at byte offset 8 of each free list trunk page are
N page numbers, each formatted as a 4-byte unsigned big-endian
integers, where N is the value described in requirement H31270.
No parents No children |
H31290 |
All page numbers stored on all free list trunk pages refer to
database pages that are free list leaves.
No parents No children |
H31300 |
The page number of each free list leaf page in a well-formed
database file appears exactly once within the set of pages numbers
stored on free list trunk pages.
No parents No children |
H31310 |
The total number of pages in the free list, including all free list
trunk and free list leaf pages, is stored as a 4-byte unsigned
big-endian integer at offset 36 of the database file header.
No parents No children |
H31320 |
The page number of the first page in the linked list of free list
trunk pages is stored as a 4-byte big-endian unsigned integer at
offset 32 of the database file header. If there are no free list
trunk pages in the database file, then the value stored at
offset 32 of the database file header is 0.
No parents No children |
H31330 |
Non auto-vacuum databases do not contain pointer map pages.
No parents No children |
H31340 |
In an auto-vacuum database file, every (num-entries + 1)th
page beginning with page 2 is designated a pointer-map page, where
num-entries is calculated as:
num-entries := database-usable-page-size / 5
No parents No children |
H31350 |
In an auto-vacuum database file, each pointer-map page contains
a pointer map entry for each of the num-entries (defined by
H31340) pages that follow it, if they exist.
No parents No children |
H31360 |
Each pointer-map page entry consists of a 1-byte page type and a
4-byte page parent number, 5 bytes in total.
No parents No children |
H31370 |
Pointer-map entries are packed into the pointer-map page in order,
starting at offset 0. The entry associated with the database
page that immediately follows the pointer-map page is located at
offset 0. The entry for the following page at offset 5 etc.
No parents No children |
H31380 |
For each page except page 1 in an auto-vacuum database file that is
the root page of a B-Tree structure, the page type of the
corresponding pointer-map entry is set to the value 0x01 and the
parent page number is zero.
No parents No children |
H31390 |
For each page that is a part of an auto-vacuum database file free-list,
the page type of the corresponding pointer-map entry is set to the
value 0x02 and the parent page number is zero.
No parents No children |
H31400 |
For each page in a well-formed auto-vacuum database that is the first
page in an overflow chain, the page type of the corresponding
pointer-map entry is set to 0x03 and the parent page number field
is set to the page number of the B-Tree page that contains the start
of the B-Tree cell stored in the overflow-chain.
No parents No children |
H31410 |
For each page that is the second or a subsequent page in an overflow
chain, the page type of the corresponding pointer-map entry is set to
0x04 and the parent page number field is set to the page number of the
preceding page in the overflow chain.
No parents No children |
H31420 |
For each page that is not a root page but is a part of a B-Tree tree
structure (not part of an overflow chain), the page type of the
corresponding pointer-map entry is set to the value 0x05 and the parent
page number field is set to the page number of the parent node in the
B-Tree structure.
No parents No children |
H35010 |
Except for the read operation required by H35070 and those reads made
as part of opening a read-only transaction, SQLite shall ensure that
a database connection has an open read-only or read/write
transaction when any data is read from the database file.
No parents No children |
H35020 |
Aside from those read operations described by H35070 and H21XXX, SQLite
shall read data from the database file in aligned blocks of
page-size bytes, where page-size is the database page size
used by the database file.
No parents No children |
H35030 |
While opening a read-only transaction, after successfully
obtaining a shared lock on the database file, SQLite shall
attempt to detect and roll back a hot journal file associated
with the same database file.
No parents No children |
H35040 |
Assuming no errors have occured, then after attempting to detect and
roll back a hot journal file, if the page cache contains
any entries associated with the current database connection,
then SQLite shall validate the contents of the page cache by
testing the file change counter. This procedure is known as
cache validiation.
No parents No children |
H35050 |
If the cache validiate procedure prescribed by H35040 is required and
does not prove that the page cache entries associated with the
current database connection are valid, then SQLite shall discard
all entries associated with the current database connection from
the page cache.
No parents No children |
H35060 |
When a new database connection is required, SQLite shall attempt
to open a file-handle on the database file. If the attempt fails, then
no new database connection is created and an error returned.
No parents No children |
H35070 |
When a new database connection is required, after opening the
new file-handle, SQLite shall attempt to read the first 100 bytes
of the database file. If the attempt fails for any other reason than
that the opened file is less than 100 bytes in size, then
the file-handle is closed, no new database connection is created
and an error returned instead.
No parents No children |
H35080 |
If the database file header is successfully read from a newly
opened database file, the connections expected page-size shall
be set to the value stored in the page-size field of the
database header.
No parents No children |
H35090 |
If the database file header cannot be read from a newly opened
database file (because the file is less than 100 bytes in size), the
connections expected page-size shall be set to the compile time
value of the SQLITE_DEFAULT_PAGESIZE option.
No parents No children |
H35100 |
When required to open a read-only transaction using a
database connection, SQLite shall first attempt to obtain
a shared-lock on the file-handle open on the database file.
No parents No children |
H35110 |
If, while opening a read-only transaction, SQLite fails to obtain
the shared-lock on the database file, then the process is
abandoned, no transaction is opened and an error returned to the user.
No parents No children |
H35120 |
If, while opening a read-only transaction, SQLite encounters
an error while attempting to detect or roll back a hot journal
file, then the shared-lock on the database file is released,
no transaction is opened and an error returned to the user.
No parents No children |
H35130 |
When required to end a read-only transaction, SQLite shall
relinquish the shared lock held on the database file by
calling the xUnlock() method of the file-handle.
No parents No children |
H35140 |
When required to attempt to detect a hot-journal file, SQLite
shall first use the xAccess() method of the VFS layer to check if a
journal file exists in the file-system.
No parents No children |
H35150 |
When required to attempt to detect a hot-journal file, if the
call to xAccess() required by H35140 indicates that a journal file does
not exist, then SQLite shall conclude that there is no hot-journal
file in the file system and therefore that no hot journal
rollback is required.
No parents No children |
H35160 |
When required to attempt to detect a hot-journal file, if the
call to xAccess() required by H35140 indicates that a journal file
is present, then the xCheckReservedLock() method of the database file
file-handle is invoked to determine whether or not some other
process is holding a reserved or greater lock on the database
file.
No parents No children |
H35170 |
If the call to xCheckReservedLock() required by H35160 indicates that
some other database connection is holding a reserved
or greater lock on the database file, then SQLite shall conclude that
there is no hot journal file. In this case the attempt to detect
a hot journal file is concluded.
No parents No children |
H35180 |
When a file-handle open on a database file is unlocked, if the
page cache contains one or more entries belonging to the
associated database connection, SQLite shall store the value
of the file change counter internally.
No parents No children |
H35190 |
When required to perform cache validation as part of opening
a read transaction, SQLite shall read a 16 byte block
starting at byte offset 24 of the database file using the xRead()
method of the database connections file handle.
No parents No children |
H35200 |
While performing cache validation, after loading the 16 byte
block as required by H35190, SQLite shall compare the 32-bit big-endian
integer stored in the first 4 bytes of the block to the most
recently stored value of the file change counter (see H35180).
If the values are not the same, then SQLite shall conclude that
the contents of the cache are invalid.
No parents No children |
H35210 |
During the conclusion of a read transaction, before unlocking
the database file, SQLite shall set the connections
expected page size to the current database page-size.
No parents No children |
H35220 |
As part of opening a new read transaction, immediately after
performing cache validation, if there is no data for database
page 1 in the page cache, SQLite shall read N bytes from
the start of the database file using the xRead() method of the
connections file handle, where N is the connections current
expected page size value.
No parents No children |
H35230 |
If page 1 data is read as required by H35230, then the value of the
page-size field that appears in the database file header that
consumes the first 100 bytes of the read block is not the same as the
connections current expected page size, then the
expected page size is set to this value, the database file is
unlocked and the entire procedure to open a read transaction
is repeated.
No parents No children |
H35240 |
If page 1 data is read as required by H35230, then the value of the
page-size field that appears in the database file header that
consumes the first 100 bytes of the read block is the same as the
connections current expected page size, then the block of data
read is stored in the page cache as page 1.
No parents No children |
H35270 |
When required to journal a database page, SQLite shall first
append the page number of the page being journalled to the
journal file, formatted as a 4-byte big-endian unsigned integer,
using a single call to the xWrite method of the file-handle opened
on the journal file.
No parents No children |
H35280 |
When required to journal a database page, if the attempt to
append the page number to the journal file is successful,
then the current page data (page-size bytes) shall be appended
to the journal file, using a single call to the xWrite method of the
file-handle opened on the journal file.
No parents No children |
H35290 |
When required to journal a database page, if the attempt to
append the current page data to the journal file is successful,
then SQLite shall append a 4-byte big-endian integer checksum value
to the to the journal file, using a single call to the xWrite method
of the file-handle opened on the journal file.
No parents No children |
H35300 |
The checksum value written to the journal file by the write
required by H35290 shall be equal to the sum of the checksum
initializer field stored in the journal header (H35700) and
every 200th byte of the page data, beginning with the
(page-size % 200)th byte.
No parents No children |
H35350 |
When required to open a write transaction on the database,
SQLite shall first open a read transaction, if the database
connection in question has not already opened one.
No parents No children |
H35360 |
When required to open a write transaction on the database, after
ensuring a read transaction has already been opened, SQLite
shall obtain a reserved lock on the database file by calling
the xLock method of the file-handle open on the database file.
No parents No children |
H35370 |
When required to open a write transaction on the database, after
obtaining a reserved lock on the database file, SQLite shall
open a read/write file-handle on the corresponding journal file.
No parents No children |
H35380 |
When required to open a write transaction on the database, after
opening a file-handle on the journal file, SQLite shall append
a journal header to the (currently empty) journal file.
No parents No children |
H35400 |
When a database connection is closed, SQLite shall close the
associated file handle at the VFS level.
No parents No children |
H35420 |
SQLite shall ensure that a database connection has an open
read-only or read/write transaction before using data stored in the page
cache to satisfy user queries.
No parents No children |
H35430 |
When a database connection is closed, all associated page
cache entries shall be discarded.
No parents No children |
H35440 |
If while attempting to detect a hot-journal file the call to
xCheckReservedLock() indicates that no process holds a reserved
or greater lock on the database file, then SQLite shall open
a file handle on the potentially hot journal file using the VFS xOpen()
method.
No parents No children |
H35450 |
After successfully opening a file-handle on a potentially hot journal
file, SQLite shall query the file for its size in bytes using the
xFileSize() method of the open file handle.
No parents No children |
H35460 |
If the size of a potentially hot journal file is revealed to be zero
bytes by a query required by H35450, then SQLite shall close the
file handle opened on the journal file and delete the journal file using
a call to the VFS xDelete() method. In this case SQLite shall conclude
that there is no hot journal file.
No parents No children |
H35470 |
If the size of a potentially hot journal file is revealed to be greater
than zero bytes by a query required by H35450, then SQLite shall attempt
to upgrade the shared lock held by the database connection
on the database file directly to an exclusive lock.
No parents No children |
H35480 |
If an attempt to upgrade to an exclusive lock prescribed by
H35470 fails for any reason, then SQLite shall release all locks held by
the database connection and close the file handle opened on the
journal file. The attempt to open a read-only transaction
shall be deemed to have failed and an error returned to the user.
No parents No children |
H35490 |
If, as part of the hot journal file detection process, the
attempt to upgrade to an exclusive lock mandated by H35470 is
successful, then SQLite shall query the file-system using the xAccess()
method of the VFS implementation to test whether or not the journal
file is still present in the file-system.
No parents No children |
H35500 |
If the xAccess() query required by H35490 reveals that the journal
file is still present in the file system, then SQLite shall conclude
that the journal file is a hot journal file that needs to
be rolled back. SQLite shall immediately begin hot journal
rollback.
No parents No children |
H35510 |
If the call to xAccess() required by H35140 fails (due to an IO error or
similar), then SQLite shall abandon the attempt to open a read-only
transaction, relinquish the shared lock held on the database
file and return an error to the user.
No parents No children |
H35520 |
If the call to xCheckReservedLock() required by H35160 fails (due to an
IO or other internal VFS error), then SQLite shall abandon the attempt
to open a read-only transaction, relinquish the shared lock
held on the database file and return an error to the user.
No parents No children |
H35530 |
If the call to xOpen() required by H35440 fails (due to an IO or other
internal VFS error), then SQLite shall abandon the attempt to open a
read-only transaction, relinquish the shared lock held on
the database file and return an error to the user.
No parents No children |
H35540 |
If the call to xFileSize() required by H35450 fails (due to an IO or
other internal VFS error), then SQLite shall abandon the attempt to open
a read-only transaction, relinquish the shared lock held on
the database file, close the file handle opened on the journal file and
return an error to the user.
No parents No children |
H35550 |
If the call to xDelete() required by H35450 fails (due to an IO or
other internal VFS error), then SQLite shall abandon the attempt to open
a read-only transaction, relinquish the shared lock held on
the database file and return an error to the user.
No parents No children |
H35560 |
If the call to xAccess() required by H35490 fails (due to an IO or
other internal VFS error), then SQLite shall abandon the attempt to open
a read-only transaction, relinquish the lock held on the
database file, close the file handle opened on the journal file and
return an error to the user.
No parents No children |
H35570 |
If the call to xAccess() required by H35490 reveals that the journal
file is no longer present in the file system, then SQLite shall abandon
the attempt to open a read-only transaction, relinquish the
lock held on the database file, close the file handle opened on the
journal file and return an SQLITE_BUSY error to the user.
No parents No children |
H35580 |
If an attempt to acquire a reserved lock prescribed by
requirement H35360 fails, then SQLite shall deem the attempt to
open a write transaction to have failed and return an error
to the user.
No parents No children |
H35590 |
When required to modify the contents of an existing database page that
existed and was not a free-list leaf page when the write
transaction was opened, SQLite shall journal the page if it has not
already been journalled within the current write transaction.
No parents No children |
H35600 |
When required to modify the contents of an existing database page,
SQLite shall update the cached version of the database page content
stored as part of the page cache entry associated with the page.
No parents No children |
H35610 |
When required to append a new database page to the database file,
SQLite shall create a new page cache entry corresponding to
the new page and insert it into the page cache. The dirty
flag of the new page cache entry shall be set.
No parents No children |
H35620 |
When required to truncate (remove) a database page that existed and was
not a free-list leaf page when the write transaction was
opened from the end of a database file, SQLite shall journal the page if
it has not already been journalled within the current write
transaction.
No parents No children |
H35630 |
When required to truncate a database page from the end of the database
file, SQLite shall discard the associated page cache entry
from the page cache.
No parents No children |
H35640 |
When required to purge a non-writable dirty page from the
page cache, SQLite shall sync the journal file before
proceding with the write operation required by H35670.
No parents No children |
H35660 |
After syncing the journal file as required by H35640, SQLite
shall append a new journal header to the journal file
before proceding with the write operation required by H35670.
No parents No children |
H35670 |
When required to purge a page cache entry that is a
dirty page SQLite shall write the page data into the database
file, using a single call to the xWrite method of the database
connection file handle.
No parents No children |
H35680 |
When required to append a journal header to the journal
file, SQLite shall do so by writing a block of sector-size
bytes using a single call to the xWrite method of the file-handle
open on the journal file. The block of data written shall begin
at the smallest sector-size aligned offset at or following the current
end of the journal file.
No parents No children |
H35690 |
The first 8 bytes of the journal header required to be written
by H35680 shall contain the following values, in order from byte offset 0
to 7: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63 and 0xd7.
No parents No children |
H35700 |
Bytes 8-11 of the journal header required to be written by
H35680 shall contain 0x00.
No parents No children |
H35710 |
Bytes 12-15 of the journal header required to be written by
H35680 shall contain the number of pages that the database file
contained when the current write-transaction was started,
formatted as a 4-byte big-endian unsigned integer.
No parents No children |
H35720 |
Bytes 16-19 of the journal header required to be written by
H35680 shall contain pseudo-randomly generated values.
No parents No children |
H35730 |
Bytes 20-23 of the journal header required to be written by
H35680 shall contain the sector size used by the VFS layer,
formatted as a 4-byte big-endian unsigned integer.
No parents No children |
H35740 |
Bytes 24-27 of the journal header required to be written by
H35680 shall contain the page size used by the database at
the start of the write transaction, formatted as a 4-byte
big-endian unsigned integer.
No parents No children |
H35750 |
When required to sync the journal file, SQLite shall invoke the
xSync method of the file handle open on the journal file.
No parents No children |
H35760 |
When required to sync the journal file, after invoking the
xSync method as required by H35750, SQLite shall update the record
count of the journal header most recently written to the
journal file. The 4-byte field shall be updated to contain
the number of journal records that have been written to the
journal file since the journal header was written,
formatted as a 4-byte big-endian unsigned integer.
No parents No children |
H35770 |
When required to sync the journal file, after updating the
record count field of a journal header as required by
H35760, SQLite shall invoke the xSync method of the file handle open
on the journal file.
No parents No children |
H35780 |
When required to upgrade to an exclusive lock as part of a write
transaction, SQLite shall first attempt to obtain a pending lock
on the database file if one is not already held by invoking the xLock
method of the file handle opened on the database file.
No parents No children |
H35790 |
When required to upgrade to an exclusive lock as part of a write
transaction, after successfully obtaining a pending lock SQLite
shall attempt to obtain an exclusive lock by invoking the
xLock method of the file handle opened on the database file.
No parents No children |
H35800 |
When required to commit a write-transaction, SQLite shall
modify page 1 to increment the value stored in the change counter
field of the database file header.
No parents No children |
H35810 |
When required to commit a write-transaction, after incrementing
the change counter field, SQLite shall sync the journal
file.
No parents No children |
H35820 |
When required to commit a write-transaction, after syncing
the journal file as required by H35810, if an exclusive lock
on the database file is not already held, SQLite shall attempt to
upgrade to an exclusive lock.
No parents No children |
H35830 |
When required to commit a write-transaction, after syncing
the journal file as required by H35810 and ensuring that an
exclusive lock is held on the database file as required by
H35830, SQLite shall copy the contents of all dirty page
stored in the page cache into the database file using
calls to the xWrite method of the database connection file
handle. Each call to xWrite shall write the contents of a single
dirty page (page-size bytes of data) to the database
file. Dirty pages shall be written in order of page number,
from lowest to highest.
No parents No children |
H35840 |
When required to commit a write-transaction, after copying the
contents of any dirty pages to the database file as required
by H35830, SQLite shall sync the database file by invoking the xSync
method of the database connection file handle.
No parents No children |
H35850 |
When required to commit a write-transaction, after syncing
the database file as required by H35840, SQLite shall close the
file-handle opened on the journal file and delete the
journal file from the file system via a call to the VFS
xDelete method.
No parents No children |
H35860 |
When required to commit a write-transaction, after deleting
the journal file as required by H35850, SQLite shall relinquish
all locks held on the database file by invoking the xUnlock
method of the database connection file handle.
No parents No children |
H40310 |
SQLite shall recognize as a VARIABLE token the a question-mark (u003f)
followed by zero or more NUMERIC characters.
No parents No children |
H40320 |
SQLite shall recognize as a VARIABLE token one of the characters
at-sign (u0040), dollar-sign (u0024), or colon (u003a) followed
by a parameter name.
No parents No children |
H40330 |
SQLite shall recognize as a VARIABLE token the shape-sign (u0023)
followed by a parameter name that does not begin with a
NUMERIC character.
No parents No children |
H41010 |
SQLite shall divide input SQL text into tokens working from left to
right.
No parents No children |
H41020 |
At each step in the SQL tokenization process, SQLite shall extract
the longest possible token from the remaining input text.
No parents No children |
H41030 |
The tokenizer shall pass each non-WHITESPACE token seen on to the
parser in the order in which the tokens are seen.
No parents No children |
H41040 |
When the tokenizer reaches the end of input where the last token sent
to the parser was not a SEMI token, it shall
send a SEMI token to the parser.
No parents No children |
H41050 |
When the tokenizer encounters text that is not a valid token, it shall
cause an error to be returned to the application.
No parents No children |
H41100 |
SQLite shall recognize a sequence of one or more WHITESPACE characters
as a WHITESPACE token.
No parents No children |
H41110 |
SQLite shall recognize as a WHITESPACE token the two-character sequence "--"
(u002d, u002d) followed by any sequence of non-zero characters up through and
including the first u000a character or until end of input.
No parents No children |
H41120 |
SQLite shall recognize as a WHITESPACE token the two-character sequence "/*"
(u002f, u002a) followed by any sequence of zero or more
non-zero characters through with the first "*/" (u002a, u002f) sequence or
until end of input.
No parents No children |
H41130 |
SQLite shall recognize as an ID token
any sequence of characters that begins with
an ALPHABETIC character and continue with zero or more
ALPHANUMERIC characters and/or "$" (u0024) characters and which is
not a keyword token.
No parents No children |
H41140 |
SQLite shall recognize as an ID token
any sequence of non-zero characters that begins with "[" (u005b) and
continuing through the first "]" (u005d) character.
No parents No children |
H41150 |
SQLite shall recognize as an ID token
any sequence of characters
that begins with a double-quote (u0022), is followed by zero or
more non-zero characters and/or pairs of double-quotes (u0022)
and terminates with a double-quote (u0022) that
is not part of a pair.
No parents No children |
H41160 |
SQLite shall recognize as an ID token
any sequence of characters
that begins with a grave accent (u0060), is followed by zero or
more non-zero characters and/or pairs ofgrave accents (u0060)
and terminates with a grave accent (u0022) that
is not part of a pair.
No parents No children |
H41200 |
SQLite shall recognize as a STRING token a sequence of characters
that begins with a single-quote (u0027), is followed by zero or
more non-zero characters and/or pairs of single-quotes (u0027)
and terminates with a single-quote (u0027) that
is not part of a pair.
No parents No children |
H41210 |
SQLite shall recognize as a BLOB token an upper or lower-case "X"
(u0058 or u0078) followed by a single-quote (u0027) followed by
a number of HEXADECIMAL character that is a multiple of two and
terminated by a single-quote (u0027).
No parents No children |
H41220 |
SQLite shall recognize as an INTEGER token any squence of
one or more NUMERIC characters.
No parents No children |
H41230 |
SQLite shall recognize as a FLOAT token a sequence of one
or more NUMERIC characters together with zero or one period
(u002e) and followed by an exponentiation suffix.
No parents No children |
H41240 |
SQLite shall recognize as a FLOAT token a sequence of one
or more NUMERIC characters that includes exactly one period
(u002e) character.
No parents No children |
H41403 |
SQLite shall recognize the 1-character sequenence "-" (u002d) as token MINUS
No parents No children |
H41406 |
SQLite shall recognize the 1-character sequenence "(" (u0028) as token LP
No parents No children |
H41409 |
SQLite shall recognize the 1-character sequenence ")" (u0029) as token RP
No parents No children |
H41412 |
SQLite shall recognize the 1-character sequenence ";" (u003b) as token SEMI
No parents No children |
H41415 |
SQLite shall recognize the 1-character sequenence "+" (u002b) as token PLUS
No parents No children |
H41418 |
SQLite shall recognize the 1-character sequenence "*" (u002a) as token STAR
No parents No children |
H41421 |
SQLite shall recognize the 1-character sequenence "/" (u002f) as token SLASH
No parents No children |
H41424 |
SQLite shall recognize the 1-character sequenence "%" (u0025) as token REM
No parents No children |
H41427 |
SQLite shall recognize the 1-character sequenence "=" (u003d) as token EQ
No parents No children |
H41430 |
SQLite shall recognize the 2-character sequenence "==" (u003d u003d) as token EQ
No parents No children |
H41433 |
SQLite shall recognize the 2-character sequenence "<=" (u003c u003d) as token LE
No parents No children |
H41436 |
SQLite shall recognize the 2-character sequenence "<>" (u003c u003e) as token NE
No parents No children |
H41439 |
SQLite shall recognize the 2-character sequenence "<<" (u003c u003c) as token LSHIFT
No parents No children |
H41442 |
SQLite shall recognize the 1-character sequenence "<" (u003c) as token LT
No parents No children |
H41445 |
SQLite shall recognize the 2-character sequenence ">=" (u003e u003d) as token GE
No parents No children |
H41448 |
SQLite shall recognize the 2-character sequenence ">>" (u003e u003e) as token RSHIFT
No parents No children |
H41451 |
SQLite shall recognize the 1-character sequenence ">" (u003e) as token GT
No parents No children |
H41454 |
SQLite shall recognize the 2-character sequenence "!=" (u0021 u003d) as token NE
No parents No children |
H41457 |
SQLite shall recognize the 1-character sequenence "," (u002c) as token COMMA
No parents No children |
H41460 |
SQLite shall recognize the 1-character sequenence "&" (u0026) as token BITAND
No parents No children |
H41463 |
SQLite shall recognize the 1-character sequenence "~" (u007e) as token BITNOT
No parents No children |
H41466 |
SQLite shall recognize the 1-character sequenence "|" (u007c) as token BITOR
No parents No children |
H41469 |
SQLite shall recognize the 2-character sequenence "||" (u007c u007c) as token CONCAT
No parents No children |
H41472 |
SQLite shall recognize the 1-character sequenence "." (u002e) as token DOT
No parents No children |
H41503 |
SQLite shall recognize the 5-character sequenence "ABORT" in any combination of upper and lower case letters as the keyword token ABORT.
No parents No children |
H41506 |
SQLite shall recognize the 3-character sequenence "ADD" in any combination of upper and lower case letters as the keyword token ADD.
No parents No children |
H41509 |
SQLite shall recognize the 5-character sequenence "AFTER" in any combination of upper and lower case letters as the keyword token AFTER.
No parents No children |
H41512 |
SQLite shall recognize the 3-character sequenence "ALL" in any combination of upper and lower case letters as the keyword token ALL.
No parents No children |
H41515 |
SQLite shall recognize the 5-character sequenence "ALTER" in any combination of upper and lower case letters as the keyword token ALTER.
No parents No children |
H41518 |
SQLite shall recognize the 7-character sequenence "ANALYZE" in any combination of upper and lower case letters as the keyword token ANALYZE.
No parents No children |
H41521 |
SQLite shall recognize the 3-character sequenence "AND" in any combination of upper and lower case letters as the keyword token AND.
No parents No children |
H41524 |
SQLite shall recognize the 2-character sequenence "AS" in any combination of upper and lower case letters as the keyword token AS.
No parents No children |
H41527 |
SQLite shall recognize the 3-character sequenence "ASC" in any combination of upper and lower case letters as the keyword token ASC.
No parents No children |
H41530 |
SQLite shall recognize the 6-character sequenence "ATTACH" in any combination of upper and lower case letters as the keyword token ATTACH.
No parents No children |
H41533 |
SQLite shall recognize the 13-character sequenence "AUTOINCREMENT" in any combination of upper and lower case letters as the keyword token AUTOINCR.
No parents No children |
H41536 |
SQLite shall recognize the 6-character sequenence "BEFORE" in any combination of upper and lower case letters as the keyword token BEFORE.
No parents No children |
H41539 |
SQLite shall recognize the 5-character sequenence "BEGIN" in any combination of upper and lower case letters as the keyword token BEGIN.
No parents No children |
H41542 |
SQLite shall recognize the 7-character sequenence "BETWEEN" in any combination of upper and lower case letters as the keyword token BETWEEN.
No parents No children |
H41545 |
SQLite shall recognize the 2-character sequenence "BY" in any combination of upper and lower case letters as the keyword token BY.
No parents No children |
H41548 |
SQLite shall recognize the 7-character sequenence "CASCADE" in any combination of upper and lower case letters as the keyword token CASCADE.
No parents No children |
H41551 |
SQLite shall recognize the 4-character sequenence "CASE" in any combination of upper and lower case letters as the keyword token CASE.
No parents No children |
H41554 |
SQLite shall recognize the 4-character sequenence "CAST" in any combination of upper and lower case letters as the keyword token CAST.
No parents No children |
H41557 |
SQLite shall recognize the 5-character sequenence "CHECK" in any combination of upper and lower case letters as the keyword token CHECK.
No parents No children |
H41560 |
SQLite shall recognize the 7-character sequenence "COLLATE" in any combination of upper and lower case letters as the keyword token COLLATE.
No parents No children |
H41563 |
SQLite shall recognize the 6-character sequenence "COLUMN" in any combination of upper and lower case letters as the keyword token COLUMNKW.
No parents No children |
H41566 |
SQLite shall recognize the 6-character sequenence "COMMIT" in any combination of upper and lower case letters as the keyword token COMMIT.
No parents No children |
H41569 |
SQLite shall recognize the 8-character sequenence "CONFLICT" in any combination of upper and lower case letters as the keyword token CONFLICT.
No parents No children |
H41572 |
SQLite shall recognize the 10-character sequenence "CONSTRAINT" in any combination of upper and lower case letters as the keyword token CONSTRAINT.
No parents No children |
H41575 |
SQLite shall recognize the 6-character sequenence "CREATE" in any combination of upper and lower case letters as the keyword token CREATE.
No parents No children |
H41578 |
SQLite shall recognize the 5-character sequenence "CROSS" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41581 |
SQLite shall recognize the 12-character sequenence "CURRENT_DATE" in any combination of upper and lower case letters as the keyword token CTIME_KW.
No parents No children |
H41584 |
SQLite shall recognize the 12-character sequenence "CURRENT_TIME" in any combination of upper and lower case letters as the keyword token CTIME_KW.
No parents No children |
H41587 |
SQLite shall recognize the 17-character sequenence "CURRENT_TIMESTAMP" in any combination of upper and lower case letters as the keyword token CTIME_KW.
No parents No children |
H41590 |
SQLite shall recognize the 8-character sequenence "DATABASE" in any combination of upper and lower case letters as the keyword token DATABASE.
No parents No children |
H41593 |
SQLite shall recognize the 7-character sequenence "DEFAULT" in any combination of upper and lower case letters as the keyword token DEFAULT.
No parents No children |
H41596 |
SQLite shall recognize the 8-character sequenence "DEFERRED" in any combination of upper and lower case letters as the keyword token DEFERRED.
No parents No children |
H41599 |
SQLite shall recognize the 10-character sequenence "DEFERRABLE" in any combination of upper and lower case letters as the keyword token DEFERRABLE.
No parents No children |
H41602 |
SQLite shall recognize the 6-character sequenence "DELETE" in any combination of upper and lower case letters as the keyword token DELETE.
No parents No children |
H41605 |
SQLite shall recognize the 4-character sequenence "DESC" in any combination of upper and lower case letters as the keyword token DESC.
No parents No children |
H41608 |
SQLite shall recognize the 6-character sequenence "DETACH" in any combination of upper and lower case letters as the keyword token DETACH.
No parents No children |
H41611 |
SQLite shall recognize the 8-character sequenence "DISTINCT" in any combination of upper and lower case letters as the keyword token DISTINCT.
No parents No children |
H41614 |
SQLite shall recognize the 4-character sequenence "DROP" in any combination of upper and lower case letters as the keyword token DROP.
No parents No children |
H41617 |
SQLite shall recognize the 3-character sequenence "END" in any combination of upper and lower case letters as the keyword token END.
No parents No children |
H41620 |
SQLite shall recognize the 4-character sequenence "EACH" in any combination of upper and lower case letters as the keyword token EACH.
No parents No children |
H41623 |
SQLite shall recognize the 4-character sequenence "ELSE" in any combination of upper and lower case letters as the keyword token ELSE.
No parents No children |
H41626 |
SQLite shall recognize the 6-character sequenence "ESCAPE" in any combination of upper and lower case letters as the keyword token ESCAPE.
No parents No children |
H41629 |
SQLite shall recognize the 6-character sequenence "EXCEPT" in any combination of upper and lower case letters as the keyword token EXCEPT.
No parents No children |
H41632 |
SQLite shall recognize the 9-character sequenence "EXCLUSIVE" in any combination of upper and lower case letters as the keyword token EXCLUSIVE.
No parents No children |
H41635 |
SQLite shall recognize the 6-character sequenence "EXISTS" in any combination of upper and lower case letters as the keyword token EXISTS.
No parents No children |
H41638 |
SQLite shall recognize the 7-character sequenence "EXPLAIN" in any combination of upper and lower case letters as the keyword token EXPLAIN.
No parents No children |
H41641 |
SQLite shall recognize the 4-character sequenence "FAIL" in any combination of upper and lower case letters as the keyword token FAIL.
No parents No children |
H41644 |
SQLite shall recognize the 3-character sequenence "FOR" in any combination of upper and lower case letters as the keyword token FOR.
No parents No children |
H41647 |
SQLite shall recognize the 7-character sequenence "FOREIGN" in any combination of upper and lower case letters as the keyword token FOREIGN.
No parents No children |
H41650 |
SQLite shall recognize the 4-character sequenence "FROM" in any combination of upper and lower case letters as the keyword token FROM.
No parents No children |
H41653 |
SQLite shall recognize the 4-character sequenence "FULL" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41656 |
SQLite shall recognize the 4-character sequenence "GLOB" in any combination of upper and lower case letters as the keyword token LIKE_KW.
No parents No children |
H41659 |
SQLite shall recognize the 5-character sequenence "GROUP" in any combination of upper and lower case letters as the keyword token GROUP.
No parents No children |
H41662 |
SQLite shall recognize the 6-character sequenence "HAVING" in any combination of upper and lower case letters as the keyword token HAVING.
No parents No children |
H41665 |
SQLite shall recognize the 2-character sequenence "IF" in any combination of upper and lower case letters as the keyword token IF.
No parents No children |
H41668 |
SQLite shall recognize the 6-character sequenence "IGNORE" in any combination of upper and lower case letters as the keyword token IGNORE.
No parents No children |
H41671 |
SQLite shall recognize the 9-character sequenence "IMMEDIATE" in any combination of upper and lower case letters as the keyword token IMMEDIATE.
No parents No children |
H41674 |
SQLite shall recognize the 2-character sequenence "IN" in any combination of upper and lower case letters as the keyword token IN.
No parents No children |
H41677 |
SQLite shall recognize the 5-character sequenence "INDEX" in any combination of upper and lower case letters as the keyword token INDEX.
No parents No children |
H41680 |
SQLite shall recognize the 9-character sequenence "INITIALLY" in any combination of upper and lower case letters as the keyword token INITIALLY.
No parents No children |
H41683 |
SQLite shall recognize the 5-character sequenence "INNER" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41686 |
SQLite shall recognize the 6-character sequenence "INSERT" in any combination of upper and lower case letters as the keyword token INSERT.
No parents No children |
H41689 |
SQLite shall recognize the 7-character sequenence "INSTEAD" in any combination of upper and lower case letters as the keyword token INSTEAD.
No parents No children |
H41692 |
SQLite shall recognize the 9-character sequenence "INTERSECT" in any combination of upper and lower case letters as the keyword token INTERSECT.
No parents No children |
H41695 |
SQLite shall recognize the 4-character sequenence "INTO" in any combination of upper and lower case letters as the keyword token INTO.
No parents No children |
H41698 |
SQLite shall recognize the 2-character sequenence "IS" in any combination of upper and lower case letters as the keyword token IS.
No parents No children |
H41701 |
SQLite shall recognize the 6-character sequenence "ISNULL" in any combination of upper and lower case letters as the keyword token ISNULL.
No parents No children |
H41704 |
SQLite shall recognize the 4-character sequenence "JOIN" in any combination of upper and lower case letters as the keyword token JOIN.
No parents No children |
H41707 |
SQLite shall recognize the 3-character sequenence "KEY" in any combination of upper and lower case letters as the keyword token KEY.
No parents No children |
H41710 |
SQLite shall recognize the 4-character sequenence "LEFT" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41713 |
SQLite shall recognize the 4-character sequenence "LIKE" in any combination of upper and lower case letters as the keyword token LIKE_KW.
No parents No children |
H41716 |
SQLite shall recognize the 5-character sequenence "LIMIT" in any combination of upper and lower case letters as the keyword token LIMIT.
No parents No children |
H41719 |
SQLite shall recognize the 5-character sequenence "MATCH" in any combination of upper and lower case letters as the keyword token MATCH.
No parents No children |
H41722 |
SQLite shall recognize the 7-character sequenence "NATURAL" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41725 |
SQLite shall recognize the 3-character sequenence "NOT" in any combination of upper and lower case letters as the keyword token NOT.
No parents No children |
H41728 |
SQLite shall recognize the 7-character sequenence "NOTNULL" in any combination of upper and lower case letters as the keyword token NOTNULL.
No parents No children |
H41731 |
SQLite shall recognize the 4-character sequenence "NULL" in any combination of upper and lower case letters as the keyword token NULL.
No parents No children |
H41734 |
SQLite shall recognize the 2-character sequenence "OF" in any combination of upper and lower case letters as the keyword token OF.
No parents No children |
H41737 |
SQLite shall recognize the 6-character sequenence "OFFSET" in any combination of upper and lower case letters as the keyword token OFFSET.
No parents No children |
H41740 |
SQLite shall recognize the 2-character sequenence "ON" in any combination of upper and lower case letters as the keyword token ON.
No parents No children |
H41743 |
SQLite shall recognize the 2-character sequenence "OR" in any combination of upper and lower case letters as the keyword token OR.
No parents No children |
H41746 |
SQLite shall recognize the 5-character sequenence "ORDER" in any combination of upper and lower case letters as the keyword token ORDER.
No parents No children |
H41749 |
SQLite shall recognize the 5-character sequenence "OUTER" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41752 |
SQLite shall recognize the 4-character sequenence "PLAN" in any combination of upper and lower case letters as the keyword token PLAN.
No parents No children |
H41755 |
SQLite shall recognize the 6-character sequenence "PRAGMA" in any combination of upper and lower case letters as the keyword token PRAGMA.
No parents No children |
H41758 |
SQLite shall recognize the 7-character sequenence "PRIMARY" in any combination of upper and lower case letters as the keyword token PRIMARY.
No parents No children |
H41761 |
SQLite shall recognize the 5-character sequenence "QUERY" in any combination of upper and lower case letters as the keyword token QUERY.
No parents No children |
H41764 |
SQLite shall recognize the 5-character sequenence "RAISE" in any combination of upper and lower case letters as the keyword token RAISE.
No parents No children |
H41767 |
SQLite shall recognize the 10-character sequenence "REFERENCES" in any combination of upper and lower case letters as the keyword token REFERENCES.
No parents No children |
H41770 |
SQLite shall recognize the 6-character sequenence "REGEXP" in any combination of upper and lower case letters as the keyword token LIKE_KW.
No parents No children |
H41773 |
SQLite shall recognize the 7-character sequenence "REINDEX" in any combination of upper and lower case letters as the keyword token REINDEX.
No parents No children |
H41776 |
SQLite shall recognize the 6-character sequenence "RENAME" in any combination of upper and lower case letters as the keyword token RENAME.
No parents No children |
H41779 |
SQLite shall recognize the 7-character sequenence "REPLACE" in any combination of upper and lower case letters as the keyword token REPLACE.
No parents No children |
H41782 |
SQLite shall recognize the 8-character sequenence "RESTRICT" in any combination of upper and lower case letters as the keyword token RESTRICT.
No parents No children |
H41785 |
SQLite shall recognize the 5-character sequenence "RIGHT" in any combination of upper and lower case letters as the keyword token JOIN_KW.
No parents No children |
H41788 |
SQLite shall recognize the 8-character sequenence "ROLLBACK" in any combination of upper and lower case letters as the keyword token ROLLBACK.
No parents No children |
H41791 |
SQLite shall recognize the 3-character sequenence "ROW" in any combination of upper and lower case letters as the keyword token ROW.
No parents No children |
H41794 |
SQLite shall recognize the 6-character sequenence "SELECT" in any combination of upper and lower case letters as the keyword token SELECT.
No parents No children |
H41797 |
SQLite shall recognize the 3-character sequenence "SET" in any combination of upper and lower case letters as the keyword token SET.
No parents No children |
H41800 |
SQLite shall recognize the 5-character sequenence "TABLE" in any combination of upper and lower case letters as the keyword token TABLE.
No parents No children |
H41803 |
SQLite shall recognize the 4-character sequenence "TEMP" in any combination of upper and lower case letters as the keyword token TEMP.
No parents No children |
H41806 |
SQLite shall recognize the 9-character sequenence "TEMPORARY" in any combination of upper and lower case letters as the keyword token TEMP.
No parents No children |
H41809 |
SQLite shall recognize the 4-character sequenence "THEN" in any combination of upper and lower case letters as the keyword token THEN.
No parents No children |
H41812 |
SQLite shall recognize the 2-character sequenence "TO" in any combination of upper and lower case letters as the keyword token TO.
No parents No children |
H41815 |
SQLite shall recognize the 11-character sequenence "TRANSACTION" in any combination of upper and lower case letters as the keyword token TRANSACTION.
No parents No children |
H41818 |
SQLite shall recognize the 7-character sequenence "TRIGGER" in any combination of upper and lower case letters as the keyword token TRIGGER.
No parents No children |
H41821 |
SQLite shall recognize the 5-character sequenence "UNION" in any combination of upper and lower case letters as the keyword token UNION.
No parents No children |
H41824 |
SQLite shall recognize the 6-character sequenence "UNIQUE" in any combination of upper and lower case letters as the keyword token UNIQUE.
No parents No children |
H41827 |
SQLite shall recognize the 6-character sequenence "UPDATE" in any combination of upper and lower case letters as the keyword token UPDATE.
No parents No children |
H41830 |
SQLite shall recognize the 5-character sequenence "USING" in any combination of upper and lower case letters as the keyword token USING.
No parents No children |
H41833 |
SQLite shall recognize the 6-character sequenence "VACUUM" in any combination of upper and lower case letters as the keyword token VACUUM.
No parents No children |
H41836 |
SQLite shall recognize the 6-character sequenence "VALUES" in any combination of upper and lower case letters as the keyword token VALUES.
No parents No children |
H41839 |
SQLite shall recognize the 4-character sequenence "VIEW" in any combination of upper and lower case letters as the keyword token VIEW.
No parents No children |
H41842 |
SQLite shall recognize the 7-character sequenence "VIRTUAL" in any combination of upper and lower case letters as the keyword token VIRTUAL.
No parents No children |
H41845 |
SQLite shall recognize the 4-character sequenence "WHEN" in any combination of upper and lower case letters as the keyword token WHEN.
No parents No children |
H41848 |
SQLite shall recognize the 5-character sequenence "WHERE" in any combination of upper and lower case letters as the keyword token WHERE.
No parents No children |
H42000 |
The SQLite parser shall accept SQL statements consisting of an SQL command
followed by a semicolon.
sql_statement ::= cmd SEMI. No parents No children |
H42002 |
The preparation of an SQL statement that is not accepted by
the SQLite parser shall fail with an error.
No parents No children |
H42004 |
SQLite shall use the built-in NOCASE collating sequence when comparing
identifiers and datatype names within SQL statements during
statement preparation.
No parents No children |
H42008 |
A token received by the parser shall be converted into an ID token
if the original token value would have resulted in a syntax error,
a token value of ID will allow the parse to continue,
and if the original token value was one of:
ABORT
AFTER
ANALYZE
ASC
ATTACH
BEFORE
BEGIN
CASCADE
CAST
CONFLICT
CTIME_KW
DATABASE
DEFERRED
DESC
DETACH
EACH
END
EXCEPT
EXCLUSIVE
EXPLAIN
FAIL
FOR
IF
IGNORE
IMMEDIATE
INITIALLY
INSTEAD
INTERSECT
KEY
LIKE_KW
MATCH
OF
OFFSET
PLAN
PRAGMA
QUERY
RAISE
REINDEX
RENAME
REPLACE
RESTRICT
ROW
TEMP
TRIGGER
UNION
VACUUM
VIEW
VIRTUAL
No parents No children |
H42010 |
The SQLite parser shall accept BEGIN statements
that conform to the following syntax:
cmd ::= BEGIN transaction_type transaction_name. transaction_type ::= . transaction_type ::= DEFERRED. transaction_type ::= IMMEDIATE. transaction_type ::= EXCLUSIVE. transaction_name ::= . transaction_name ::= TRANSACTION. transaction_name ::= TRANSACTION name. No parents No children |
H42012 |
A token received by the parser shall be converted into an ANY token
if the original token value would have resulted in a syntax error
and if a token value of ANY will allow the parse to continue.
No parents No children |
H42013 |
The successful evaluation of a BEGIN statement shall
cause the database connection to exit autocommit mode.
No parents No children |
H42016 |
The evaluation of a BEGIN TRANSACTION statement shall fail with an error
if the database connection is not in autocommit mode at the
start of evaluation.
No parents No children |
H42019 |
If the transaction_type keyword is omitted from a
BEGIN TRANSACTION statement then the behavior shall be the same
as if the DEFERRED keyword were used.
No parents No children |
H42022 |
When the DEFERRED keyword appears in a BEGIN statement
the locking state of the underlying database files shall be
the same before and after the statement is evaluated.
No parents No children |
H42025 |
When the IMMEDIATE keyword appears in a BEGIN statement
then successful evaluation of the statement shall cause a RESERVED
lock to be obtained for all underlying database files.
No parents No children |
H42028 |
When the EXCLUSIVE keyword appears in a BEGIN statement
then successful evaluation of the statement shall cause a EXCLUSIVE
lock to be obtained for all underlying database files.
No parents No children |
H42110 |
SQLite shall accept the following COMMIT statement syntax:
cmd ::= COMMIT transaction_name. cmd ::= END transaction_name. No parents No children |
H42113 |
The successful evaluation of COMMIT statement places the
database connection in autocommit mode.
No parents No children |
H42116 |
If a database connection is already in autocommit mode when
a COMMIT statement is evaluated, then the statement shall fail
with an error.
No parents No children |
H42210 |
The SQLite parser shall accept ROLLBACK statements
that conform to the following syntax:
cmd ::= ROLLBACK transaction_name. No parents No children |
H42213 |
The successful evaluation of ROLLBACK statement places the
database connection in autocommit mode.
No parents No children |
H42216 |
If a database connection is already in autocommit mode when
a ROLLBACK statement is invoked, then the statement invocation
shall fail with an error.
No parents No children |
H42222 |
Other pending statements on the same database connection
as a successfully evaluated ROLLBACK statement shall be aborted.
No parents No children |
H42225 |
The successful evaluation of a ROLLBACK statement causes the
current transaction on the database connection to roll back.
No parents No children |
H42310 |
The SQLite parser shall accept CREATE TABLE statements
that conform to the following syntax:
cmd ::= CREATE temp TABLE ifnotexists fullname table_definition. temp ::= . temp ::= TEMP. ifnotexists ::= . ifnotexists ::= IF NOT EXISTS. No parents No children |
H42313 |
When the TEMP keyword appears in a CREATE TABLE statement and the
databasename exists and is something other than "temp", then
the preparation of the CREATE TABLE statement shall fail with an error.
No parents No children |
H42316 |
When the TEMP keyword appears in a CREATE TABLE statement the behavior
shall be as if the databasename where "temp".
No parents No children |
H42319 |
The successful evaluation of a CREATE TABLE statement shall cause
a new SQL table whose name is given by the objectname to be
created in the schema of the database whose name is given by the
databasename.
No parents No children |
H42322 |
If a CREATE TABLE statement specifies no databasename and omits
the TEMP keyword then the behavior shall be as if a databasename
of "main" where used.
No parents No children |
H42325 |
The preparation of a CREATE TABLE statement shall fail with an
error if the IF NOT EXISTS clause is omitted and the objectname
is the same as the name of a table or view
in the same database.
No parents No children |
H42328 |
The evaluation of a CREATE TABLE statement shall be a silent no-op if the
IF NOT EXISTS clause is present and the objectname
is the same as the name of a table or view
in the same database.
No parents No children |
H42331 |
The preparation of a CREATE TABLE statement shall fail with an error if the
the objectname is the same as the name of an index
in any database attached to the same database connection.
No parents No children |
H42334 |
The preparation of a CREATE TABLE statement shall fail with an error if the
the databasename references a database that is not
attached to the same database connection.
No parents No children |
H42410 |
The SQLite parser shall accept the following syntax for the
table_definition section of a CREATE TABLE statement:
table_definition ::= LP columnlist constraint_opt RP. columnlist ::= column. columnlist ::= columnlist COMMON column. constraint_opt ::= . constraint_opt ::= COMMA constraint_list. No parents No children |
H42413 |
The SQLite parser shall accept the following syntax
for the column component of a table_definition.
column ::= name column_type column_constraint_list. column_type ::= . column_type ::= typename. column_type ::= typename LP signed_int RP. column_type ::= typename LP signed_int COMMA signed_int RP. typename ::= identifier. typename ::= typename identifier. signed_int ::= INTEGER. signed_int ::= MINUS INTEGER. signed_int ::= PLUS INTEGER. No parents No children |
H42416 |
The preparation of an ordinary CREATE TABLE statement shall fail
with an error if it specifies two or more columns with the same name.
No parents No children |
H42419 |
The datatype affinity of each column in a table generate by an
ordinary CREATE TABLE statement
shall be determined from the column_type
text using the following 5-step algorithm:
No parents No children |
H42450 |
The SQLite parser shall accept the following syntax for the list of column
constraints and modifiers that follows a column definition in
an ordinary CREATE TABLE statement.
column_constraint_list ::= . column_constraint_list ::= column_constraint_list named_column_constraint. named_column_constraint ::= CONSTRAINT name column_constraint. named_column_constraint ::= column_constraint. column_constraint ::= DEFAULT term. column_constraint ::= DEFAULT identifier. column_constraint ::= DEFAULT PLUS term. column_constraint ::= DEFAULT MINUS term. column_constraint ::= DEFAULT LP expr RP. column_constraint ::= NULL conflict. column_constraint ::= NOT NULL conflict. column_constraint ::= PRIMARY KEY sortorder conflict autoincr. column_constraint ::= UNIQUE conflict. column_constraint ::= CHECK LP expr RP. column_constraint ::= COLLATE identifier. column_constraint ::= foreign_key_constraint. column_constraint ::= deferrable_constraint. autoincr ::= . autoincr ::= AUTOINCR. indexlist_opt ::= . indexlist_opt ::= LP indexlist RP. conflict ::= . conflict ::= ON CONFLICT IGNORE. conflict ::= ON CONFLICT REPLACE. conflict ::= ON CONFLICT ABORT. conflict ::= ON CONFLICT FAIL. conflict ::= ON CONFLICT ROLLBACK. No parents No children |
H42453 |
When a column as a DEFAULT constraint, the default value for the
column shall be the value specified by that constraint.
No parents No children |
H42456 |
If a column has no DEFAULT constraint then the default value for
that column shall be NULL.
No parents No children |
H42459 |
If a column has no NOT NULL constraint then the NULL conflict
resolution behavior for the column shall be NONE.
No parents No children |
H42462 |
If a column has a NOT NULL constraint and that constrait lacks
an ON CONFLICT clause
then the null-conflict resolution behavior for the column shall
be ABORT.
No parents No children |
H42465 |
If a column has a NOT NULL constraint and that constraint
has an ON CONFLICT clause
then the null-conflict resolution behavior for the column shall
be the behavior specified by the ON CONFLICT clause.
No parents No children |
H42467 |
A column without a COLLATE constraint shall have a default
collating sequence of BINARY.
No parents No children |
H42468 |
A column with a COLLATE constraint shall have a default
collating sequence as specified by the COLLATE constraint.
No parents No children |
H42470 |
If the datatype of a single-column PRIMARY KEY is
exactly "INTEGER" then the name of that column shall be
an alias for the table rowid.
No parents No children |
H42472 |
If a table contains no column named "ROWID" then "ROWID" shall be
an alias for the table rowid.
No parents No children |
H42474 |
If a table contains no column named "OID" then "OID" shall be
an alias for the table rowid.
No parents No children |
H42476 |
If a table contains no column named "_ROWID_" then "_ROWID_" shall be
an alias for the table rowid.
No parents No children |
H42478 |
A table shall have an autoincrementing rowid if and only if
the PRIMARY KEY for the table is an alias for the rowid and
the PRIMARY KEY declaration uses the AUTOINCR keyword.
No parents No children |
H42480 |
Successful evaluation of a CREATE TABLE statement shall create
an index for every UNIQUE constraint where the created index has
a conflict resolution algorithm as specified by the ON CONFLICT
clause of the UNIQUE constraint or a conflict resolution algorithm
of ABORT if there is no ON CONFLICT clause on the constraint.
No parents No children |
H42510 |
The SQLite parser shall accept the following syntax for the list of table
contraints that occurs at the end of an ordinary CREATE TABLE statement.
constraint_list ::= constraint. constraint_list ::= constraint_list constraint. constraint_list ::= constraint_list COMMA constraint. constraint ::= CHECK LP expr RP conflict. constraint ::= CONSTRAINT name. constraint ::= FOREIGN KEY LP columnlist RP foreign_key_constraint defer_opt. constraint ::= PRIMARY KEY LP indexlist autoinc RP conflict. constraint ::= UNIQUE LP indexlist RP conflict. No parents No children |
H42513 |
The preparation of a CREATE TABLE statement that contains more
than one PRIMARY KEY constraint shall fail with an error.
No parents No children |
H42516 |
The preparation of a CREATE TABLE statement that contains a
CHECK constraint that uses a subquery shall fail with an error.
No parents No children |
H42517 |
The preparation of a CREATE TABLE statement that contains a
CHECK constraint that uses a parameter shall fail with an error.
No parents No children |
H42518 |
Name resolution of the expr with each CHECK constraint of
a CREATE TABLE statement shall be carried out using a name context
with an empty result set and a source set holding
single source element that is the
table being created.
No parents No children |
H42521 |
The preparation of a CREATE TABLE statement that contains a
DEFAULT constraint with an non-constant expression
shall fail with an error.
No parents No children |
H42536 |
A PRIMARY KEY constraint that does not result in a rowid alias
shall have the same effect as a UNIQUE constraint.
No parents No children |
H42539 |
Preparation of a CREATE TABLE statement shall fail with an
error if the indexlist of either a table PRIMARY KEY
or a table UNIQUE constraint references a column that is not
a column in the table.
No parents No children |
H42570 |
The SQLite parser shall accept the following syntax for a foreign
key constraint as either a separate constraint or as part of a
column constraint in an ordinary CREATE TABLE statement.
foreign_key_constraint ::= REFERENCES name indexlist_opt fkarglist. defer_opt ::= . defer_opt ::= deferrable_constraint. deferrable_constraint ::= NOT DEFERRABLE initially_deferred_clause. deferrable_constraint ::= DEFERRABLE initially_deferred_clause. fkarglist ::= . fkarglist ::= fkarglist fkarg. fkarg ::= MATCH name. fkarg ::= ON DELETE fkaction. fkarg ::= ON UPDATE fkaction. fkarg ::= ON INSERT fkaction. fkaction ::= SET NULL. fkaction ::= SET DEFAULT. fkaction ::= CASCADE. fkaction ::= RESTRICT. initially_deferred_clause ::= . initially_deferred_clause ::= INITIALLY DEFERRED. initially_deferred_clause ::= INITIALLY IMMEDIATE. No parents No children |
H42610 |
The SQLite parser shall accept the following syntax for creating new
database tables from the result set of SELECT statements.
table_definition ::= AS select. No parents No children |
H42613 |
The table generated by a CREATE TABLE AS statement shall have the
same number of columns as the result set of the SELECT.
No parents No children |
H42616 |
The names of the columns in a table generated by a CREATE TABLE AS
statement shall have base names which are the names of the columns
in the result set of the SELECT statement
No parents No children |
H42617 |
Each column name in a table generated by a CREATE TABLE AS
statement shall have an arbitrary suffix appended to its basename
if and only if such a suffix is necessary to make the name
distinct from all preceding column names in the table.
No parents No children |
H42619 |
All columns in a table generated by a CREATE TABLE AS statement
shall have a default value of NULL.
No parents No children |
H42622 |
All columns in a table generated by a CREATE TABLE AS statement
shall have a NULL conflict resolution behavior of NONE.
No parents No children |
H42625 |
All columns in a table generated by a CREATE TABLE AS statement
shall have an affinity of NONE.
No parents No children |
H42628 |
All columns in a table generated by a CREATE TABLE AS statement
shall have a default collating sequence of BINARY.
No parents No children |
H42700 |
The SQLite parser shall accept DROP TABLE statements
that conform to the following syntax.
cmd ::= DROP TABLE ifexists fullname. ifexists ::= . ifexists ::= IF EXISTS. No parents No children |
H42710 |
The preparation of a DROP TABLE statement shall fail with an
error if the statement lacks an IF EXISTS clause and the
fullname does not reference a existing table.
No parents No children |
H42713 |
The evaluation of a DROP TABLE statement shall be a silent no-op
if the the statement has an IF EXISTS clause and the
fullname does not reference a existing table.
No parents No children |
H42716 |
The successful evaluation of a DROP TABLE statement shall cause
the table identified by fullname to be removed from its
database and discarded.
No parents No children |
H42719 |
The successful evaluation of a DROP TABLE statement shall cause
all indices attached to the table identified by fullname
to be removed from their database and discarded.
No parents No children |
H42721 |
The successful evaluation of a DROP TABLE statement shall cause
all triggers attached to the table identified by fullname
to be removed from their database and discarded.
No parents No children |
H42724 |
The preparation of a DROP TABLE statement shall fail with an
error if fullname is a system table.
No parents No children |
H42800 |
The SQLite parser shall accept CREATE INDEX statements that
conform to the following syntax:
cmd ::= CREATE unique INDEX ifnotexists fullname ON tablename LP indexlist RP. tablename ::= name. indexlist ::= indexlist COMMA columnname collate sortorder. indexlist ::= columnname collate sortorder. columnname ::= name. collate ::= . collate ::= COLLATE identifier. sortorder ::= . sortorder ::= ASC. sortorder ::= DESC. No parents No children |
H42803 |
The target database of a CREATE INDEX statement shall be the
databasename specified in the fullname term of the
statement if the databasename exists.
No parents No children |
H42806 |
If the fullname term of a CREATE INDEX statement does not
specify a databasename and the tablename references a table
that is in the "temp" database, then the target database for the statement
shall be "temp".
No parents No children |
H42809 |
If the fullname term of a CREATE INDEX statement does not
specify a databasename and the tablename references a table
that is not in the "temp" database, then the target database for the
statement shall be "main".
No parents No children |
H42812 |
The preparation of a CREATE INDEX statement shall fail with an error if the
databasename of the fullname exists and references a database
that is not attached to the same database connection.
No parents No children |
H42815 |
The preparation of a CREATE INDEX statement shall fail with an error if the
tablename does not reference an ordinary table in the
database of the statement.
No parents No children |
H42818 |
A successful evaluation of a CREATE INDEX statement shall create a
new index called objectname
in the database of the statement and attached to the
table identified by tablename in that same database.
No parents No children |
H42821 |
An index generated by a CREATE INDEX statement that omits the
UNIQUE keyword shall have a conflict resolution behavior
of NONE.
No parents No children |
H42824 |
An index generated by a CREATE INDEX statement that includes the
UNIQUE keyword shall have a conflict resolution behavior
of ABORT.
No parents No children |
H42830 |
The preparation of a CREATE INDEX statement shall fail with an error if any
columnname value within the indexlist is not the
name of one of the columns of the tablename table.
No parents No children |
H42833 |
The collating sequence for each column of an index shall be the
collating sequence specified in the indexlist.
No parents No children |
H42836 |
If an index column does not specify a collating sequence then
the collating sequence shall be
the default collating sequence of the corresponding table column.
No parents No children |
H42839 |
The sort order for an index column shall be descending if and only
if the DESC keyword is used in the indexlist entry for that
term.
No parents No children |
H42842 |
The preparation of a CREATE INDEX statement shall fail with an error
if the tablename refers to a system table.
No parents No children |
H42900 |
The SQLite parser shall accept DROP INDEX statements
that conform to the following syntax:
cmd ::= DROP INDEX ifexists fullname. No parents No children |
H42910 |
The preparation of a DROP INDEX statement shall fail with an
error if the statement lacks an IF EXISTS clause and the
fullname does not reference a existing index.
No parents No children |
H42913 |
The evaluation of a DROP INDEX statement shall be a silent no-op
if the the statement has an IF EXISTS clause and the
fullname does not reference a existing index.
No parents No children |
H42916 |
The successful evaluation of a DROP INDEX statement shall cause
the index identified by fullname to be removed from its
database and discarded.
No parents No children |
H43100 |
The SQLite parser shall accept CREATE VIEW statements
that conform to the following syntax:
cmd ::= CREATE temp VIEW ifnotexists fullname AS select. No parents No children |
H43113 |
When the TEMP keyword appears in a CREATE VIEW statement and the
databasename exists and is something other than "temp", then
the preparation of the CREATE VIEW statement shall fail with an error.
No parents No children |
H43116 |
When the TEMP keyword appears in a CREATE VIEW statement the behavior
shall be as if the databasename where "temp".
No parents No children |
H43119 |
The successful evaluation of a CREATE VIEW statement shall cause
a new view whose name is given by the objectname and is located
in the schema of the database whose name is given by the
databasename.
No parents No children |
H43122 |
If a CREATE VIEW statement specifies no databasename and omits
the TEMP keyword then the behavior shall be as if a databasename
of "main" where used.
No parents No children |
H43125 |
The preparation of a CREATE VIEW statement shall fail with an
error if the IF NOT EXISTS clause is omitted and the objectname
is the same as the name of a table or view
in the same database.
No parents No children |
H43128 |
The evaluation of a CREATE VIEW statement shall be a silent no-op if the
IF NOT EXISTS clause is present and the objectname
is the same as the name of a table or view
in the same database.
No parents No children |
H43131 |
The preparation of a CREATE VIEW statement shall fail with an error if the
the objectname is the same as the name of an index
in any database attached to the same database connection.
No parents No children |
H43200 |
The SQLite parser shall accept DROP VIEW statements
that conform to the following syntax:
cmd ::= DROP VIEW ifexists fullname. No parents No children |
H43204 |
The preparation of a DROP VIEW statement shall fail with an
error if the statement lacks an IF EXISTS clause and the
fullname does not reference a existing view.
No parents No children |
H43207 |
The evaluation of a DROP VIEW statement shall be a silent no-op
if the the statement has an IF EXISTS clause and the
fullname does not reference a existing view.
No parents No children |
H43211 |
The successful evaluation of a DROP VIEW statement shall cause
the view identified by fullname to be removed from its
database and discarded.
No parents No children |
H43214 |
The successful evaluation of a DROP VIEW statement shall cause
all triggers attached to the view identified by fullname
to be removed from their database and discarded.
No parents No children |
H43234 |
The preparation of a CREATE VIEW statement shall fail with an error if the
the databasename references a database that is not
attached to the same database connection.
No parents No children |
H43237 |
The view generated by a CREATE VIEW statement shall have the
same number of columns as the result set of the SELECT.
No parents No children |
H43241 |
The names of the columns in a view generated by a CREATE VIEW
statement shall have base names which are the names of the columns
in the result set of the SELECT statement
No parents No children |
H43244 |
Each column name in a table generated by a CREATE VIEW
statement shall have an arbitrary suffix appended to its basename
if and only if such a suffix is necessary to make the name
distinct from all preceding column names in the view.
No parents No children |
H43300 |
The SQLite parser shall accept CREATE TRIGGER statements
that conform to the following syntax:
cmd ::= CREATE temp TRIGGER ifnotexists fullname trigger trigger_body. trigger ::= trigger_time trigger_event foreach_clause when_clause. trigger_body ::= BEGIN trigger_cmd_list END. trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI. trigger_cmd_list ::= trigger_cmd_list. trigger_cmd ::= DELETE FROM tablename where. trigger_cmd ::= update_cmd tablename SET setlist where. trigger_cmd ::= insert_cmd INTO tablename columnlist_opt VALUES LP exprlist RP. trigger_cmd ::= insert_cmd INTO tablename columnlist_opt select. trigger_cmd ::= select. trigger_event ::= DELETE ON trigger_target. trigger_event ::= INSERT ON trigger_target. trigger_event ::= UPDATE OF columnlist ON trigger_target. trigger_event ::= UPDATE ON trigger_target. trigger_target ::= fullname. trigger_time ::= AFTER. trigger_time ::= BEFORE. trigger_time ::= INSTEAD OF. trigger_time ::=. foreach_clause ::= FOR EACH ROW. foreach_clause ::=. when_clause ::= WHEN expr. when_clause ::=. No parents No children |
H43303 |
When the TEMP keyword appears in a CREATE TRIGGER statement and the
databasename of the fullname exists
then the preparation of the statement
shall fail with an error.
No parents No children |
H43306 |
When the TEMP keyword appears in a CREATE TRIGGER statement
the target database of the trigger shall be "temp".
No parents No children |
H43309 |
When the TEMP keyword is omitted in a CREATE TRIGGER statement and the
databasename of the fullname is
omitted then the target database of the trigger shall be "main".
No parents No children |
H43312 |
When the databasename of fullname in a CREATE TRIGGER
statement exists, then the target database shall be the database
named by databasename.
No parents No children |
H43315 |
If a CREATE TRIGGER does not specify a trigger_time then
the trigger_time shall be BEFORE.
No parents No children |
H43318 |
The preparation of a CREATE TRIGGER statement shall fail with an error
the trigger_time is INSTEAD OF and trigger_target is not
the name of view in the target database.
No parents No children |
H43321 |
The preparation of a CREATE TRIGGER statement shall fail with an error
the trigger_time is not INSTEAD OF and trigger_target is not
the name of an ordinary table in the target database.
No parents No children |
H43324 |
The preparation of a CREATE TRIGGER statement shall fail with an error
if the trigger_target is a system table.
No parents No children |
H43500 |
The SQLite parser shall accept DROP TRIGGER statements
that conform to the following syntax:
cmd ::= DROP TRIGGER ifexists fullname. No parents No children |
H43504 |
The preparation of a DROP TRIGGER statement shall fail with an
error if the statement lacks an IF EXISTS clause and the
fullname does not reference a existing trigger.
No parents No children |
H43507 |
The evaluation of a DROP TRIGGER statement shall be a silent no-op
if the the statement has an IF EXISTS clause and the
fullname does not reference a existing trigger.
No parents No children |
H43511 |
The successful evaluation of a DROP TRIGGER statement shall cause
the trigger identified by fullname to be removed from its
database and discarded.
No parents No children |
H43514 |
The successful evaluation of a DROP TRIGGER statement shall cause
all triggers attached to the trigger identified by fullname
to be removed from their database and discarded.
No parents No children |
H43600 |
The SQLite parser shall accept CREATE VIRTUAL TABLE statements
that conform to the following syntax.
cmd ::= CREATE VIRTUAL TABLE fullname USING name vtab_arg_list. vtab_arg_list ::= . vtab_arg_list ::= LP vtab_arg_token RP. vtab_arg_token ::= ANY. vtab_arg_token ::= LP anylist RP. anylist ::= . anylist ::= anylist ANY. No parents No children |
H43700 |
The SQLite parser shall accept ALTER TABLE RENAME statements
that conform to the following syntax:
cmd ::= ALTER TABLE fullname RENAME TO name. No parents No children |
H43750 |
The SQLite parser shall accept ALTER TABLE ADD COLUMN statements
that conform to the following syntax:
cmd ::= ALTER TABLE fullname ADD column_keyword column. column_keyword ::= . column_keyword ::= COLUMNKW. No parents No children |
H43810 |
The SQLite parser shall accept INSERT statements that
conform to the following syntax:
cmd ::= insert_cmd INTO fullname columnlist_opt insert_content. insert_cmd ::= INSERT. insert_cmd ::= REPLACE. insert_cmd ::= INSERT OR REPLACE. insert_cmd ::= INSERT OR IGNORE. insert_cmd ::= INSERT OR ABORT. insert_cmd ::= INSERT OR FAIL. insert_cmd ::= INSERT OR ROLLBACK. columnlist_opt ::= . columnlist_opt ::= LP columnlist RP. columnlist ::= columnname. columnlist ::= columnlist COMMA columnname. No parents No children |
H43813 |
The preparation of an INSERT statement shall fail with an error
if the instcolist contains a reference to a column which
is not a column in the table identified by fullname and is
not one of the special column named "ROWID", "OID", or "_ROWID_".
No parents No children |
H43816 |
The preparation of an INSERT statement shall fail with an error
if fullname does not identify either a view with an
INSTEAD OF INSERT trigger or a table.
No parents No children |
H43819 |
The preparation of an INSERT statement shall fail with an error
if the objectname of the fullname is "sqlite_master"
or "sqlite_temp_master" and the database connection is not in
writeable schema mode.
No parents No children |
H43821 |
When the form of an INSERT statement is simply "INSERT" then the
default null- and uniqueness-conflict resolution algorithms shall
be used.
No parents No children |
H43824 |
When the form of an INSERT statement is simply "REPLACE" then the
null- and uniqueness-conflict resolution algorithms shall all
change to REPLACE.
No parents No children |
H43827 |
When the form of an INSERT statement is "INSERT OR algorithm"
then the null- and uniqueness-conflict resolution algorithms shall all
change to algorithm.
No parents No children |
H43831 |
Name resolution in the insert_content term of an INSERT statement
shall be carried out using a name context
with an empty result set and a source set holding
single source element that is the fullname table.
No parents No children |
H43840 |
The SQLite parser shall accept INSERT VALUE statements that
conform to the following syntax:
insert_content ::= VALUES LP exprlist RP. No parents No children |
H43843 |
The preparation of an INSERT VALUE statement shall fail with an
error if the columnlist element exists and the number of
entries in the instcollist is different
from the number of entries in the exprlist.
No parents No children |
H43846 |
The preparation of an INSERT VALUE statement shall fail with an
error if the columnlist element does not exists and the number of
entries in the exprlist is different
from the number of columns in the table or view identified by
fullname.
No parents No children |
H43890 |
The SQLite parser shall accept INSERT DEFAULT statements that
conform to the following syntax:
insert_contents ::= DEFAULT VALUES. No parents No children |
H43900 |
The SQLite parser shall accept DELETE statements that
conform to the following syntax:
cmd ::= DELETE FROM fullname where. where ::= . where ::= WHERE expr. No parents No children |
H43904 |
The preparation of a DELETE statement shall fail with an error if
the fullname element does not identify a view with an
INSTEAD OF DELETE trigger or a table.
No parents No children |
H43907 |
The preparation of a DELETE statement shall fail with an error if
the objectname of the fullname element is "sqlite_master"
or "sqlite_temp_master" and the database connection is not in
writeable_schema mode.
No parents No children |
H43911 |
Name resolution in the where term of a DELETE statement
shall be carried out using a name context
with an empty result set and a source set holding
single source element that is the fullname table.
No parents No children |
H44100 |
The SQLite parser shall accept UPDATE statements that
conform to the following syntax:
cmd ::= update_cmd fullname SET setlist where. update_cmd ::= UPDATE. update_cmd ::= UPDATE OR IGNORE. update_cmd ::= UPDATE OR REPLACE. update_cmd ::= UPDATE OR ABORT. update_cmd ::= UPDATE OR FAIL. update_cmd ::= UPDATE OR ROLLBACK. setlist ::= setting. setlist ::= setlist COMMA setting. setting ::= columnname EQ expr. No parents No children |
H44113 |
The preparation of an UPDATE statement shall fail with an error
if any columnname
is not a column in the table identified by fullname and is
not one of the special columns named "ROWID", "OID", or "_ROWID_".
No parents No children |
H44116 |
The preparation of an UPDATE statement shall fail with an error
if fullname does not identify either a view with an
INSTEAD OF UPDATE trigger that covers all columnnames or a table.
No parents No children |
H44119 |
The preparation of an UPDATE statement shall fail with an error
if the objectname of the fullname is "sqlite_master"
or "sqlite_temp_master" and the database connection is not in
writeable schema mode.
No parents No children |
H44121 |
When the form of an UPDATE statement is simply "UPDATE" then the
default null- and uniqueness-conflict resolution algorithms shall
be used.
No parents No children |
H44127 |
When the form of an UPDATE statement is "UPDATE OR algorithm"
then the null- and uniqueness-conflict resolution algorithms shall all
change to algorithm.
No parents No children |
H44131 |
Name resolution in the where term of a DELETE statement
shall be carried out using a name context
with an empty result set and a source set holding
single source element that is the fullname table.
No parents No children |
H44200 |
The SQLite parser shall accept VACUUM statements that
conform to the following syntax:
cmd ::= VACUUM. cmd ::= VACUUM name. No parents No children |
H44300 |
The SQLite parser shall accept ANALYZE statements
that conform to the following syntax:
cmd ::= ANALYZE. cmd ::= ANALYZE fullname. No parents No children |
H44303 |
The preparation of an ANALYZE statement
shall fail with an error if
the fullname is included and does not evaluate to
either an individual table name or the name of a database.
No parents No children |
H44400 |
The SQLite parser shall accept REINDEX statements
that conform to the following syntax:
cmd ::= REINDEX. cmd ::= REINDEX fullname. No parents No children |
H44403 |
The preparation of an ANALYZE statement
shall fail with an error if
the fullname is included and does not evaluate to
either an individual table name or the name of a database
or the name of a collating sequence.
No parents No children |
H44500 |
cmd ::= ATTACH database_kw expr AS expr.
database_kw ::= .
database_kw ::= DATABASE.
No parents No children |
H44503 |
The expr terms of an ATTACH statement that are
identifiers shall be interpreted as string literals.
No parents No children |
H44506 |
The preparation of an ATTACH statement shall fail with an error
if either expr is not a constant expression.
No parents No children |
H44509 |
The preparation of an ATTACH statement shall fail with an error
if the second expr evaluates to the name of a database
that is already attached to the database connection.
No parents No children |
H44600 |
The SQLite parser shall accept DETACH statements
that conform to the following syntax:
cmd ::= DETACH database_kw expr. No parents No children |
H44603 |
The expr term of an DETACH statement that is an
identifier shall be interpreted as string literals.
No parents No children |
H44606 |
The preparation of an DETACH statement shall fail with an error
if the expr is not a constant expression.
No parents No children |
H44609 |
The preparation of an DETACH statement shall fail with an error
if the expr does not evaluate to the
name of an attached database other than "temp" or "main".
No parents No children |
H44700 |
The SQLite parser shall accept the EXPLAIN keyword as a prefix
to other valid SQL statements, as shown by the following syntax:
sql_statement ::= EXPLAIN cmd SEMI. No parents No children |
H44800 |
The SQLite parser shall accept EXPLAIN QUERY PLAY as a prefix
to other valid SQL statements, as shown by the following syntax:
sql_statement ::= EXPLAIN QUERY PLAN cmd SEMI. No parents No children |
H45000 |
The SQLite parser shall accept SELECT statements that
conform to the following syntax:
cmd ::= select. select ::= query. select ::= select UNION query. select ::= select UNION ALL query. select ::= select EXCEPT query. select ::= select INTERSECT query. query ::= SELECT distinct resultset from where groupby having orderby limit. distinct ::= . distinct ::= DISTINCT. groupby ::= . groupby ::= GROUP BY exprlist. having ::= . having ::= HAVING expr. orderby ::= . orderby ::= ORDER BY exprlist. limit ::=. limit ::= LIMIT expr. limit ::= LIMIT expr COMMA expr. limit ::= LIMIT expr OFFSET expr. resultset ::= result. resultset ::= resultset COMMA result. result ::= STAR. result ::= tablename DOT STAR. result ::= expr as. from ::= . from ::= FROM sourceset. sourceset ::= source. sourceset ::= sourceset joinop source. source ::= fullname as on using. source ::= LP select RP as on using. as ::= . as ::= AS name. as ::= identifier. on ::= . on ::= ON expr. using ::= . using ::= USING LP columnlist RP. joinop ::= COMMA. joinop ::= JOIN. joinop ::= JOIN_KW JOIN. joinop ::= JOIN_KW JOIN_KW JOIN. joinop ::= JOIN_KW JOIN_KW JOIN_KW JOIN. No parents No children |
H45003 |
The preparation of a statement containing a select
shall fail with an error if the select contains
two terms of the same compound query having a different number of columns
in their result sets.
No parents No children |
H45006 |
The preparation of a statement containing a select
shall fail with an error if the select contains a compound query that
has an ORDER BY, GROUP BY, HAVING, or LIMIT clause on any term of than
the right-most.
No parents No children |
H45009 |
The preparation of a statement containing a select
shall fail with an error if the select contains a compound query with
an ORDER BY or GROUP BY clause with a term that is not either
a token-by-token duplicate of the result columns of one of the
compound query terms, or the "AS" name of one of the compound
query terms, or a compile-time integer between 1 and N where N is
the number of columns in each compound query term.
No parents No children |
H45012 |
The preparation of a statement containing a select
shall fail with an error if the select contains a join with two
or more of the following properties:
No parents No children |
H45015 |
The preparation of a statement containing a select
shall fail with an error if the select contains a joinop
that uses the keywords RIGHT or FULL.
No parents No children |
H45018 |
The preparation of a statement containing a select
shall fail with an error if the select contains a joinop
that uses either of the keywords OUTER or LEFT
together with either INNER or CROSS.
No parents No children |
H45021 |
The preparation of a statement containing a select
shall fail with an error if the select contains a using
that names columns that are not found in both the table to the
immediate right of the join and in the result set of all tables
to the left of the join.
No parents No children |
H45024 |
The preparation of a statement containing a select
shall fail with an error if the fullname of a source
does not refer to an existing table or view.
No parents No children |
H45027 |
The preparation of a statement containing a limit
shall fail with an error if any expr within the limit
does not evaluate to a compile-time integer.
No parents No children |
H45103 |
Name resolution of a top-level SELECT statement shall use an
empty name context.
No parents No children |
H45106 |
Name context of a query term shall be
constructed by adding a new inner name context layer
to the name context of the construct containing the query
term.
No parents No children |
H45109 |
Name resolution of the resultset of a query shall
use the name context of the query with an empty result
set and the source set
configured to the from clause of the query.
No parents No children |
H45112 |
Name resolution of all child terms of a query other than
resultset child shall use the name context of the query
with the result set configured to be the resultset clause of the
query and with the source set configured to be the
from clause of the query.
No parents No children |
H46000 |
The SQLite parser shall accept PRAGMA statements
that conform to the following syntax:
cmd ::= PRAGMA fullname EQ DELETE. cmd ::= PRAGMA fullname EQ ON. cmd ::= PRAGMA fullname EQ name. cmd ::= PRAGMA fullname EQ expr. cmd ::= PRAGMA fullname LP name RP. cmd ::= PRAGMA fullname LP expr RP. cmd ::= PRAGMA fullname. No parents No children |
H46003 |
The evaluation of a PRAGMA statement with an unknown verb shall
be a silent no-op.
No parents No children |
H47000 |
The SQLite parser shall accept expressions that
conform to the following syntax:
expr ::= BITNOT expr. expr ::= CASE case_operand case_exprlist case_else END. expr ::= CAST LP expr AS typetoken RP. expr ::= EXISTS LP select RP. expr ::= function_name LP STAR RP. expr ::= function_name LP distinct exprlist RP. expr ::= LP expr RP. expr ::= LP select RP. expr ::= MINUS expr. expr ::= NOT expr. expr ::= PLUS expr. expr ::= RAISE LP IGNORE RP. expr ::= RAISE LP ABORT COMMA name RP. expr ::= RAISE LP FAIL COMMA name RP. expr ::= RAISE LP ROLLBACK COMMA name RP. expr ::= VARIABLE. expr ::= expr AND expr. expr ::= expr BITAND expr. expr ::= expr BITOR expr. expr ::= expr LSHIFT expr. expr ::= expr RSHIFT expr. expr ::= expr COLLATE ids. expr ::= expr CONCAT expr. expr ::= expr EQ expr. expr ::= expr NE expr. expr ::= expr IS NOT NULL. expr ::= expr IS NULL. expr ::= expr ISNULL expr ::= expr NOTNULL. expr ::= expr LT expr. expr ::= expr GT expr. expr ::= expr GE expr. expr ::= expr LE expr. expr ::= expr NOT NULL. expr ::= expr OR expr. expr ::= expr PLUS expr. expr ::= expr MINUS expr. expr ::= expr STAR expr. expr ::= expr SLASH expr. expr ::= expr REM expr. expr ::= expr BETWEEN expr AND expr. expr ::= expr NOT BETWEEN expr AND expr. expr ::= expr IN LP exprlist RP. expr ::= expr IN LP select RP. expr ::= expr IN fullname. expr ::= expr NOT IN LP exprlist RP. expr ::= expr NOT IN LP select RP. expr ::= expr NOT IN fullname. expr ::= expr LIKE_KW expr escape. expr ::= expr MATCH expr escape. expr ::= expr NOT LIKE_KW expr escape. expr ::= expr NOT MATCH expr escape. expr ::= rtvalue. expr ::= term. term ::= CTIME_KW. term ::= INTEGER. term ::= FLOAT term ::= BLOB. term ::= NULL. term ::= STRING. exprlist ::= expr. exprlist ::= exprlist COMMA expr. case_else ::= ELSE expr. case_else ::= . case_exprlist ::= WHEN expr THEN expr. case_exprlist ::= case_exprlist WHEN expr THEN expr. case_operand ::= expr. case_operand ::= . function_name ::= ID. escape ::= . escape ::= ESCAPE expr. No parents No children |
H47003 |
The unary PLUS, unary MINUS, and BITNOT operators shall have
precedence over the COLLATE operator.
No parents No children |
H47006 |
The COLLATE operator shall have precedence over the CONCAT
operator.
No parents No children |
H47009 |
The CONCAT operator shall have precedence over the STAR, SLASH,
and REM operators.
No parents No children |
H47012 |
The STAR, SLASH, and REM operator shall have equal precedence.
No parents No children |
H47015 |
The STAR, SLASH, and REM operators shall have precedence over the
binary PLUS and binary MINUS operators.
No parents No children |
H47018 |
The binary PLUS and binary MINUS operators shall have equal precedence.
No parents No children |
H47021 |
The binary PLUS and binary MINUS operators shall have precedence
over the BITAND, BITOR, LSHIFT, and RSHIFT operators.
No parents No children |
H47024 |
The BITAND, BITOR, LSHIFT, and RSHIFT operators shall have equal
precendence.
No parents No children |
H47027 |
The BITAND, BITOR, LSHIFT, and RSHIFT operators shall have precedence
over the ESCAPE operator.
No parents No children |
H47029 |
The ESCAPE operator shall have precedence over
the GT, LE, LT, and GE operators.
No parents No children |
H47033 |
The GT, LE, LT, and GE operators shall have equal precedence.
No parents No children |
H47036 |
The GT, LE, LT, and GE operators shall have precedence over
the IS, MATCH, LIKE_KW, BETWEEN, IN, ISNULL, NOTNULL, NE, and EQ
operators shall have equal precedence.
No parents No children |
H47039 |
The IS, MATCH, LIKE_KW, BETWEEN, IN, ISNULL, NOTNULL, NE, and EQ
operators shall have equal precedence.
No parents No children |
H47042 |
The IS, MATCH, LIKE_KW, BETWEEN, IN, ISNULL, NOTNULL, NE, and EQ
operators shall have precedence over the unary NOT operator.
No parents No children |
H47045 |
The unary NOT operator shall have precedence over the AND operator.
No parents No children |
H47048 |
The AND operator shall have precedence over the OR operator.
No parents No children |
H47051 |
Operators of equal precedence shall group from right to left.
No parents No children |
H49100 |
The SQLite parser shall accept names, fullnames, and identifiers
that conform to the following syntax:
name ::= ID. name ::= JOIN_KW. name ::= STRING. fullname ::= objectname. fullname ::= databasename DOT objectname. objectname ::= name. databasename ::= name. columnname ::= name. identifier ::= ID. identifier ::= STRING. No parents No children |
H49103 |
The SQLite parser shall accept rtvalue elements of an
expr that conform to the following syntax:
rtvalue ::= databasename DOT tablename DOT columnname. rtvalue ::= tablename DOT columnname. rtvalue ::= ID. rtvalue ::= JOIN_KW. No parents No children |