Lines Matching defs:handle
1345 ** file-control may be invoked by SQLite on the database file handle
1390 ** underlying native file handle associated with a file handle. This file
1391 ** control interprets its argument as a pointer to a native file handle and
1396 ** opcode causes the xFileControl method to swap the file handle with the one
2231 ** allocator is engaged to handle all of SQLites memory allocation needs.
2591 ** database handle, SQLite checks if this will mean that there are now no
3708 ** order for sqlite3_open16(). ^(A [database connection] handle is usually
3723 ** associated with the [database connection] handle should be released by
3976 sqlite3 **ppDb /* OUT: SQLite db handle */
3980 sqlite3 **ppDb /* OUT: SQLite db handle */
3984 sqlite3 **ppDb, /* OUT: SQLite db handle */
4508 sqlite3 *db, /* Database handle */
4511 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
4515 sqlite3 *db, /* Database handle */
4518 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
4522 sqlite3 *db, /* Database handle */
4526 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
4530 sqlite3 *db, /* Database handle */
4533 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
4537 sqlite3 *db, /* Database handle */
4540 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
4544 sqlite3 *db, /* Database handle */
4548 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
6677 ** ^The sqlite3_db_handle interface returns the [database connection] handle
7213 sqlite3 *db, /* Connection handle */
7781 ** KEYWORDS: {BLOB handle} {BLOB handles}
7798 ** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
7816 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored
7844 ** [sqlite3_blob_write()]. The [BLOB handle] can be moved to a
7846 ** interface. However, the column, table, or database of a [BLOB handle]
7847 ** cannot be changed after the [BLOB handle] is opened.
7849 ** ^(If the row that a BLOB handle points to is modified by an
7851 ** then the BLOB handle is marked as "expired".
7853 ** other than the one the BLOB handle is open on.)^
7855 ** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
7869 ** To avoid a resource leak, every open [BLOB handle] should eventually
7890 ** ^This function is used to move an existing [BLOB handle] so that it points
7893 ** changed. ^The database, table and column on which the blob handle is open
7894 ** remain the same. Moving an existing [BLOB handle] to a new row is
7895 ** faster than closing the existing handle and opening a new one.
7901 ** SQLite error code is returned and the blob handle is considered aborted.
7903 ** [sqlite3_blob_reopen()] on an aborted blob handle immediately return
7904 ** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle
7907 ** ^This function sets the database handle error code and message.
7915 ** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed
7917 ** handle is still closed.)^
7919 ** ^If the blob handle being closed was opened for read-write access, and if
7926 ** open blob handle results in undefined behaviour. ^Calling this routine
7929 ** is passed a valid open blob handle, the values returned by the
7939 ** successfully opened [BLOB handle] in its only argument. ^The
7943 ** This routine only works on a [BLOB handle] which has been created
7954 ** ^(This function is used to read data from an open [BLOB handle] into a
7964 ** ^An attempt to read from an expired [BLOB handle] fails with an
7970 ** This routine only works on a [BLOB handle] which has been created
7983 ** ^(This function is used to write data into an open [BLOB handle] from a
7993 ** ^If the [BLOB handle] passed as the first argument was not opened for
8005 ** ^An attempt to write to an expired [BLOB handle] fails with an
8007 ** before the [BLOB handle] expired are not rolled back by the
8008 ** expiration of the handle, though of course those changes might
8009 ** have been overwritten by the statement that expired the BLOB handle
8012 ** This routine only works on a [BLOB handle] which has been created
8218 ** of a valid mutex handle. The implementations of the methods defined
8219 ** by this structure are not required to handle this case. The results
8220 ** of passing a NULL pointer instead of a valid mutex handle are undefined
9164 ** handle invalid, and will not use it with any other sqlite3_pcache_methods2
9322 ** that the backup operation has failed and pass the backup operation handle
9411 sqlite3 *pDest, /* Destination database handle */
9413 sqlite3 *pSource, /* Source database handle */
9444 ** sqlite3_unlock_notify() method with the blocked connection handle as
9630 ** registering the callback. ^The second is a copy of the database handle.
9644 ** A single database handle may have at most a single write-ahead log callback
9804 sqlite3 *db, /* Database handle */
9877 ** Virtual table implementations that are required to handle OR REPLACE
10079 ** CAPI3REF: Identify and handle IN constraints in xBestIndex
10391 ** ^This function does not set the database handle error code or message
10493 sqlite3 *db, /* Database handle */
10564 ** <li> The database handle must not be in [autocommit mode].
10579 ** database handle in autocommit mode but fails for some other reason,
10608 ** is already a read transaction open on schema S, then the database handle
10671 ** clients drops to zero. If either snapshot handle was obtained before the
10700 ** of database handle db and make all valid snapshots available to
11003 ** Create a new session object attached to database handle db. If successful,
11009 ** database handle.
11012 ** [sqlite3session_delete()] function before the database handle that they
11013 ** are attached to is itself closed. If the database handle is closed before
11020 ** database handle that has one or more session objects attached. Nor is
11021 ** it possible to create a session object attached to a database handle for
11031 sqlite3 *db, /* Database handle */
11045 ** Session objects must be deleted before the database handle to which they
11354 ** attached to the same database handle as the session object that contains
11451 ** [sqlite3session_changeset()] on the session handle may still return a
11473 ** If successful, *pp is set to point to the iterator handle and SQLITE_OK
11510 sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */
11515 sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */
12008 ** update the "main" database attached to handle db with the changes found in
12163 sqlite3 *db, /* Apply change to "main" db of this handle */
12178 sqlite3 *db, /* Apply change to "main" db of this handle */
12261 ** it is possible to call on the supplied sqlite3_changeset_iter handle
12492 ** low-memory environment is required to handle very large changesets, the
12561 sqlite3 *db, /* Apply change to "main" db of this handle */
12576 sqlite3 *db, /* Apply change to "main" db of this handle */
13021 ** should be set to point to the new tokenizer handle and SQLITE_OK
13027 ** This function is invoked to delete a tokenizer handle previously
14631 ** callback for a given sqlite handle.
14634 ** callback for the database handle. Each pager opened via the sqlite
14635 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
14694 ** this magic value that the code knows to handle differently. Any
15157 ** sqlite3_malloc() to obtain space for the file-handle structure.
16505 sqlite3_pcache_page *pPage; /* Pcache object page handle */
17695 ** instance of the sqlite3_vtab* handle used to access the virtual table
17699 ** connection handle passed to it via the xConnect() or xCreate() method
17700 ** during initialization internally. This database connection handle may
17712 ** sqlite3_vtab* handle in the compiled query.
17727 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
20451 ** macros handle the common case without a procedure call, but then call
22006 ** handle case conversions for the UTF character set since the tables
23457 ** pagers the database handle is connected to. *pHighwater is always set
25043 sqlite3_file *id, /* Database file handle */
27609 ** This type of mutex is used as the database handle mutex when testing
29926 /* If the db handle must hold the connection handle mutex here.
32899 void *tid; /* The thread handle */
33751 ** handle "db". The error code is set to "err_code".
33757 ** To clear the most recent error for sqlite handle "db", sqlite3Error
33783 ** stored by this function into the database handle using sqlite3Error().
34181 /* attempt to handle extremely small/large numbers better */
36555 ** Check if another file-handle holds a RESERVED lock on an kvvfs-file.
36601 ** Open an kvvfs file handle.
36708 ** Open the dynamic library located at zPath and return a handle.
36973 ** Sometimes, after a file handle is closed by SQLite, the file descriptor
37679 ** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
38562 ** handle that precludes the requested lock, return BUSY.
38709 ** Add the file descriptor used by file handle pFile to the corresponding
39784 ** handle that precludes the requested lock, return BUSY.
40722 ** This function is called to handle the SQLITE_FCNTL_SIZE_HINT
40834 ** Information and control of an open file handle.
42606 ** handle h - as it is guaranteed that no posix locks will be released
42979 ** file handle closed. To achieve the same effect using this new
43102 ** they may be stored as part of the file handle and used by the
45497 HANDLE hHeap; /* The handle to our heap. */
47307 ** Acquire a lock on the handle h
47377 /* If we succeeded in making the shared memory handle, map it. */
47381 /* If mapping failed, close the shared memory handle and erase it */
47438 /* De-reference and close our copy of the shared memory handle */
47660 ** Move the current position of the file handle passed as the first
47729 ** It is reported that an attempt to close a handle might sometimes
47733 ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
47802 winFile *pFile = (winFile*)id; /* file handle */
47880 winFile *pFile = (winFile*)id; /* File handle */
47983 winFile *pFile = (winFile*)id; /* File handle object */
48589 ** Control and query of the open file handle.
48802 winFile hFile; /* File handle from winOpen */
48810 HANDLE hMap; /* File handle from CreateFileMapping */
49365 HANDLE hMap = NULL; /* file-mapping handle */
49754 /* caller will handle out of memory */
49775 /* caller will handle out of memory */
50089 sqlite3_file *id, /* Write the SQLite file handle here */
50860 OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
50865 OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
50875 OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
50890 OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)h));
50902 OSTRACE(("DLSYM handle=%p, symbol=%s, address=%p\n",
50909 OSTRACE(("DLCLOSE handle=%p\n", (void*)pHandle));
51811 ** Open an mem file handle.
51940 ** Open the dynamic library located at zPath and return a handle.
51963 ** Close the dynamic library handle pHandle.
52217 ** to handle both cases well.
52306 ** Create a new bitmap object able to handle bits between 0 and iSize,
55448 sqlite3 *db, /* Check this handle's interrupt flag */
60273 /* Figure out how much space is required for each journal file-handle
60344 ** Database file handle (pVfs->szOsFile bytes)
60345 ** Sub-journal file handle (journalFileSize bytes)
60346 ** Main journal file handle (journalFileSize bytes)
62601 ** Return the file handle for the database file associated
62610 ** Return the file handle for the journal file (if it exists).
62719 ** sub-journal now. This is required to handle the following scenario:
62829 ** The page handle passed as the first argument refers to a dirty page
63050 sqlite3 *db, /* Db handle used to check for interrupts */
63112 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
63255 ** Set the database handle used by the wal layer to determine if
63267 ** If this is a WAL database, obtain a snapshot handle for the snapshot
63869 sqlite3_file *pDbFd; /* File handle for the database file */
63870 sqlite3_file *pWalFd; /* File handle for WAL file */
64368 Wal *pWal, /* WAL handle */
64822 ** to must remain valid for the lifetime of the returned Wal* handle.
64831 ** *ppWal is set to point to a new WAL handle. If an error occurs,
64840 Wal **ppWal /* OUT: Allocated Wal handle */
64911 /* Open file handle on the write-ahead log file. */
65218 ** they are supported by the VFS, and (b) the database handle is configured
65274 ** Set the database handle used to determine if blocking locks are required.
65400 sqlite3 *db, /* Check for interrupts on this handle */
66505 Wal *pWal, /* WAL handle */
66609 Wal *pWal, /* WAL handle */
66756 ** "rollback" the write position of the WAL handle back to the current
66830 ** to handle if this transaction is rolled back. */
66982 Wal *pWal, /* Wal handle to write to */
67227 sqlite3 *db, /* Check this handle's interrupt flag */
67867 DbPage *pDbPage; /* Pager page handle */
67877 ** a btree handle is closed.
67880 Btree *pBtree; /* Btree handle holding this lock */
67890 /* A Btree handle
68126 #define BTCF_Incrblob 0x10 /* True if an incremental I/O handle */
68228 ** of handle p (type Btree*) are internally consistent.
68305 ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
68306 ** set BtShared.db to the database handle associated with p and the
68320 ** Release the BtShared mutex associated with B-Tree handle p and
68901 ** Query to see if Btree handle p may obtain a lock of type eLock
68963 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
71073 sqlite3 *db, /* Associated database handle */
71458 /* Close all cursors opened via this handle. */
71475 /* Rollback any active transaction and free the handle structure.
71477 ** this handle.
71650 ** database handle that owns *p is not. In this case if sqlite3BtreeEnter()
71652 ** database handle that owns *p, causing undefined behavior.
72159 /* If another database handle has already opened a write transaction
72822 ** handle, downgrade to a read-only transaction. The other statements
72827 /* If the handle had any kind of transaction open, decrement the
72880 /* If the handle has a write-transaction open, commit the shared-btrees
73168 BtShared *pBt = p->pBt; /* Shared b-tree handle */
73430 ** that SQLite can handle) or more. But returning a smaller value might
73465 MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
79555 ** btree as the argument handle holds an exclusive lock on the
79736 ** the Btree handle passed as the only argument. For private caches
79768 sqlite3* pDestDb; /* Destination database handle */
79774 sqlite3* pSrcDb; /* Source database handle */
79797 ** handle mutex and the mutex associated with the source BtShared
79821 ** in connection handle pDb. If such a database cannot be found, return
79868 ** message in database handle db.
79880 ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
79884 ** stored in database handle pDestDb.
79901 /* Lock the source database handle. The destination database
79902 ** handle is not locked in this routine, but it is locked in
79904 ** other thread accesses the destination handle for the duration
79943 ** handle. All that is left to do here is free the sqlite3_backup
79973 sqlite3_backup *p, /* Backup handle */
79985 ** guaranteed that the shared-mutex is held by this thread, handle
80343 ** Release all resources associated with an sqlite3_backup* handle.
80376 /* Set the error code of the destination database handle. */
81830 ** that both the BtShared and database handle mutexes are held. */
82424 sqlite3 *db, /* Database handle */
84423 ** of all of BtShared structures accessible via the database handle
85290 ** A read or write transaction may or may not be active on database handle
85647 ** handle associated with the VM passed as an argument is about to be
85749 ** so, abort any other statements this handle currently has active.
85896 ** as the first argument to its database handle (so that they will be
85900 ** copies them to the database handle.
86231 ** the end. Hence these functions allow the caller to handle the
87061 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
87621 ** sqlite3_changes() on the database handle 'db'.
88523 ** caller. Set the error code in the database handle to the same
88624 ** caller. Set the error code in the database handle to the same value.
88684 ** into the database handle. This block copies the error message
88685 ** from the database handle into the statement and sets the statement
89667 ** Return the sqlite3* database handle to which the prepared statement given
89668 ** in the argument belongs. This is the same database handle that was
94038 /* Link the new savepoint into the database handle's list. */
96144 ** The value of the change counter is copied to the database handle
99285 u16 iCol; /* Table column this handle is open on */
99296 ** the b-tree cursor associated with blob handle p to point to row iRow.
99302 ** blob handle was opened, then an error code is returned and *pzErr may
99377 ** Open a blob handle.
99611 ** Close a blob handle that was previously created using
99656 /* If there is no statement handle, then the blob-handle has
99662 ** returned, clean-up the statement handle.
99708 ** Read data from a blob handle.
99715 ** Write data to a blob handle.
99722 ** Query a blob handle for the size of the data.
99733 ** Move an existing blob handle to point to a different row of the same
99738 ** database handle error code and message set. If this happens, then all
99752 /* If there is no statement handle, then the blob-handle has
99946 ** A container for a temp file handle and the current amount of data
99950 sqlite3_file *pFd; /* File handle */
100131 sqlite3_file *pFd; /* File handle we are reading from */
100197 sqlite3_file *pFd; /* File handle to write to */
101054 ** The first argument is a file-handle open on a temporary file. The file
101077 ** Allocate space for a file-handle and open a temporary file. If successful,
101078 ** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK.
101082 sqlite3 *db, /* Database handle doing sort */
101230 sqlite3_file *pFd, /* File handle to write to */
103328 sqlite3_file *pJfd, /* Preallocated, blank file handle */
103336 /* Zero the file-handle object. If nSpill was passed zero, initialize
103339 ** made on the journal file-handle. */
103398 ** The file-handle passed as the only argument is open on a journal file.
107605 sqlite3 *db, /* Database handle. Used for memory allocation */
107624 sqlite3 *db, /* Database handle. Used for memory allocation */
112710 ** can handle (i.e. not CURRENT_TIME etc.)
113456 sqlite3 *db, /* Database handle */
114452 sqlite3 *db = pParse->db; /* Database handle */
115584 sqlite3 *db = pParse->db; /* Database handle */
116315 sqlite3 *db, /* Database handle */
116596 ** database iDb attached to handle db.
117296 sqlite3 *db = pParse->db; /* Database handle */
117470 ** when syntax rules are reduced. The routines in this file handle the
118911 ** knows to handle it specially. The TEMP trigger is automatically
124548 ** handle rows (possibly in other tables) that refer via a foreign key
125136 ** handle the rounding directly,
125159 ** the database handle that malloc() has failed and return NULL.
127156 ** with the database handle. The counter is set to zero each time a
127681 sqlite3 *db = pParse->db; /* Database handle */
127810 ** the lookaside buffer belonging to database handle dbMem.
128019 sqlite3 *db = pParse->db; /* Database handle */
128338 sqlite3 *db = pParse->db; /* Database handle */
128615 ** to handle INSERT statements in SQLite.
129184 int onError, /* How to handle constraint errors */
129189 ** This routine is called to handle SQL of the following forms:
129290 int onError, /* How to handle constraint errors */
130889 /* Generate code to handle collisions */
131386 int onError, /* How to handle constraint errors */
132289 /* handle after drop table done */
132617 /* handle after drop table done */
133176 void *handle;
133222 handle = sqlite3OsDlOpen(pVfs, zFile);
133224 for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
133227 handle = sqlite3OsDlOpen(pVfs, zAltFile);
133231 if( handle==0 ) goto extension_not_found;
133232 xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
133250 sqlite3OsDlClose(pVfs, handle);
133264 xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry);
133277 sqlite3OsDlClose(pVfs, handle);
133289 sqlite3OsDlClose(pVfs, handle);
133293 /* Append the new shared library handle to the db->aExtension array. */
133294 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
133299 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
133304 db->aExtension[db->nExtension++] = handle;
136326 ** new database files created using this database handle. It is only
136352 /* Only change the value of sqlite.enc if the database handle is not
137214 sqlite3 *db, /* Database handle. */
137818 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
137821 sqlite3 *db, /* Database handle. */
137966 sqlite3 *db, /* Database handle. */
138052 sqlite3 *db, /* Database handle. */
138064 sqlite3 *db, /* Database handle. */
138082 sqlite3 *db, /* Database handle. */
138107 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
138110 sqlite3 *db, /* Database handle. */
138168 sqlite3 *db, /* Database handle. */
138180 sqlite3 *db, /* Database handle. */
138192 sqlite3 *db, /* Database handle. */
138223 ** to handle SELECT statements in SQLite.
141896 /* Generate code to handle the case of A<B
141903 /* Generate code to handle the case of A==B
141917 /* Generate code to handle the case of A>B
144981 ** systems handle this case differently, and not all the same way,
147519 sqlite3 *db = pParse->db; /* Database handle */
147853 ** to handle UPDATE statements.
148129 int onError, /* How to handle constraint errors */
148934 ** handle rows (possibly in other tables) that refer via a foreign key
150235 ** associated with the database handle itself must be held.
150241 ** the database handle mutex is held.
151456 u32 bOmitOffset : 1; /* True to let virtual table handle offset */
151460 u32 mHandleIn; /* Terms to handle as IN(...) instead of == */
152060 sqlite3 *db = pParse->db; /* Database handle */
152170 sqlite3 *db = pParse->db; /* Database handle */
152438 ** of the subroutines do not handle this case. */
156587 u32 mHandleIn; /* Terms that vtab will handle as <col> IN (...) */
156981 ** but is enough to handle most commonly occurring SQL statements.
160432 ** or clear (if bHandle==0) the flag to handle it using an iterator.
160673 ** Add WhereLoop entries to handle OR terms. This works for either
165261 ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this
165748 ** To handle this case, the pseudo-code programs depicted above are modified
173682 ** that we will be able to handle recursive calls into
174005 ** alternative memory allocator is engaged to handle all of SQLites
174164 /* Free any existing lookaside buffer for this handle before
174533 ** Return the number of changes since the database handle was opened.
174550 ** database handle object, it does not close any savepoints that may be open
174670 /* Closing the handle. Fourth parameter is passed the value 2. */
175823 sqlite3 *db, /* Attach the hook to this db handle */
175850 sqlite3 *db, /* Database handle */
175929 ** The mutex on database handle db should be held by the caller. The mutex
176077 ** sqlite3ApiExit(), to avoid setting the database handle error message.
176320 ** the default flags to open the database handle with. The value stored in
176383 ** common error, we are told, so we handle it as a special case. */
176629 sqlite3 **ppDb, /* OUT: Returned database handle */
176633 sqlite3 *db; /* Store allocated handle here */
176974 /* Opening a db handle. Fourth parameter is passed 0. */
176988 ** Open a new database handle.
176999 sqlite3 **ppDb, /* OUT: SQLite db handle */
177008 ** Open a new database handle.
177047 ** Register a new collation sequence with the database handle db.
177060 ** Register a new collation sequence with the database handle db.
177085 ** Register a new collation sequence with the database handle db.
177114 ** Register a collation sequence factory callback with the database handle
177135 ** Register a collation sequence factory callback with the database handle
177245 sqlite3 *db, /* Connection handle */
178183 ** Obtain a snapshot handle for the snapshot of database zDb currently
178184 ** being read by handle db.
178307 ** Free a snapshot handle obtained from sqlite3_snapshot_get().
178639 ** This is a difficult situation to handle. Returning an error
179542 sqlite3_blob *pSegments; /* Blob handle open on %_segments table */
180241 sqlite3 *db = p->db; /* Database handle */
180739 sqlite3 *db, /* Database handle */
181399 ** Finalize the statement handle at pCsr->pStmt.
181401 ** Or, if that statement handle is one created by fts3CursorSeekStmt(),
181655 Fts3Table *p, /* Virtual table handle */
182510 Fts3Table *p, /* FTS table handle */
182608 Fts3Table *p, /* FTS3 table handle */
182682 Fts3Table *p, /* FTS3 table handle */
182714 Fts3Table *p, /* FTS virtual table handle */
182739 Fts3Cursor *pCsr, /* Virtual table cursor handle */
182805 Fts3Table *p, /* Virtual table handle */
183147 sqlite3_vtab *pVtab, /* Virtual table handle */
183329 Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
183352 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
183399 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
183426 Fts3Table *p; /* Virtual table handle */
183427 Fts3Cursor *pCursor; /* Cursor handle passed through apVal[0] */
183459 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
183475 sqlite3_vtab *pVtab, /* Virtual table handle */
183511 sqlite3_vtab *pVtab, /* Virtual table handle */
183805 Fts3Cursor *pCsr, /* FTS cursor handle */
183911 Fts3Cursor *pCsr, /* FTS Cursor handle */
184278 Fts3Table *pTab, /* Virtual table handle */
184330 Fts3Cursor *pCsr, /* FTS Cursor handle */
184431 Fts3Cursor *pCsr, /* FTS Cursor handle */
184470 Fts3Cursor *pCsr, /* FTS Cursor handle */
184523 Fts3Cursor *pCsr, /* FTS Cursor handle */
184638 Fts3Cursor *pCsr, /* FTS Cursor handle */
184927 Fts3Cursor *pCsr, /* FTS Cursor handle */
185152 Fts3Cursor *pCsr, /* FTS cursor handle */
185533 Fts3Cursor *pCsr, /* FTS cursor handle */
189382 /* TODO(shess) This needs expansion to handle UTF-8
190037 sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
190164 ** This function is used to obtain an SQLite prepared statement handle
190166 ** *pp is set to the requested statement handle and SQLITE_OK returned.
190175 Fts3Table *p, /* Virtual table handle */
190177 sqlite3_stmt **pp, /* OUT: Statement handle */
190320 Fts3Table *pTab, /* FTS3 table handle */
190322 sqlite3_stmt **ppStmt /* OUT: Statement handle */
190345 Fts3Table *pTab, /* Fts3 table handle */
190346 sqlite3_stmt **ppStmt /* OUT: Statement handle */
190366 Fts3Table *pTab, /* Fts3 table handle */
190368 sqlite3_stmt **ppStmt /* OUT: Statement handle */
190453 Fts3Table *p, /* FTS3 table handle */
190468 ** Set *ppStmt to a statement handle that may be used to iterate through
190754 Fts3Table *p, /* Full-text table handle */
190862 /* Locate the statement handle used to insert data into the %_content
191074 ** This function may leave an open sqlite3_blob* handle in the
191075 ** Fts3Table.pSegments variable. This handle is reused by subsequent calls
191076 ** to this function. The handle may be closed by calling the
191077 ** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy
191078 ** performance improvement, but the blob handle should always be closed
191085 Fts3Table *p, /* FTS3 table handle */
191137 ** Close the blob handle at p->pSegments, if it is open. See comments above
191591 Fts3Table *p, /* Virtual table handle */
191812 Fts3Table *p, /* Virtual table handle */
191854 Fts3Table *p, /* Virtual table handle */
191911 Fts3Table *p, /* Virtual table handle */
191912 SegmentNode **ppTree, /* IN/OUT: SegmentNode handle */
192053 Fts3Table *p, /* Virtual table handle */
192054 SegmentNode *pTree, /* SegmentNode handle */
192122 Fts3Table *p, /* Virtual table handle */
192123 SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */
192273 Fts3Table *p, /* Virtual table handle */
192419 Fts3Table *p, /* FTS table handle */
192451 Fts3Table *p, /* Virtual table handle */
192553 Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
192571 Fts3Table *p, /* Virtual table handle */
192572 Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
192639 Fts3Table *p, /* Virtual table handle */
192671 Fts3Table *p, /* Virtual table handle */
192680 Fts3Table *p, /* Virtual table handle */
192768 Fts3Table *p, /* Virtual table handle */
193005 Fts3Table *p, /* FTS table handle */
193524 Fts3Table *p, /* FTS3 table handle */
193743 Fts3Table *p, /* Fts3 table handle */
193898 Fts3Table *p, /* Fts3 table handle */
193984 Fts3Table *p, /* FTS3 table handle */
194014 ** And, by design or by accident, released versions of FTS cannot handle
194135 Fts3Table *p, /* Fts3 table handle */
194286 Fts3Table *p, /* FTS Table handle */
194331 Fts3Table *p, /* Fts3 table handle */
194396 Fts3Table *p, /* FTS3 table handle */
194420 Fts3Table *p, /* FTS3 table handle */
194553 Fts3Table *p, /* FTS3 table handle */
194639 Fts3Table *p, /* FTS table handle */
194994 Fts3Table *p, /* FTS3 table handle */
195037 Fts3Table *p, /* FTS3 table handle */
195095 Fts3Table *p, /* FTS3 table handle */
195286 Fts3Table *p /* FTS3 table handle */
197679 sqlite3_tokenizer **pp /* OUT: New tokenizer handle */
204356 ** it uses this hook to close any open blob handle. This is done because a
204358 ** succeed if there are any open blob handles. i.e. if the blob handle were
204617 sqlite3 *db, /* Database handle */
204618 Rtree *pRtree, /* Rtree handle */
204885 sqlite3 *db; /* Database handle */
205211 sqlite3 *db, /* Database handle to access db through */
207171 ** Register the r-tree module with database handle db. This creates the
208224 ** handle is closed before the entire *-wal file is checkpointed,
208487 ** 1) Opens an RBU handle using the sqlite3rbu_open() function.
208490 ** handle returned by sqlite3rbu_db(). Also, if required, register
208494 ** the new handle. Each call to sqlite3rbu_step() performs a single
208498 ** 4) Calls sqlite3rbu_close() to close the RBU update handle. If
208521 ** While an RBU handle is open, a SHARED lock may be held on the target
208542 ** Open an RBU handle.
208581 ** Open an RBU handle to perform an RBU vacuum on database file zTarget.
208590 ** sqlite3rbu_close() on the RBU handle before sqlite3rbu_step() has
208593 ** handle specifying the same target and state databases.
208609 ** the next call to sqlite3rbu_vacuum() opens a handle that starts a
208624 ** the RBU handle passed as the first argument. The new limit is specified
208640 ** the RBU handle passed as the only argument.
208650 ** handle. The second argument should be passed zero to access the target
208651 ** database handle, or non-zero to access the rbu update database handle.
208656 ** call sqlite3_create_module() on the target database handle to
208661 ** the rbu update db handle to any required virtual table
208666 ** rbu_delta() implementation with the target database handle.
208686 ** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops
208704 ** Close an RBU handle.
208818 ** If a callback is registered with an RBU handle, it invokes it instead
208850 ** handle is opened. The RBU VFS should be installed so that the zipvfs
209148 ** RBU handle.
209189 sqlite3 *dbMain; /* target database handle */
209190 sqlite3 *dbRbu; /* rbu database handle */
209201 rbu_file *pTargetFd; /* File handle open on target db */
209233 ** space used by the RBU handle.
209253 sqlite3_file *pReal; /* Underlying file handle */
209274 ** True for an RBU vacuum handle, or false otherwise.
209529 ** Prepare the SQL statement in buffer zSql against database handle db.
209573 ** handle and SQLITE_OK is returned.
209670 ** left in the RBU handle passed as the first argument. A copy of the
209738 ** For a non-vacuum RBU handle, if the table name matches the pattern:
209750 ** For an rbu vacuum handle, a copy of the first argument is returned if
209786 ** left in the RBU handle passed as the first argument. A copy of the
209817 ** an error code is stored in the RBU handle passed as the first argument.
209846 ** RBU handle. If an error has already occurred when this function is
209871 ** error code in the rbu handle passed as the first argument. Or, if an
209894 ** error code in the RBU handle passed as the first argument.
209943 ** rbu handle error code is not already set, set the error code and error
210132 ** the RBU handle.
210311 sqlite3rbu *p, /* RBU handle */
210378 sqlite3rbu *p, /* RBU handle */
210684 ** of the RBU handle to something reflecting this.
210704 ** string, an error code is left in the rbu handle passed as the first
210758 ** string, an error code is left in the rbu handle passed as the first
211275 ** an rbu vacuum handle. */
211395 sqlite3rbu *p, /* RBU handle */
211398 sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */
211498 ** If an error occurs, leave an error code and message in the rbu handle
211575 ** Open the database handle and attach the RBU database as "rbu". If an
211576 ** error occurs, leave an error code and message in the RBU handle.
211578 ** If argument dbMain is not NULL, then it is a database handle already
211579 ** open on the target database. Use this handle instead of opening a new
211600 ** the RBU db handle now. */
211809 ** object, then the rbu handle is set to DONE state. This occurs if some
211926 ** file while the rbu handle is in capture mode. Record the page number
211973 ** Return true if the database handle passed as the only argument
212007 ** The RBU handle is currently in RBU_STAGE_OAL state, with a SHARED lock
212011 ** handle.
212091 ** message are left in the RBU handle and zero returned.
212229 ** and message is left in the RBU handle and a copy of the error code
212326 ** are determined by inspecting the rbu handle passed as the first argument.
212405 ** The RBU handle passed as the only argument has just been opened and
212406 ** the state database is empty. If this RBU handle was opened for an
212468 ** when this handle was opened, create the target database schema. */
212598 ** an rbu handle in OAL stage. If the rbu update has not started (i.e.
212601 ** where the previous rbu handle left off.
212604 ** rbu handle passed as the first argument.
212637 ** leave an error code and error message in the rbu handle.
212650 ** Allocate a private rbu VFS for the rbu handle passed as the only
212672 ** Destroy the private VFS created for the rbu handle passed as the only
212818 ** when the handle was closed and a second attempt to open the
212940 ** Allocate and return an RBU handle with all fields zeroed except for the
212954 ** Open and return a new RBU handle.
212966 ** Open a handle to begin or resume an RBU VACUUM operation.
212984 ** Return the database handle used by pRbu.
212996 ** If the error code currently stored in the RBU handle is SQLITE_CONSTRAINT,
213016 ** Close the RBU handle.
213042 /* If this is an RBU vacuum handle and the vacuum has either finished
213052 /* Close the open database handle and VFS object. */
213364 ** a file-handle opened by the same database connection on the corresponding
213408 /* Close the underlying file handle */
213628 ** Check if another file-handle holds a RESERVED lock on an rbuVfs-file.
213831 ** Open an rbu file handle.
214000 ** Open the dynamic library located at zPath and return a handle.
214030 ** Close the dynamic library handle pHandle.
214165 ** Configure the aggregate temp file size limit for this RBU handle.
215555 ** Session handle structure.
215558 sqlite3 *db; /* Database handle session is attached to */
216032 SessionTable *pTab, /* Session table handle */
216114 SessionTable *pTab, /* Table handle */
217006 sqlite3 *db, /* Database handle */
217348 sqlite3 *db, /* Database handle */
217370 ** attached to database handle $db. Do this under the cover of the db
217371 ** handle mutex. */
217415 ** database handle. Hold the db mutex while doing so. */
217739 ** values). The statement handle passed as the second argument points
217752 sqlite3_stmt *pStmt, /* Statement handle pointing at new row */
217905 sqlite3 *db, /* Database handle */
218063 sqlite3 *db = pSession->db; /* Source database handle */
218328 sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
218366 sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
218373 sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
218386 sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
218393 sqlite3_changeset_iter **pp, /* OUT: Changeset iterator handle */
218919 sqlite3_changeset_iter *pIter, /* Iterator handle */
219483 sqlite3 *db, /* Database handle */
219548 sqlite3 *db, /* Database handle */
219566 sqlite3 *db, /* Database handle */
219711 sqlite3 *db, /* Database handle */
220051 sqlite3 *db, /* Apply change to "main" db of this handle */
220159 ** changeset to the main database attached to handle "db". The supplied
220164 sqlite3 *db, /* Apply change to "main" db of this handle */
220359 ** database attached to handle "db".
220362 sqlite3 *db, /* Apply change to "main" db of this handle */
220391 ** attached to handle "db". Invoke the supplied conflict handler callback
220395 sqlite3 *db, /* Apply change to "main" db of this handle */
220416 ** attached to handle "db". Invoke the supplied conflict handler callback
220420 sqlite3 *db, /* Apply change to "main" db of this handle */
220447 sqlite3 *db, /* Apply change to "main" db of this handle */
220467 ** sqlite3_changegroup handle.
220976 ** Changeset rebaser handle.
221682 ** should be set to point to the new tokenizer handle and SQLITE_OK
221688 ** This function is invoked to delete a tokenizer handle previously
222111 sqlite3 *db; /* Database handle */
222370 ** Close the reader blob handle, if it is open.
229159 ** UDF with the SQLite handle passed as the only argument.
230573 ** the Fts5Index handle passed as the first argument.
230623 ** Close the read-only blob handle, if it is open.
230646 ** rollback since it was last used. In this case a new blob handle
230659 /* If the blob handle is not open at this point, open it and seek
231095 ** Fts5Index handle. If an error has already occurred when this function
235403 ** Open a new Fts5Index handle. If the bCreate argument is true, create
235448 ** Close a handle opened by an earlier call to sqlite3Fts5IndexOpen().
236903 ** registered with a database handle. It is used to store pointers to
237142 ** Delete a virtual table handle allocated by fts5InitVtab().
238286 /* If the cursor does not yet have a statement handle, obtain one now. */
238331 ** This function is called to handle an FTS INSERT command. In other words,
238445 sqlite3_vtab *pVtab, /* Virtual table handle */
239216 Fts5Global *pGlobal, /* FTS5 global context for db handle */
239353 sqlite3_vtab *pVtab, /* Virtual table handle */
239378 sqlite3_vtab *pVtab, /* Virtual table handle */
239429 fts5_api *pApi, /* Global context (one per db handle) */
239468 fts5_api *pApi, /* Global context (one per db handle) */
239524 fts5_api *pApi, /* Global context (one per db handle) */
239810 Fts5Storage *p, /* Storage handle */
239812 sqlite3_stmt **ppStmt, /* OUT: Prepared statement handle */
240027 ** Open a new Fts5Index handle. If the bCreate argument is true, create
240097 ** Close a handle opened by an earlier call to sqlite3Fts5StorageOpen().
240748 ** Obtain an SQLite statement handle that may be used to read data from the
240771 ** Release an SQLite statement handle obtained via an earlier call to
243140 ** Except, this version does handle the single byte case that the core
243514 sqlite3 *db; /* Database handle */