Lines Matching refs:HANDLE
765 ** CAPI3REF: Database Connection Handle
1127 ** CAPI3REF: OS Interface Open File Handle
1405 ** CAPI3REF: Mutex Handle
2016 ** allocator is engaged to handle all of SQLites memory allocation needs.
2314 ** the statement that makes them is completed (when the statement handle
2402 ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
3010 ** order for sqlite3_open16(). ^(A [database connection] handle is usually
3025 ** associated with the [database connection] handle should be released by
3200 sqlite3 **ppDb /* OUT: SQLite db handle */
3204 sqlite3 **ppDb /* OUT: SQLite db handle */
3208 sqlite3 **ppDb, /* OUT: SQLite db handle */
3508 sqlite3 *db, /* Database handle */
3511 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3515 sqlite3 *db, /* Database handle */
3518 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3522 sqlite3 *db, /* Database handle */
3525 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3529 sqlite3 *db, /* Database handle */
3532 sqlite3_stmt **ppStmt, /* OUT: Statement handle */
5025 ** CAPI3REF: Find The Database Handle Of A Prepared Statement
5027 ** ^The sqlite3_db_handle interface returns the [database connection] handle
5303 ** database table accessible using the [database connection] handle
5362 sqlite3 *db, /* Connection handle */
5752 ** CAPI3REF: A Handle To An Open BLOB
5753 ** KEYWORDS: {BLOB handle} {BLOB handles}
5768 ** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
5788 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
5797 ** ^(If the row that a BLOB handle points to is modified by an
5799 ** then the BLOB handle is marked as "expired".
5801 ** other than the one the BLOB handle is open on.)^
5803 ** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
5818 ** To avoid a resource leak, every open [BLOB handle] should eventually
5832 ** CAPI3REF: Move a BLOB Handle to a New Row
5834 ** ^This function is used to move an existing blob handle so that it points
5837 ** changed. ^The database, table and column on which the blob handle is open
5838 ** remain the same. Moving an existing blob handle to a new row can be
5839 ** faster than closing the existing handle and opening a new one.
5845 ** SQLite error code is returned and the blob handle is considered aborted.
5847 ** [sqlite3_blob_reopen()] on an aborted blob handle immediately return
5848 ** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle
5851 ** ^This function sets the database handle error code and message.
5856 ** CAPI3REF: Close A BLOB Handle
5858 ** ^Closes an open [BLOB handle].
5883 ** successfully opened [BLOB handle] in its only argument. ^The
5887 ** This routine only works on a [BLOB handle] which has been created
5897 ** ^(This function is used to read data from an open [BLOB handle] into a
5907 ** ^An attempt to read from an expired [BLOB handle] fails with an
5913 ** This routine only works on a [BLOB handle] which has been created
5925 ** ^This function is used to write data into an open [BLOB handle] from a
5929 ** ^If the [BLOB handle] passed as the first argument was not opened for
5941 ** ^An attempt to write to an expired [BLOB handle] fails with an
5943 ** before the [BLOB handle] expired are not rolled back by the
5944 handle, though of course those changes might
5945 ** have been overwritten by the statement that expired the BLOB handle
5951 ** This routine only works on a [BLOB handle] which has been created
6157 ** of a valid mutex handle. The implementations of the methods defined
6158 ** by this structure are not required to handle this case, the results
6159 ** of passing a NULL pointer instead of a valid mutex handle are undefined
6809 ** handle invalid, and will not use it with any other sqlite3_pcache_methods2
6963 ** that the backup operation has failed and pass the backup operation handle
7052 sqlite3 *pDest, /* Destination database handle */
7054 sqlite3 *pSource, /* Source database handle */
7084 ** sqlite3_unlock_notify() method with the blocked connection handle as
7231 ** registering the callback. ^The second is a copy of the database handle.
7245 ** A single database handle may have at most a single write-ahead log callback
7307 ** handle db. The specific operation is determined by the value of the
7374 sqlite3 *db, /* Database handle */
7438 ** Virtual table implementations that are required to handle OR REPLACE
8028 ** callback for a given sqlite handle.
8031 ** callback for the database handle. Each pager opened via the sqlite
8032 ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
8070 ** this magic value that the code knows to handle differently. Any
8889 ** Handle type for pages.
9065 sqlite3_pcache_page *pPage; /* Pcache object page handle */
9500 ** sqlite3_malloc() to obtain space for the file-handle structure.
10099 ** instance of the sqlite3_vtab* handle used to access the virtual table
10103 ** connection handle passed to it via the xConnect() or xCreate() method
10104 ** during initialization internally. This database connection handle may
10116 ** sqlite3_vtab* handle in the compiled query.
10131 ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
12207 ** handle case conversions for the UTF character set since the tables
13510 ** pagers the database handle is connected to. *pHighwater is always set
14802 sqlite3_file *id, /* Database file handle */
19352 /* If the db handle is not NULL, then we must hold the connection handle
21108 ** The compiler [with /fp:precise] will properly handle comparisons
21143 ** handle "db". The error code is set to "err_code".
21158 ** To clear the most recent error for sqlite handle "db", sqlite3Error
21191 ** stored by this function into the database handle using sqlite3Error().
21420 /* attempt to handle extremely small/large numbers better */
22950 HFILE h; /* Handle for accessing the file */
23168 OSTRACE(( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res ));
23435 ** Control and query of the open file handle.
23948 sqlite3_file *id, /* Handle open on database file */
24343 sqlite3_file *id, /* Write the SQLite file handle here */
24423 ** The handle should not be inherited by child processes and we don't
24457 OSTRACE(( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
25006 ** Sometimes, after a file handle is closed by SQLite, the file descriptor
25702 ** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
26476 ** handle that precludes the requested lock, return BUSY.
26623 ** Add the file descriptor used by file handle pFile to the corresponding
27694 ** handle that precludes the requested lock, return BUSY.
28519 ** This function is called to handle the SQLITE_FCNTL_SIZE_HINT
28589 ** Information and control of an open file handle.
29051 sqlite3_file *fd, /* Handle open on database file */
29719 ** handle h - as it is guaranteed that no posix locks will be released
30052 ** file handle closed. To achieve the same effect using this new
30161 ** they may be stored as part of the file handle and used by the
32200 HANDLE h; /* Handle for accessing the file */
32210 HANDLE hMutex; /* Mutex used to control access to shared lock */
32211 HANDLE hShared; /* Shared memory segment used for locking */
32260 HANDLE hHeap; /* The handle to our heap. */
32382 #define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent)
32390 #define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \
32391 LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent)
32399 #define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \
32400 LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)
32404 #define osCreateFileMapping ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
32413 #define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
32422 #define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \
32461 #define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent)
32534 #define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent)
32618 #define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \
32623 #define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \
32628 #define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[37].pCurrent)
32632 #define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[38].pCurrent)
32636 #define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \
32641 #define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \
32646 #define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
32672 #define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32681 #define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
32689 #define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32704 #define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \
32709 #define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[51].pCurrent)
32713 #define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
32728 #define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32737 #define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32754 #define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \
32872 HANDLE hHeap;
32895 HANDLE hHeap;
32915 HANDLE hHeap;
32943 HANDLE hHeap;
33390 ** Acquire a lock on the handle h
33392 static void winceMutexAcquire(HANDLE h){
33457 /* If we succeeded in making the shared memory handle, map it. */
33461 /* If mapping failed, close the shared memory handle and erase it */
33511 /* De-reference and close our copy of the shared memory handle */
33526 HANDLE *phFile,
33590 HANDLE *phFile,
33652 HANDLE *phFile,
33689 ** Move the current position of the file handle passed as the first
33725 ** It is reported that an attempt to close a handle might sometimes
33729 ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
33777 winFile *pFile = (winFile*)id; /* file handle */
33816 winFile *pFile = (winFile*)id; /* File handle */
33865 winFile *pFile = (winFile*)id; /* File handle object */
34283 ** Control and query of the open file handle.
34431 winFile hFile; /* File handle from winOpen */
34436 HANDLE hMap; /* File handle from CreateFileMapping */
34646 (sqlite3_file*)&pShmNode->hFile, /* File handle here */
34885 sqlite3_file *fd, /* Handle open on database file */
34951 HANDLE hMap; /* file-mapping handle */
35058 /* caller will handle out of memory */
35142 sqlite3_file *id, /* Write the SQLite file handle here */
35146 HANDLE h;
35598 HANDLE h;
35624 return (void(*)(void))osGetProcAddressA((HANDLE)pHandle, zSymbol);
35628 osFreeLibrary((HANDLE)pHandle);
35863 ** to handle both cases well.
35950 ** Create a new bitmap object able to handle bits between 0 and iSize,
42779 /* Figure out how much space is required for each journal file-handle
42781 ** is the maximum space required for an in-memory journal file handle
42782 handle. Note that a "regular journal-handle"
42845 ** Database file handle (pVfs->szOsFile bytes)
42846 ** Sub-journal file handle (journalFileSize bytes)
42847 ** Main journal file handle (journalFileSize bytes)
44748 ** Return the file handle for the database file associated
44842 ** sub-journal now. This is required to handle the following scenario:
45204 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
45773 sqlite3_file *pDbFd; /* File handle for the database file */
45774 sqlite3_file *pWalFd; /* File handle for WAL file */
46198 Wal *pWal, /* WAL handle */
46599 ** to must remain valid for the lifetime of the returned Wal* handle.
46608 ** *ppWal is set to point to a new WAL handle. If an error occurs,
46617 Wal **ppWal /* OUT: Allocated Wal handle */
46655 /* Open file handle on the write-ahead log file. */
47657 Wal *pWal, /* WAL handle */
47889 ** "rollback" the write position of the WAL handle back to the current
47964 ** to handle if this transaction is rolled back.
48070 Wal *pWal, /* Wal handle to write to */
48759 DbPage *pDbPage; /* Pager page handle */
48775 ** a btree handle is closed.
48778 Btree *pBtree; /* Btree handle holding this lock */
48788 /* A Btree handle
48976 u8 isIncrblobHandle; /* True if this cursor is an incr. io handle */
49075 ** of handle p (type Btree*) are internally consistent.
49126 ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
49127 ** set BtShared.db to the database handle associated with p and the
49141 ** Release the BtShared mutex associated with B-Tree handle p and
49514 Btree *pBtree, /* Handle that must hold lock */
49609 ** Query to see if Btree handle p may obtain a lock of type eLock
49671 ** by Btree handle p. Parameter eLock must be either READ_LOCK or
51094 sqlite3 *db, /* Associated database handle */
51100 Btree *p; /* Handle to return */
51420 /* Close all cursors opened via this handle. */
51432 /* Rollback any active transaction and free the handle structure.
51434 ** this handle.
51960 /* If another database handle has already opened a write transaction
52541 ** handle, downgrade to a read-only transaction. The other statements
52546 /* If the handle had any kind of transaction open, decrement the
52599 /* If the handle has a write-transaction open, commit the shared-btrees
52636 ** Return the number of write-cursors open on this handle. This is for use
52856 BtShared *pBt = p->pBt; /* Shared b-tree handle */
53122 MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
57525 ** btree as the argument handle holds an exclusive lock on the
57690 sqlite3* pDestDb; /* Destination database handle */
57696 sqlite3* pSrcDb; /* Source database handle */
57719 ** handle mutex and the mutex associated with the source BtShared
57743 ** in connection handle pDb. If such a database cannot be found, return
57794 ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
57798 ** stored in database handle pDestDb.
57808 /* Lock the source database handle. The destination database
57809 ** handle is not locked in this routine, but it is locked in
57811 ** other thread accesses the destination handle for the duration
57848 ** pDestDb handle. All that is left to do here is free the
58204 ** Release all resources associated with an sqlite3_backup* handle.
58235 /* Set the error code of the destination database handle. */
59292 ** that both the BtShared and database handle mutexes are held. */
59423 /* Handle negative integers in a single step. This is needed in the
60525 ** of all of BtShared structures accessible via the database handle
61274 ** A read or write transaction may or may not be active on database handle
61609 ** handle associated with the VM passed as an argument is about to be
61705 ** so, abort any other statements this handle currently has active.
61843 ** as the first argument to its database handle (so that they will be
61847 ** copies them to the database handle.
62083 ** the end. Hence these functions allow the caller to handle the
62697 ** sqlite3_changes() on the database handle 'db'.
63230 ** caller. Set the error code in the database handle to the same value.
63271 ** into the database handle. This block copies the error message
63272 ** from the database handle into the statement and sets the statement
64038 ** Return the sqlite3* database handle to which the prepared statement given
64039 ** in the argument belongs. This is the same database handle that was
67575 /* Link the new savepoint into the database handle's list. */
69049 ** The value of the change counter is copied to the database handle
71230 int iCol; /* Table column this handle is open on */
71239 ** the b-tree cursor associated with blob handle p to point to row iRow.
71245 ** blob handle was opened, then an error code is returned and *pzErr may
71307 ** Open a blob handle.
71316 sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
71535 ** Close a blob handle that was previously created using
71580 /* If there is no statement handle, then the blob-handle has
71586 ** returned, clean-up the statement handle.
71606 ** Read data from a blob handle.
71613 ** Write data to a blob handle.
71620 ** Query a blob handle for the size of the data.
71631 ** Move an existing blob handle to point to a different row of the same
71636 ** database handle error code and message set. If this happens, then all
71650 /* If there is no statement handle, then the blob-handle has
71826 sqlite3 *db, /* Database handle (for sqlite3DbMalloc() ) */
71932 sqlite3 *db, /* Database handle */
72120 ** Allocate space for a file-handle and open a temporary file. If successful,
72121 ** set *ppFile to point to the malloc'd file-handle and return SQLITE_OK.
72281 sqlite3 *db, /* Database handle */
72327 sqlite3 *db, /* Database handle */
72328 VdbeCursor *pCsr, /* Cursor handle for this sorter */
72588 ** as an open file handle for journal files.
72761 sqlite3_file *pJfd, /* Preallocated, blank file handle */
73050 ** Return true if the file-handle passed as an argument is
74806 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
74855 sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
79154 ** can handle (i.e. not CURRENT_TIME etc.)
79731 sqlite3 *db = pParse->db; /* Database handle */
81088 sqlite3 *db = pParse->db; /* Database handle */
81246 ** when syntax rules are reduced. The routines in this file handle the
86062 ** handle rows (possibly in other tables) that refer via a foreign key
86442 ** handle the rounding directly,
86465 ** the database handle that malloc() has failed and return NULL.
87808 ** with the database handle. The counter is set to zero each time a
88256 sqlite3 *db = pParse->db; /* Database handle */
88381 ** the lookaside buffer belonging to database handle dbMem.
88478 sqlite3 *db = pParse->db; /* Database handle */
88752 sqlite3 *db = pParse->db; /* Database handle */
89012 ** to handle INSERT statements in SQLite.
89326 int onError, /* How to handle constraint errors */
89331 ** This routine is call to handle SQL of the following forms:
89438 int onError /* How to handle constraint errors */
90604 int onError, /* How to handle constraint errors */
91841 void *handle;
91866 handle = sqlite3OsDlOpen(pVfs, zFile);
91867 if( handle==0 ){
91879 sqlite3OsDlSym(pVfs, handle, zProc);
91889 sqlite3OsDlClose(pVfs, handle);
91897 sqlite3OsDlClose(pVfs, handle);
91901 /* Append the new shared library handle to the db->aExtension array. */
91902 aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
91907 memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
91912 db->aExtension[db->nExtension++] = handle;
93379 ** new database files created using this database handle. It is only
93409 /* Only change the value of sqlite.enc if the database handle is not
94196 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
94199 sqlite3 *db, /* Database handle. */
94359 sqlite3 *db, /* Database handle. */
94431 sqlite3 *db, /* Database handle. */
94443 sqlite3 *db, /* Database handle. */
94458 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
94461 sqlite3 *db, /* Database handle. */
94511 sqlite3 *db, /* Database handle. */
94523 sqlite3 *db, /* Database handle. */
94551 ** to handle SELECT statements in SQLite.
96959 /* Generate code to handle the case of A<B
96967 /* Generate code to handle the case of A==B
96982 /* Generate code to handle the case of A>B
100171 sqlite3 *db = pParse->db; /* Database handle */
100490 ** to handle UPDATE statements.
100570 int onError /* How to handle constraint errors */
100986 ** handle rows (possibly in other tables) that refer via a foreign key
101692 ** associated with the database handle itself must be held.
101698 ** the database handle mutex is held.
106298 sqlite3 *db = pParse->db; /* Database handle */
112644 ** that we will be able to handle recursive calls into
112954 /* Free any existing lookaside buffer for this handle before
113156 ** Return the number of changes since the database handle was opened.
113164 ** database handle object, it does not close any savepoints that may be open
113894 sqlite3 *db, /* Attach the hook to this db handle */
113915 sqlite3 *db, /* Database handle */
113975 ** The mutex on database handle db should be held by the caller. The mutex
114108 ** sqlite3ApiExit(), to avoid setting the database handle error message.
114327 ** the default flags to open the database handle with. The value stored in
114555 sqlite3 **ppDb, /* OUT: Returned database handle */
114559 sqlite3 *db; /* Store allocated handle here */
114810 ** Open a new database handle.
114821 sqlite3 **ppDb, /* OUT: SQLite db handle */
114830 ** Open a new database handle.
114867 ** Register a new collation sequence with the database handle db.
114886 ** Register a new collation sequence with the database handle db.
114907 ** Register a new collation sequence with the database handle db.
114932 ** Register a collation sequence factory callback with the database handle
114950 handle
115041 sqlite3 *db, /* Connection handle */
115798 ** This is a difficult situation to handle. Returning an error
116642 sqlite3_blob *pSegments; /* Blob handle open on %_segments table */
117182 sqlite3 *db = p->db; /* Database handle */
117640 sqlite3 *db, /* Database handle */
118376 Fts3Table *p, /* Virtual table handle */
119187 Fts3Table *p, /* FTS table handle */
119270 Fts3Table *p, /* FTS3 table handle */
119344 Fts3Table *p, /* FTS3 table handle */
119381 Fts3Table *p, /* FTS virtual table handle */
119406 Fts3Cursor *pCsr, /* Virtual table cursor handle */
119472 Fts3Table *p, /* Virtual table handle */
119763 sqlite3_vtab *pVtab, /* Virtual table handle */
119857 Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
119881 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
119922 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
119949 Fts3Table *p; /* Virtual table handle */
119950 Fts3Cursor *pCursor; /* Cursor handle passed through apVal[0] */
119982 Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
119998 sqlite3_vtab *pVtab, /* Virtual table handle */
120034 sqlite3_vtab *pVtab, /* Virtual table handle */
120288 Fts3Cursor *pCsr, /* FTS cursor handle */
120388 Fts3Cursor *pCsr, /* FTS Cursor handle */
120630 Fts3Cursor *pCsr, /* FTS Cursor handle */
120710 Fts3Cursor *pCsr, /* FTS Cursor handle */
120762 Fts3Cursor *pCsr, /* FTS Cursor handle */
120877 Fts3Cursor *pCsr, /* FTS Cursor handle */
121159 Fts3Cursor *pCsr, /* FTS Cursor handle */
121366 Fts3Cursor *pCsr, /* FTS cursor handle */
121728 Fts3Cursor *pCsr, /* FTS cursor handle */
125060 /* TODO(shess) This needs expansion to handle UTF-8
125226 sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
125341 ** This function is used to obtain an SQLite prepared statement handle
125343 ** *pp is set to the requested statement handle and SQLITE_OK returned.
125352 Fts3Table *p, /* Virtual table handle */
125354 sqlite3_stmt **pp, /* OUT: Statement handle */
125433 Fts3Table *pTab, /* FTS3 table handle */
125436 sqlite3_stmt **ppStmt /* OUT: Statement handle */
125463 Fts3Table *pTab, /* Fts3 table handle */
125464 sqlite3_stmt **ppStmt /* OUT: Statement handle */
125470 Fts3Table *pTab, /* Fts3 table handle */
125472 sqlite3_stmt **ppStmt /* OUT: Statement handle */
125580 ** Set *ppStmt to a statement handle that may be used to iterate through
125866 Fts3Table *p, /* Full-text table handle */
125967 /* Locate the statement handle used to insert data into the %_content
126171 ** This function may leave an open sqlite3_blob* handle in the
126172 ** Fts3Table.pSegments variable. This handle is reused by subsequent calls
126173 ** to this function. The handle may be closed by calling the
126174 ** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy
126175 ** performance improvement, but the blob handle should always be closed
126182 Fts3Table *p, /* FTS3 table handle */
126232 ** Close the blob handle at p->pSegments, if it is open. See comments above
126654 Fts3Table *p, /* Virtual table handle */
126874 Fts3Table *p, /* Virtual table handle */
126894 Fts3Table *p, /* Virtual table handle */
126943 Fts3Table *p, /* Virtual table handle */
126944 SegmentNode **ppTree, /* IN/OUT: SegmentNode handle */
127080 Fts3Table *p, /* Virtual table handle */
127081 SegmentNode *pTree, /* SegmentNode handle */
127149 Fts3Table *p, /* Virtual table handle */
127150 SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */
127287 Fts3Table *p, /* Virtual table handle */
127410 Fts3Table *p, /* Virtual table handle */
127512 Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
127529 Fts3Table *p, /* Virtual table handle */
127530 Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
127597 Fts3Table *p, /* Virtual table handle */
127629 Fts3Table *p, /* Virtual table handle */
127638 Fts3Table *p, /* Virtual table handle */
127713 Fts3Table *p, /* Virtual table handle */
128277 ** Handle a 'special' INSERT of the form:
133151 sqlite3 *db, /* Database handle */
133152 Rtree *pRtree, /* Rtree handle */
133345 ** Register the r-tree module with database handle db. This creates the
