Lines Matching refs:using
185 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
413 ** that we have taken it all out and gone back to using simple
490 ** using an edited copy of [the amalgamation], then the last four characters
556 ** can be fully or partially disabled using a call to [sqlite3_config()]
800 ** on a per database connection basis using the
802 ** the most recent error can be obtained using
897 ** to be opened using O_EXCL. Passing SQLITE_OPEN_EXCLUSIVE into
1085 ** VFS implementations to directly control an open file using the
1358 ** temporary filename using the same algorithm that is followed to generate
1453 ** obtain a file lock using the xLock or xShmLock methods of the VFS.
1569 ** Mutexes are created using [sqlite3_mutex_alloc()].
1882 ** shutdown on embedded systems. Workstation applications using
1920 ** prior to using any other SQLite interface. For maximum portability,
1922 ** directly prior to using any other SQLite interface. Future releases
1933 ** a default configuration using [sqlite3_config()].
1943 ** (using the [SQLITE_OS_OTHER=1] compile-time
1969 ** may only be invoked prior to library initialization using
2192 ** cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2].
2199 ** can be determined using [SQLITE_CONFIG_PCACHE_HDRSZ].
2228 ** to using its default memory allocator (the system malloc() implementation),
2349 ** third parameter is passed NULL In this case. An example of using this
2358 ** ^The default setting can be overridden by each database connection using
2359 ** either the [PRAGMA mmap_size] command, or by using the
2389 ** is enabled (using the [PRAGMA threads] command) and the amount of content
2427 ** database created using [sqlite3_deserialize()]. This default maximum
2428 ** size can be adjusted up or down for individual databases using the
2487 ** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the
2495 ** connection is not currently using lookaside memory, or in other words
2683 ** using the [PRAGMA legacy_alter_table] statement.
2721 ** can also be controlled using the [PRAGMA trusted_schema] statement.
2809 ** rowid value using [sqlite3_set_last_insert_rowid()] before returning
3014 ** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
3106 ** was defined (using [sqlite3_busy_handler()]) prior to calling
3138 ** A result table should be deallocated using [sqlite3_free_table()].
3313 ** a block of memory after it has been released using
3363 ** seeded using randomness obtained from the xRandomness method of
3436 ** might also consider lowering resource limits using [sqlite3_limit()]
3437 ** and limiting database size using the [max_page_count] [PRAGMA]
3438 ** in addition to using an authorizer.
3579 ** using the [sqlite3_trace_v2()] tracing logic. The M argument
3602 ** interface by using the X argument when X begins with "--" and invoking
3636 ** function X against [database connection] D, using property mask M
3718 ** ^The default encoding will be UTF-8 for databases created using
3720 ** created using sqlite3_open16() will be UTF-16 in the native byte order.
3764 ** to use SQLite at the same time, as long as each thread is using
3835 ** been enabled globally using the [SQLITE_CONFIG_URI] option with the
3957 ** URI filename are interpreted, they are encoded using UTF-8 and all
4002 ** <li> A new filename constructed using [sqlite3_create_filename()].
4151 ** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y,
4246 ** <li> Create the prepared statement object using [sqlite3_prepare_v2()].
4247 ** <li> Bind values to [parameters] using the sqlite3_bind_*()
4250 ** <li> Reset the prepared statement using [sqlite3_reset()] then go back
4252 ** <li> Destroy the object using [sqlite3_finalize()].
4292 ** created by an untrusted script can be contained using the
4304 ** that can be lowered at run-time using [sqlite3_limit()].
4383 ** be used just once or at most a few times and then destroyed using
4414 ** program using one of these routines. Or, in other words, these routines
4423 ** does all parsing using UTF-8. The UTF-16 interfaces are provided
4452 ** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set
4456 ** SQL statement using [sqlite3_finalize()] after it has finished with it.
4569 ** ^(For example, if a prepared statement is created using the SQL
4665 ** [prepared statement] S has been stepped at least once using
4668 ** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S)
4760 ** can be set using the sqlite3_bind_*() routines defined here.
4770 ** ^The index for named parameters can be looked up using the
4845 ** content is later written using
4853 ** destructor D with a single argument of P when it is finished using
4953 ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or
5030 ** using [sqlite3_finalize()] or until the statement is automatically
5104 ** After a [prepared statement] has been prepared using any of
5111 ** on whether the statement was prepared using the newer "vX" interfaces
5137 ** caller. The values may be accessed using the [column access functions].
5159 ** sqlite3_step(). Failure to reset the prepared statement using
5176 ** using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()]
5273 ** ^The number of columns in the result can be determined using
5498 ** ^Any SQL statement variables that had values bound to them using
5561 ** otherwise. ^The same SQL function may be registered multiple times using
5591 ** function can gain access to this pointer using [sqlite3_user_data()].)^
5747 ** are innocuous. Developers are advised to avoid using the
5843 ** using [sqlite3_bind_pointer(S,I,P,X,D)] or [sqlite3_result_pointer(C,P,X,D)]
6157 ** interprets the string from sqlite3_result_error16() as UTF-16 using
6217 ** finished using that result.
6222 ** when it has finished using that result.
6261 ** [application-defined SQL function] using [sqlite3_value_pointer()].
6342 ** ^Multiple collating functions can be registered using the same name but
6357 ** to the same collation name (using different eTextRep values) then all
6378 ** [database connection] is closed using [sqlite3_close()].
6423 ** ^If the function is registered using the sqlite3_collation_needed() API,
6437 ** The callback function should register the desired collation using
6524 ** created by SQLite when using a built-in [sqlite3_vfs | VFS]
6529 ** Applications are strongly discouraged from using this global variable.
6550 ** using [sqlite3_free].
6563 ** example of how to do this using C++ with the Windows Runtime:
6583 ** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed
6607 ** using [sqlite3_free].
6963 ** invoked when rows are deleted using the [truncate optimization].
7019 ** individual database connections using the [sqlite3_open_v2()] interface
7107 ** The memory allocation limits can also be adjusted using
7115 ** <li> Memory accounting is disabled using a combination of the
7118 ** <li> An alternative page cache implementation is specified using
7165 ** for the table using the same algorithm used by the database engine to
7253 ** ^Extension loading must be enabled using
7295 ** be enabled using the [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method
7344 ** initialization routine X that was registered using a prior call to
7356 ** registered using [sqlite3_auto_extension()].
7447 ** stored in aConstraint[].op using one of the
7485 ** not be checked again using byte code.)^
7554 int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */
7556 double estimatedCost; /* Estimated cost of using this index */
7595 ** The right-hand operands for each constraint might be accessible using
7606 ** The collating sequence to be used for comparison can be found using
7636 ** creating a new [virtual table] using the module and before using a
7725 ** to loop through the virtual table. Cursors are created using the
7755 ** using the [xFindFunction] method of the [virtual table module].
7842 ** A BLOB referenced by sqlite3_blob_open() may be read using the
7843 ** [sqlite3_blob_read()] interface and modified by using
7845 ** different row of the same table using the [sqlite3_blob_reopen()]
7867 ** zero-filled blob to read or write using the incremental-blob interface.
7962 ** can be determined using the [sqlite3_blob_bytes()] interface.
7998 ** not possible to increase the size of a BLOB using this API.
8002 ** using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less
8082 ** application must supply a custom mutex implementation using the
8144 ** upon successful entry. ^(Mutexes created using
8188 ** implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
8276 ** using mutexes. And we do not want the assert() containing the
8339 ** databases that are added using the [ATTACH] SQL command.
8465 ** using keywords as identifiers. Common techniques used to avoid keyword
8496 ** <li> ^The sqlite3_str object is created using [sqlite3_str_new()].
8497 ** <li> ^Text is appended to the sqlite3_str object using various
8500 ** is returned using the [sqlite3_str_finish()] interface.
8664 ** using [sqlite3_malloc()], either directly or indirectly. The
8684 ** [pagecache memory allocator] that was configured using
8777 ** satisfied using lookaside memory. Only the high-water value is meaningful;
8783 ** been satisfied using lookaside memory but failed due to the amount of
8791 ** been satisfied using lookaside memory but failed due to all lookaside
8894 ** that the prepared statement is using a full table scan rather than
9024 ** custom page cache using this API, an application can better control
9091 ** instance passed as the first argument. This is the value configured using
9110 ** is 1. After it has been retrieved using xFetch, the page is considered
9276 ** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or
9302 ** <li> the destination database is using write-ahead-log journaling
9337 ** database is modified by the using the same database connection as is used
9468 ** connection using [sqlite3_close()].
9499 ** action (a reasonable assumption), then using this API may cause the
9548 ** strings in a case-independent fashion, using the same definition of "case
9671 ** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback
9672 ** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism
10170 ** of the IN constraint using code like the following:
10324 ** available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS]
10400 ** ^These interfaces are only available if SQLite is compiled using the
10480 ** callback made with op==SQLITE_DELETE is actuall a write using the
10583 ** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()]
10650 ** using this routine to avoid a memory leak.
10732 ** is currently using for that database, or NULL if the no such contiguous
10762 ** a pointer to contiguous in-memory database that it is currently using,
10763 ** without making a copy of the database. If SQLite is not currently using
10766 ** using a contiguous in-memory database if it has been initialized by a
10786 ** SQLite will try to increase the buffer size using sqlite3_realloc64()
10822 ** free it when it has finished using it. Without this flag, the caller
10826 ** grow the size of the database using calls to [sqlite3_realloc64()]. This
10835 #define SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */
10901 ** argument to callbacks registered using rtree_geometry_callback().
10928 ** argument to scored geometry callback registered using
11011 ** Session objects created using this function should be deleted using the
11040 ** Delete a session object previously allocated using
11247 ** The contents of a changeset may be traversed using an iterator created
11248 ** using the [sqlite3changeset_start()] API. A changeset may be applied to
11249 ** a database with a compatible schema using the [sqlite3changeset_apply()]
11261 ** the caller to eventually free the buffer that *ppChangeset points to using
11283 ** When this function is called, the requested changeset is created using
11333 ** to enable this API using sqlite3session_object_config() with the
11387 ** using [sqlite3session_changeset()], then after applying that changeset to
11397 ** message. It is the responsibility of the caller to free this buffer using
11496 ** an application iterates through a changeset using an iterator created by
11529 ** inverting a changeset using sqlite3changeset_invert() before applying it.
11749 ** This function should only be called on iterators created using the
11814 ** This function combines the two input changesets using an
11862 ** should eventually free the returned object using a call to
11869 ** <li> It is created using a call to sqlite3changegroup_new().
11877 ** <li> The object is deleted using a call to sqlite3changegroup_delete().
11989 ** responsibility of the caller to eventually free the buffer using a
12150 ** caller to eventually free any such buffer using sqlite3_free(). The buffer
12213 ** a changeset using sqlite3changeset_invert() before applying it. It is
12363 ** from the update change are filled in using the old.* values from
12368 ** the old.* values are rebased using the new.* values in the remote
12396 ** be applied to the local database using sqlite3changeset_apply_v2() and
12450 ** responsibility of the caller to eventually free the new buffer using
12490 ** a pointer to a single large buffer allocated using sqlite3_malloc().
12825 ** Tokenize text using the tokenizer belonging to the FTS5 table.
12857 ** the same MATCH query using the xGetAuxdata() API.
12948 ** The information accessed using this API and its companion
12949 ** xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext
13028 ** allocated using xCreate(). Fts5 guarantees that this function will
13096 ** <ol><li> By mapping all synonyms to a single token. In this case, using
13186 ** When using methods (2) or (3), it is important that the tokenizer only
13280 ** Include the configuration header output by 'configure' if we're using the
13392 ** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options.
13409 ** counted using a signed 8-bit integer which has a maximum value of 127
13475 ** This value can be lowered (or raised) at run-time using that the
13626 ** Powersafe overwrite is on by default. But can be turned off using
13846 ** compiled using SQLITE_TEST).
13912 ** directly. Change this structure only by using the routines below.
14238 ** changed at run-time using a pragma.
14273 ** The default initial allocation for the pagecache when using separate
14474 ** using C-preprocessor macros. If that is unsuccessful, or if
14656 ** in support of (2). Names are translated using sqlite3PreferredTableName()
15000 ** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line.
15003 ** Mcafee started using SQLite in their anti-virus product and it
15078 ** using the same locking range we are at least open to the possibility.
15156 ** Convenience functions for opening and closing files using
15189 ** value means no limit. This value may be overridden using the
15448 ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
15561 ** SQLite database header may be found using the following formula:
15724 ** run a little faster by using fewer registers for parameter passing.
15796 ** If we are not using shared cache, then there is no need to
16852 ** using the sqlite3_limit() interface.
16897 ** lookaside slots are available while also using less memory.
17053 unsigned reopenMemdb : 1; /* ATTACH is really a reopen using MemDB */
17084 void (*xPreUpdateCallback)( /* Registered using sqlite3_preupdate_hook() */
17215 /* the count using a callback. */
17248 #define SQLITE_DistinctOpt 0x00000010 /* DISTINCT using indexes */
17325 ** configured using create_function_v2()) and a reference counter. When
17720 ** next time a statement is prepared using said sqlite3*. This is done
17727 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
17767 LogEst costMult; /* Cost multiplier for using this table */
18128 #define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */
18147 ** using a structure of this type. See documentation at the top of the
18905 ** SRT_Output Generate a row of output (using the OP_ResultRow
19180 ** using offsetof(Parse,sLastToken) so the sLastToken field must be the
19301 ** 2. All triggers associated with a single table form a linked list, using the
19339 ** using the "pNext" member) referenced by the "step_list" member of the
19449 /* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled
19450 ** on debug-builds of the CLI using ".testctrl tune ID VALUE". Tuning
19514 ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
19548 ** For most test cases, CORRUPT_DB is set to false using a special
19668 ** The CteUse objects are freed using sqlite3ParserAddCleanup() rather
19685 ** data structures on sqlite3DebugPrintf() using a tree-like view.
19785 ** using sqlite3_log(). The routines also provide a convenient place
19820 ** FTS4 is really an extension for FTS3. It is enabled using the
21216 ** Include the configuration header output by 'configure' if we're using the
22095 ** The equivalent of tolower() is implemented using the sqlite3UpperToLower[]
22146 ** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options.
22171 # error "Compile-time disabling of covering index scan using the\
22201 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
22202 ** or at run-time for an individual database connection using
22208 ** using the older 1200,100 configuration without two-size-lookaside.
22219 /* The default maximum size of an in-memory database created using
22656 ** MEM_Subtype pointer accessible using
22660 ** to other NULLs even using the IS operator.
22683 ** For a pointer type created using sqlite3_bind_pointer() or
24005 ** using whatever operating-system specific localtime facility that
24908 ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
24942 ** of this would be completely automatic if SQLite were coded using
25001 ** is using a regular VFS, it is called after the corresponding
25419 ** are merely placeholders. Real drivers must be substituted using
25426 ** used when no other memory allocator is specified using compile-time
25497 ** a different name, using a separate -D
25513 ** used when no other memory allocator is specified using compile-time
25587 ** so that we can find it later using sqlite3MemSize().
26098 ** higher level code is using pointer to the old allocation, it is
26741 /* Try to expand the key using the newly freed chunk */
27619 ** that has been configured using sqlite3MutexWarnOnContention(), it is
27950 ** mutex routines at start-time using the
28089 ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
28179 ** are necessary under two condidtions: (1) Debug builds and (2) using
28395 ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
28605 ** Windows NT using the _WIN32_WINNT macro as follows:
28652 ** functions are not available (e.g. those not using MSVC, Cygwin, etc).
28917 ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
29645 ** slower case when the allocation cannot be fulfilled using lookaside.
29858 ** Always return a NULL pointer so that this routine can be invoked using
30116 ** SQL from requesting large allocations using the precision or width
30975 ** work (enlarging the buffer) using tail recursion, so that the
31066 /* Finalize a string created using sqlite3_str_new().
31257 ** We house it in a separate routine from sqlite3_log() to avoid using
32800 ** A "thread" can be created using sqlite3ThreadCreate(). This thread
32801 ** runs independently of its creator until it is joined using
33631 ** During testing, if the test harness has set a fault-sim callback using
33783 ** stored by this function into the database handle using sqlite3Error().
33912 ** case-independent fashion, using the same definition of "case
36132 ** base-26 number using a..z. "a" means 0. "b" means 1,
36149 ** base-26 number using a..z as the digits. So one zero is "b".
37158 ** The difference is important when using a pointer to the function.
37466 ** opening database file using file descriptors that are commonly used for
37851 ** that it overrides locks set by the same process using a different
38029 ** set. It logs a message using sqlite3_log() containing the current value of
38428 ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
38561 /* If some thread using this PID has a lock via a different unixFile*
38571 /* If a SHARED lock is requested, and some thread using this PID already
38852 /* Decrement the shared lock counter. Release the lock using an
39783 /* If some thread using this PID has a lock via a different unixFile*
39793 /* If a SHARED lock is requested, and some thread using this PID already
39998 /* Decrement the shared lock counter. Release the lock using an
40189 ** data from the memory mapping using memcpy(). */
40347 ** data from the memory mapping using memcpy(). */
40541 ** This routine can be overridden using the xSetSysCall interface.
40550 ** the file descriptor *pFd using close().
40664 ** when restoring a database using the backup API from a zero-length
41458 ** database to end up using different files for shared memory -
41461 ** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
41473 ** If the original database file (pDbFd) is using the "unix-excl" VFS
42042 ** continue accessing the database using the xRead() and xWrite()
42113 ** will probably fail too. Fall back to using xRead/xWrite exclusively
42131 ** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller.
42461 ** Test byte-range lock using fcntl(). If the call succeeds,
42761 ** using the io-error infrastructure to test that SQLite handles this
42890 ** an indication to robust_open() to create the file using
42895 ** possible, WAL and journal files are created using the same permissions
42949 /* If this is a main database file and the file was opened using a URI
42979 ** file handle closed. To achieve the same effect using this new
43448 ** using the io-error infrastructure to test that SQLite handles this
43852 ** named automatically using the same logic as
45102 ** Compiling and using WAL mode requires several APIs that are only
45170 ** target system. It is unavailable when using "mincore.lib" on Win10.
45405 * function), all data that was allocated using the isolated heap will
46797 ** Convert an ANSI string to Microsoft Unicode, using the ANSI or OEM
46827 ** using the ANSI or OEM code page.
47148 ** It logs a message using sqlite3_log() containing the current value of
47361 ** and using that as the shared filemapping name.
47816 ** data from the memory mapping using memcpy(). */
47894 ** data from the memory mapping using memcpy(). */
48363 ** If you are using this code as a model for alternative VFSes, do not
49482 ** using SQLITE_FCNTL_MMAP_SIZE, whichever is smaller.
49541 /* Log the error, but continue normal operation using xRead/xWrite */
49559 /* Log the error, but continue normal operation using xRead/xWrite */
49828 ** using the io-error infrastructure to test that SQLite handles this
49894 ** prior to using it.
50616 ** using the GetFullPathName Win32 API function (if available).
50752 ** using the io-error infrastructure to test that SQLite handles this
51105 ** by sqlite into the error message available to the user using
51314 ** using "file:/name?vfs=memdb". The first character of the name must be
51318 ** Separate memdb objects are created using a name that does not begin
51319 ** with "/" or using sqlite3_deserialize().
52635 ** All dirty pages are linked into the doubly linked list using
52757 ** for example, when using the sqlite3PagerDontWrite() optimization:
53571 ** runtime using sqlite3_config(SQLITE_CONFIG_PCACHE_HDRSZ, &size). The
53595 ** (2) Global page-cache memory provided using sqlite3_config() with
53601 ** bulk allocation can be adjusted using
53605 ** If N is positive, then N pages worth of memory are allocated using a single
53741 ** buffer provided using the SQLITE_CONFIG_PAGECACHE mechanism.
53871 ** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no
54022 ** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer
54042 ** If memory was allocated specifically to the page cache using
54245 ** configured a start-time buffer for use as page-cache memory using
54703 ** Destroy a cache allocated using pcache1Create().
54873 ** The cost of a TEST using the same batch number is O(logN). The cost
54928 struct RowSetEntry *pEntry; /* List of entries using pRight */
55471 /* Return true if the argument is non-NULL and the WAL module is using
55473 ** WAL module is using shared-memory, return false.
55509 ** This comment block describes invariants that hold when using a rollback
55917 ** resized using sqlite3Realloc().
56058 ** Similarly, if the database is truncated using PagerTruncateImage(),
56285 ** interfaces to access the database using memory-mapped I/O.
56743 ** on the cache using a hash function. This is used for testing
57499 ** The journal file is closed and deleted using sqlite3OsDelete().
57577 ** the database file, it will do so using an in-memory journal.
57956 ** populated, then moved using sqlite3PagerMovepage().
58035 ** the file-system using sqlite3OsDelete().
59113 ** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
59436 ** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
60358 ** filename without using the sqlite3_filename_database() API. This is a
60640 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
61043 ** point in the future, using a call to sqlite3PagerWrite(), its contents
61427 ** or using a temporary file otherwise.
61821 ** by writing an updated version of page 1 using a call to the
62219 ** using persistent journals, then this function is a no-op.
62289 /* This can happen using journal_mode=off. Move the pager to the error
62429 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
63431 ** The checksum is computed using 32-bit big-endian integers if the
63433 ** is computed using little-endian if the magic number is 0x377f0682.
63445 ** Note that s0 and s1 are both weighted checksums using fibonacci weights
63491 ** might choose to implement the wal-index using a mmapped file. Because
63546 ** Even without using the hash table, the last frame for page P
63595 ** reader might be using some value K0 and a second reader that started
63597 ** and to the wal-index) might be using a different value K1, where K1>K0.
63604 ** second reader using K1 will see additional values that were inserted
63730 ** aReadMark[K] cannot changed while there is a reader is using that mark
63747 ** written back into the database) and if no readers are using the WAL
65045 ** Sort the elements in list aList using aContent[] as the sort key.
65373 ** that a concurrent reader might be using.
65542 ** until all readers have finished using the wal file. This ensures that
65614 /* If an EXCLUSIVE lock can be obtained on the database file (using the
65865 ** constructed in pWal->apWiData[] using heap memory instead of shared
66460 /* A client using a non-current snapshot may not ignore any frames
66584 ** result obtained using the hash indexes above. */
66822 /* If all readers are using WAL_READ_LOCK(0) (in other words if no
66823 ** readers are currently using the WAL), then the transactions
66979 ** on the log file (obtained using sqlite3WalBeginWriteTransaction()).
67427 ** Return true if the argument is non-NULL and the WAL module is using
67429 ** WAL module is using shared-memory, return false.
67578 ** This file implements an external (disk-based) database using BTrees.
67993 sqlite3 *db; /* Database connection currently using this Btree */
68532 ** db using sqlite3SchemaToIndex().
68606 ** This file implements an external (disk-based) database using BTrees.
68619 ** Set this global variable to 1 to enable tracing using the TRACE
68988 ** obtain a read-lock using this function. The only read-lock obtained
70144 ** two (or one) blocks of cells using memmove() and add the required
70314 ** all the space together, however. This routine will avoid using
70377 /* The request could not be fulfilled using a freelist slot. Check
70953 ** Page1 is a special case and must be released using releasePageOne().
71538 ** using mxPage of 0 is a way to query the current spill size.
71774 ** using "PRAGMA synchronous", and if the safety-level is not already
73057 ** using the sqlite3BtreeSavepoint() function.
73069 ** an index greater than all savepoints created explicitly using
73476 /* Try to find the next page in the overflow list using the
74230 ** try to get there using sqlite3BtreeNext() rather than a full
74347 ** pointing to to pIdxKey using xRecordCompare. Return negative or
75291 ** avoid using the last six entries in the freelist trunk page array in
75395 ** caller is iterating through or using in some other way, this
76411 ** Before returning, page pTo is reinitialized using btreeInitPage().
77886 ** multiple records into an intkey b-tree using a single cursor (as can
79792 ** Once it has been created using backup_init(), a single sqlite3_backup
80563 ** only within the VDBE. Interface routines refer to a Mem using the
80601 ** case) or it is a pointer set using sqlite3_bind_pointer() or
80634 ** (2) Memory to be freed using Mem.xDel
80740 ** representation is already stored using the requested encoding, then this
81136 ** So we define our own static constants here using nothing
82095 ** using valueNew().
82397 ** Attempt to extract a value from expression pExpr using the methods
82737 ** fire after each opcode is inserted and displayed using
83054 ** that could cause problems if two or more co-routines are using the same
83525 ** having to malloc for more space (except when compiled using
83567 ** to arrange for the returned array to be eventually freed using the
83911 ** static array using sqlite3VdbeAddOpList but we want to make a
84569 ** with no indexes using a single prepared INSERT statement, bind()
85089 ** pass will fill in the remainder using a fresh memory allocation.
85298 ** that are candidates for a two-phase commit using a
85436 ** be "9" to avoid name collisions when using 8+3 filenames. */
86382 ** Developers using SQLite on an ARM7 should compile and run their
86383 ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
86394 ** the necessary byte swapping is carried out using a 64-bit integer
86567 ** The space is either allocated using sqlite3DbMallocRaw() or from within
86570 ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
86630 /* In a corrupt record entry, the last pMem might have been set up using
86643 ** this function deserializes and compares values using the
86730 /* No memory allocation is ever used on mem1. Prove this using
86789 ** using the collation sequence pColl. As usual, return a negative , zero
86969 ** If both are strings, compare using the collating functions.
86996 /* Both values must be blobs. Compare using memcmp(). */
87258 /* No memory allocation is ever used on mem1. Prove this using
87502 ** pCur points at an index entry created using the OP_MakeRecord opcode.
87682 ** The returned value must be freed by the caller using sqlite3ValueFree().
87772 ** structure itself, using sqlite3DbFree().
88521 /* If this statement was prepared using saved SQL and an
88622 /* If this statement was prepared using saved SQL and an
88637 ** statements prepared using the legacy sqlite3_prepare() interface */
88941 ** to all functions within the current prepared statement using iArg as an
89032 ** using gcc, we force nullMem to be 8-byte aligned using the magical
89182 ** Convert the N-th element of pStmt->pColName[] into a string using
90372 ** operation implemented using OP_FkIsZero is working. This variable
90503 /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
90526 ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
90999 ** Compute a bloom filter hash using pOp->p4.i registers from aMem[] beginning
91427 ** Check the value in register P3. If it is NULL then Halt using
91653 ** or that can be called using OP_Gosub. The subroutine should
91657 ** fall through. But if the subroutine is entered using OP_Gosub, then
91712 ** previously copied using OP_SCopy, the copies will continue to be valid.
93151 ** Interpret the data that cursor P1 points to as a structure built using
94338 ** are queried from within xNext() and other v-table methods using
94695 ** different name to distinguish its use. Tables created using
94779 ** tables using an external merge-sort algorithm.
94828 ** individual columns using the OP_Column opcode. The OP_Column opcode
94897 ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
94964 ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
95393 ** If cursor P1 is not open or if P1 is set to a NULL row using the
95469 ** In such a case, we abandon the IN clause search early, using this
96033 ** have been positioned using OP_NotFound prior to invoking this opcode in
96195 ** a register that is the source for a pseudo-table cursor created using
96641 ** Register P2 holds an SQL index key made using the
96699 ** Register P2 holds an SQL index key made using the
96998 ** that is used to store tables create using CREATE TEMPORARY TABLE.
97059 ** that is used to store tables create using CREATE TEMPORARY TABLE.
97253 ** is dropped from disk (using the Destroy opcode) in order to keep
97267 ** is dropped from disk (using the Destroy opcode)
97281 ** is dropped from disk (using the Destroy opcode) in order to keep
97458 ** exception using the RAISE() function. Register P3 contains the address
98192 ** is executed using sqlite3_step() it will either automatically
98193 ** reprepare itself (if it was originally created using sqlite3_prepare_v2())
98421 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
98754 ** whether meta data associated with a user function argument using the
98773 ** whether meta data associated with a user function argument using the
98782 ** to see if they were called using OP_PureFunc instead of OP_Function, and
98960 ** using the X argument when X begins with "--" and invoking
99070 ** that if the content of the released register was set using OP_SCopy,
99304 ** responsibility of the caller to free the error message buffer using
99508 ** db/table/row entry. The reason for using a vdbe program instead
99611 ** Close a blob handle that was previously created using
99679 ** using the incremental-blob API, this works. For the sessions module
99791 ** using indexes and without LIMIT clauses.
99849 ** a threshold, when Rewind() is called the set of records is sorted using
99958 ** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects
99960 ** are connected using SorterRecord.u.iNext.
99970 ** one big PMA using a merge operation. Separate PMAs all need to be
100166 ** at offset iStartOff of file pTask->file2. And instead of using a
100205 ** by this module. If using a separate allocation for each in-memory record
100206 ** (VdbeSorter.list.aMemory==0), then the list is always connected using the
100209 ** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0),
100210 ** then while records are being accumulated the list is linked using the
100639 /* The two values have the same sign. Compare using memcmp(). */
101277 ** The results of using the PMA-writer after this call are undefined.
101471 ** using a background thread.
101492 ** fall back to using the final sub-task. The first (pSorter->nTask-1)
101571 ** If using the single large allocation mode (pSorter->aMemory!=0), then
101575 ** Or, if using separate allocations for each record, flush the contents
101771 SortSubtask *pTask, /* The thread that will be using the new IncrMerger */
101960 ** child-trees have already been initialized using IncrInit(INCRINIT_TASK).
102052 ** using the current thread.
102319 ** b) If it is using task (nTask-1), it is configured to run
102321 ** root merge (INCRINIT_ROOT) will be using the same task
103183 ** the in-memory journal is being used by a connection using the
103318 ** accessed using the underlying VFS. If nSpill is less than zero, then
103337 ** it using the sqlite3OsOpen() function of the underlying VFS. In this
103961 ** using SQLITE_DBCONFIG_MAINDBNAME. */
104480 ** function call using a macro.
104751 ** SQL is being compiled using sqlite3NestedParse() or
105291 ** the usual way - using sqlite3ResolveExprNames().
105740 ** All SELECT statements should have been expanded using
106378 ** already been generated using the exprCodeSubselect() routine. In this
106595 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
106852 ** Join two expressions using an AND operator. If either expression is
108525 ** calling routine should implement the IN operator using a sequence
108721 } /* End attempt to optimize using an index */
108777 ** string is eventually freed using sqlite3DbFree().
108854 ** have been duplicated using OP_OpenDup.
109317 ** suitable for evaluating the IN operator, then evaluate using a
109389 ** of the RHS using the LHS as a probe. If found, the result is
109736 ** in-line rather than by using the usual callbacks.
109802 /* Compare two expressions using sqlite3ExprCompare() */
109811 /* Compare two expressions using sqlite3ExprImpliesExpr() */
109878 ** computed using the original expression. */
110476 ** The expression is implemented using an OP_Param opcode. The p1
110813 ** Make a transient copy of expression pExpr and then code it using
110847 ** filled using OP_SCopy. OP_Copy must be used instead.
111175 ** can compute the mapping above using the following expression.
111379 ** The pA side might be using TK_REGISTER. If that is the case and pB is
111380 ** not using TK_REGISTER but is otherwise equivalent, then still return 0.
111806 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
111827 ** evaluated using only the index and without having to lookup the
112968 /* Do the rename operation using a recursive UPDATE statement that
113084 ** Remember that the parser tree element pPtr was created using
113450 ** Parse the SQL statement zSql using Parse object (*p). The Parse object
113527 ** point to zQuot so that all substitutions are made using the
113570 ** using single quotes. If the character immediately following the
113783 ** It is only accessible to SQL created using sqlite3NestedParse(). It is
115446 ** the number of rows matched by a equality query on the index using
117378 ** Do an authorization check using the code and arguments given. Return
117808 ** auxiliary databases added using the ATTACH command.
117910 /* If zName is the not the name of a table in the schema created using
117995 ** using the ATTACH command.
118398 ** writing. The table is opened using cursor 0.
118422 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
119551 ** it is quoted using double-quotes.
119989 ** any shadow tables seen using the TF_Shadow flag.
121868 /* Create the rootpage for the index using CreateIndex. But before
122999 ** when it has finished using it.
123028 ** the missing index using the collation-needed callback. For
124630 ** The label should be resolved using sqlite3ResolvePartIdxLabel().
124689 ** might be stored in the table as an integer (using a compact
125157 ** Allocate nByte bytes of space using sqlite3Malloc(). If the
125391 ** range of characters can be specified using '-'. Example:
126148 ** When the "sqlite3" command-line shell is built using this functionality,
126376 ** internal count when using count(*) and when the total count can be
127155 ** Deferred constraints are implemented using a simple counter associated
127218 ** instead of using a counter, an exception is thrown immediately if the
127233 ** implemented using triggers, which of the old.* columns would be
127491 ** is no matching parent key. Before using MustBeInt, make a copy of
128007 ** the original record is deleted from the table using the calling convention
128009 ** but before the new record is inserted using the INSERT convention.
128825 ** run without using a temporary table for the results of the SELECT.
129745 ** using the rowid. So put a NULL in the IPK slot of the record to avoid
129746 ** using excess space. The file format definition requires this extra
131015 ** Hence, make a complete copy of the opcode, rather than using
134390 ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
134815 ** buffer that the pager module resizes using sqlite3_realloc().
134964 ** can become corrupted using ordinary SQL when the journal is off */
135891 ** can be specified using a numeric parameter N.
136320 ** In all cases new databases created using the ATTACH command are
136326 ** new database files created using this database handle. It is only
136401 ** Subverting this mechanism by using "PRAGMA schema_version" to modify
137574 ** created using ATTACH statements. Return a success code. If an
137692 ** We return -32768 instead of the more usual -1 simply because using
137764 ** Or, stop using the pPtr parameter with this call and use only its
138770 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
139516 /* Store the result as data using a unique key.
139652 ** index with pSO->nExpr+2 columns. Build a key using pSO for the first
139858 ** If the inner loop was generated using a non-null pOrderBy argument,
141023 ** two or more separate queries using UNION, UNION ALL, EXCEPT, or
141476 /* Store the result as data using a unique key.
141641 ** actually called using Gosub and they do not Return. EofA and EofB loop
142677 ** using UNION ALL operators. In this case N is the number of simple
144241 ** using clause from the table on the right. */
145148 /* Handle compound SELECT statements using the separate multiSelect()
146275 ** the calling procedure is finished using it.
147786 ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
148015 ** table iEph as index keys, using OP_IdxInsert.
149138 /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
149178 /* End of the ephemeral table scan. Or, if using the onepass strategy,
150230 ** shared b-tree databases opened using connection db are held by the
150686 ** have already been reserved using growVTrans().
151058 ** new FuncDef structure that is marked as ephemeral using the
151427 ** dependencies and cost estimates for using the chosen algorithm.
151507 ** 1. Then using those as a basis to compute the N best WherePath objects
151540 ** the <op> using a bitmask encoding defined by WO_xxx below. The
151930 #define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */
151939 #define WHERE_BLOOMFILTER 0x00400000 /* Consider using a Bloom-filter */
152674 ** copy of the column affinity string of the index allocated using
152684 ** no conversion should be attempted before using a t2.b value as part of
152837 ** the expression tree (by sqlite3WalkExpr()) using an instance of this
153076 Index *pIdx, /* Index scan is using */
153462 /* Case 2: We can directly reference a single row using an
153464 ** we reference multiple rows using a "rowid IN (...)"
153596 /* Case 4: A scan using an index.
153746 /* Generate code to evaluate all constraint terms using == or IN
154282 /* If all of the OR-connected terms are optimized using the same
154283 ** index, and the index is opened using the same cursor number
154370 ** computed using the current set of tables.
154859 ** can be optimized using inequality constraints. Return TRUE if it is
155326 ** Terms that satisfy case 3 are candidates for lookup by using
155328 ** the union of all rowids using a RowSet object. This is similar
157637 ** measure the size of the table at run-time using OP_Count with
158290 ** using the method described in the header comment for this function. */
158403 /* Determine iLower and iUpper using ($P) only. */
158424 /* If possible, improve on the iLower estimate using ($P:$L). */
158441 /* If possible, improve on the iUpper estimate using ($P:$U). */
158969 /* Any loop using an appliation-defined index (or PRIMARY KEY or
159011 ** Insert or replace a WhereLoop entry using the template supplied.
159212 /* If a truth probability is specified using the likelihood() hints,
159245 ** in the vector can be optimized using column nEq of the index. This
159327 ** number of rows expected to be visited by filtering using the nEq
159476 ** a safety margin of 2 (LogEst: 10) that favors using the IN operator
159477 ** with the index, as using an index has better worst-case behavior.
159566 /* Adjust nOut using stat4 data. Or, if there is no stat4
159567 ** data, using some other estimate. */
159685 /* Consider using a skip-scan if there are no WHERE clause constraints
159920 ** bias the scoring in favor of using an index, since the worst-case
159921 ** performance of using an index is far better than the worst-case performance
159926 Bitmask mPrereq /* Extra prerequesites for using this table */
160078 ** At 2.75, a full table scan is preferred over using an index on
160134 ** satisfied using just the index, and that do not require a
160145 /* pTerm can be evaluated using just the index. So reduce
160225 u16 mExclude, /* Exclude terms using these operators */
160432 ** or clear (if bHandle==0) the flag to handle it using an iterator.
161293 ** The (Y/X) term is implemented using stack variable rScale
161413 /* Compute successively longer WherePaths using the previous generation
161720 ** to plan those simple cases using much less ceremony than the
161960 ** using a Bloom filter. Consider a Bloom filter if:
162400 ** loops will be built using the revised truthProb values. */
162480 ** using a Bloom filter.
162611 /* This is one term of an OR-optimization using the PRIMARY KEY of a
163247 ** be implemented using an API, built-in window functions are much more
163251 ** window functions and some are implemented directly using VDBE
163262 ** functions min() and max() are implemented using VDBE instructions if
163715 /* Window functions that are implemented using bytecode and thus have
165167 ** arrays of registers using the collation sequences and other comparison
165770 ** The various GROUPS cases are implemented using the same patterns as
166679 ** zero the stack is dynamically sized using realloc()
171702 ** using a lookup table, whereas a switch() directly on c uses a binary search.
171836 ** might be implemented more directly using a hand-written hash table.
171837 ** But by using this automatically generated code, the size of the code
172674 /* This token started out using characters that can appear in keywords,
173125 u8 state = 0; /* Current state, using numbers defined in header comment */
173519 ** SQLITE_SOURCE_ID C preprocessor macro. Except if SQLite is built using
173552 ** I/O active are written using this function. These messages
173623 ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
173995 ** is NULL, then SQLite reverts to using its default memory allocator
174040 ** can be changed at start-time using the
174431 ** strings byte by byte using the memcmp() function from the standard C
174830 ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
175285 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
175586 /* Register a trace callback using the version-2 interface.
175671 ** inserted or deleted using this database connection.
175722 ** inserted or deleted using this database connection.
175797 ** registered using sqlite3_wal_hook(). Likewise, registering a callback
175798 ** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
176139 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
176328 ** and is in the same format as names created using sqlite3_create_filename().
176723 /* Beginning with version 3.37.0, using the VFS xFetch() API to memory-map
176726 ** SQLITE_ENABLE_SORTER_MMAP at compile time or by using the
176916 ** using the sqlite3_automatic_extension() API.
177462 ** Restore the state of the PRNG to the last state saved using
177485 ** x==0 && db==0 Revert to default behavior of using the
177533 ** using a typedef.
177931 ** Access tuning parameters using the Tuning(ID) macro. Set the
177932 ** parameters in the CLI using ".testctrl tune ID VALUE".
178499 ** (call it pOther) in the same process was busy using the same shared
178739 ** using seven bits * per byte as follows:
178769 ** FTS3 used to optionally store character offsets using a compile-time
178820 ** nodes are written using LeafWriter, and read using LeafReader (to
178865 ** nodes are written using InteriorWriter, and read using
178938 ** written individually (using LeafWriter) to a level 0 segment, with
178982 ** Since we're using a segmented structure, with no docid-oriented
179022 ** FTS4 is really an extension for FTS3. It is enabled using the
179131 ** until the cursor is closed (using the xClose() method).
179233 ** directly. Change this structure only by using the routines below.
179601 ** virtual table cursor (an instance of the following structure) using
179602 ** the xOpen method. Cursors are destroyed using the xClose method.
179729 ** The aMI array is allocated using sqlite3_malloc(). It should be freed
180730 ** and its contents are allocated using a single allocation. It
181249 ** 2. Full-text search using a MATCH operator on a non-docid column.
181338 /* If using a docid=? or rowid=? strategy, set the UNIQUE flag. */
182258 ** The first docid written to the output is therefore encoded using the
182503 ** doclists to merge, the merging is done pair-wise using the TermSelect
182517 ** buffer using memcpy().
183840 ** This function assumes that pList points to a buffer allocated using
184653 /* Tokens are never deferred for FTS tables created using the content=xxx
185059 ** expression, using the data currently stored in the position lists
185570 ** occurrence of the phrase in the column, stored using the normal (delta+2)
186353 ** d) When using the old syntax, the OR operator has a greater precedence
186354 ** than an implicit AND. When using the new, both implicity and explicit
186361 ** be tested using a single build of testfixture.
186440 ** Allocate nByte bytes of memory using sqlite3_malloc(). If successful,
186484 ** Extract the next token from buffer z (length n) using the tokenizer
186832 ** the end of the input. Read a regular token using the sqlite3_tokenizer
186867 ** When using the new fts3 query syntax (when SQLITE_ENABLE_FTS3_PARENTHESIS
186876 ** Note that when using the old query syntax, the OR operator has a higher
187277 ** expression tree. It should be deleted using sqlite3Fts3ExprFree()
187329 ** nul-terminated string and the length is determined using strlen().
187439 ** the returned expression text and then freed using sqlite3_free().
188918 ** using the built-in "simple" tokenizer:
189454 ** The virtual table module tokenizes this <string>, using the FTS3
191064 ** NULL, then a buffer is allocated using sqlite3_malloc() and populated
191632 ** objects in term order using qsort(). This uses the same comparison
191681 ** 2) The current terms (if any) are compared using memcmp(). If one
192269 ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
192331 /* If using the content=xxx option, assume the table is never empty */
192723 ** This function is called on a MultiSegReader that has been started using
193439 ** created using the content=xxx option, then the new index is based on
194067 ** zRhs (size in bytes nRhs) using memcmp. If one term is a prefix of
194883 ** indexes of absolute level iAbsLevel. If this cursor is opened using
195359 ** this list using sqlite3Fts3DeferToken().
195907 ** Free a MatchinfoBuffer object allocated using fts3MIBufferNew()
196247 ** the required space using malloc().
196303 ** determined using strlen().
197898 ** using this format.
199525 ** Do a node lookup using zPath. Return a pointer to the node on success.
201334 ** SQL function was created using sqlite3_rtree_geometry_callback() or
201369 ** Note that the GCC_VERSION macro will also be set correctly when using
201415 ** using C-preprocessor macros. If that is unsuccessful, or if
202845 ** can be cast into an RtreeMatchArg object. One created using
202943 ** is, do not consider the lookup-by-rowid plan as using such a plan would
204582 ** using database connection db. If successful, the integer value returned
206818 ** 2 "rtree" R-tree overlap query using geopoly_overlap()
206819 ** 3 "rtree" R-tree within query using geopoly_within()
207369 ** operator) using the ICU uregex_XX() APIs.
207768 ** a UCollator structure previously allocated using ucol_open().
207777 ** a UCollator structure previously allocated using ucol_open().
207947 UChar *aChar; /* Copy of input using utf-16 encoding */
208201 ** "<database>-oal", they go on using the original database in
208206 ** tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses
208212 ** location using a call to rename(2). Before doing this the RBU
208315 ** applied using this extension is hence refered to as an "RBU update".
208364 ** tables or view named using the data_<target> naming scheme.
208379 ** not function like a primary key value cannot be updated using RBU. For
208478 ** words, rows should be sorted using the destination table PRIMARY KEY
208487 ** 1) Opens an RBU handle using the sqlite3rbu_open() function.
208572 ** the zipvfs_create_vfs() API below for details on using RBU with zipvfs.
208614 ** a description of the complications associated with using RBU with
208715 ** eventually free any such buffer using sqlite3_free().
209155 ** using the formula:
209228 ** An rbu VFS is implemented using an instance of this structure.
209231 ** It is NULL for RBU VFS objects created explicitly using
209536 ** of the caller to (eventually) free this buffer using sqlite3_free().
209558 ** to eventually free this buffer using sqlite3_free().
209569 ** Unless it is NULL, argument zSql points to a buffer allocated using
209578 ** buffer using sqlite3_free().
209915 ** using sqlite3_free().
210700 ** It is the responsibility of the caller to eventually free it using
210754 ** It is the responsibility of the caller to eventually free it using
211495 ** responsibility of the caller to eventually free the object using
211599 /* If using separate RBU and state databases, attach the state database to
212901 ** generating a large journal using a temp file. */
213247 ** db fds opened using a particular RBU VFS is maintained at
213876 ** happens to pass a pointer to this buffer when using xAccess()
214246 ** If the paths are sorted using the BINARY collation sequence, then
214912 /* Initialize a cursor according to the query plan idxNum using the
215587 ** (e.g. sqlite3changeset_start()) or using a stream function (e.g.
215671 ** A varint containing the number of bytes in the value (encoded using
215700 ** N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
215742 ** N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
215774 ** resolved using either the OMIT or REPLACE strategies within the apply_v2()
215785 ** N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
216505 ** be freed using sqlite3_free() by the caller
217407 ** Delete a session object previously allocated using sqlite3session_create().
218182 ** using sqlite3_free().
218228 ** using sqlite3_free().
218516 ** using sqlite3_free().
219634 /* COVERAGE: The (pVal->z==0) branch is never true using current versions
219737 ** a conflict is encountered and resolved using conflict resolution
220013 ** to be done using a SELECT, as there is no PRIMARY KEY in the
220778 ** is the responsibility of the caller to free the output buffer using
221099 ** free the (*ppOut) buffer using sqlite3_free().
221486 ** Tokenize text using the tokenizer belonging to the FTS5 table.
221518 ** the same MATCH query using the xGetAuxdata() API.
221609 ** The information accessed using this API and its companion
221610 ** xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext
221689 ** allocated using xCreate(). Fts5 guarantees that this function will
221757 ** <ol><li> By mapping all synonyms to a single token. In this case, using
221847 ** When using methods (2) or (3), it is important that the tokenizer only
222105 ** are ignored. This value is configured using:
222359 ** using sqlite3Fts5IndexQuery().
222910 ** zero the stack is dynamically sized using realloc()
224884 ** This is done using the standard BM25 formula as found on wikipedia:
225274 ** the length of the string is determined using strlen().
225277 ** buffer using sqlite3_free(). If an OOM error occurs, NULL is returned.
225638 ** eventually free any such error message using sqlite3_free().
225923 ** such error message using sqlite3_free().
226665 ** This function is only called when using the special 'trigram' tokenizer.
226927 ** using sqlite3_malloc(). This approach could be improved upon. */
227062 ** using sqlite3_malloc(). This approach could be improved upon. */
228477 ** zero, or it may create copies of pColset using fts5CloneColset().
228839 ** responsibility of the caller to at some point free the buffer using
230325 ** using an Fts5Structure record in memory. Which uses instances of the
230599 ** Compare the contents of the two buffers using memcmp(). If one buffer
235583 ** prefix-query. Instead of using a prefix-index (if one exists),
235584 ** evaluate the prefix query using the main FTS index. This is used
237685 ** is using. Then attempt to move the cursor to a rowid equal to or laster
238029 ** 1. Full-text search using a MATCH operator.
241039 ** Tokenize some text using the ascii tokenizer.
242166 ** Tokenize using the porter tokenizer.
242292 ** pTok is a tokenizer previously created using the same method. This function
245820 // support hmac algo changed by using rekey operation