Lines Matching refs:open
572 ** Each open SQLite database is represented by a pointer to an instance of
641 ** sqlite3_close() will leave the database connection open and return
652 ** ^If an [sqlite3] object is destroyed while a transaction is open,
728 ** is a valid and open [database connection].
736 sqlite3*, /* An open database */
769 #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
952 ** flag indicates that a file cannot be deleted when open. The
1028 ** An [sqlite3_file] object represents an open file in the
1034 ** I/O operations on the open file.
1038 const struct sqlite3_io_methods *pMethods; /* Methods for an open file */
1048 ** against the open file represented by the [sqlite3_file] object.
1085 ** VFS implementations to directly control an open file using the
1320 ** file control is sent to the open [sqlite3_file] object corresponding
1493 ** transaction open on the database or not. It is only available on unix.The
1497 ** currently has an SQL transaction open on the database. It is set to 0 if
1507 ** If there is currently no transaction open on the database, and the
1509 ** of the in-memory page cache. If there is an open transaction, or if
1685 ** the open of a journal file a no-op. Writes to this journal would
1705 ** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
1718 ** this even if the open fails. SQLite expects that the sqlite3_file.pMethods
1899 ** single thread. All open [database connections] must be closed and all
3187 sqlite3 *db, /* An open database */
3705 ** ^These routines open an SQLite database file as specified by the
3808 ** the open to fail if the database already exists. The SQLITE_OPEN_EXCLUSIVE
4677 ** statements that are holding a transaction open.
6471 ** Change the key on an open database. If the current database is not
6591 ** open can result in a corrupt database.
6725 ** to open the database originally was a URI or relative pathname.
6812 ** [sqlite3_next_stmt(D,S)] must refer to an open database
7279 ** ^So as not to open security holes in older applications that are
7713 int nRef; /* Number of open cursors */
7783 ** An instance of this object represents an open BLOB on which
7853 ** other than the one the BLOB handle is open on.)^
7869 ** To avoid a resource leak, every open [BLOB handle] should eventually
7893 ** changed. ^The database, table and column on which the blob handle is open
7915 ** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed
7920 ** the database is in auto-commit mode and there are no other open read-write
7926 ** open blob handle results in undefined behaviour. ^Calling this routine
7929 ** is passed a valid open blob handle, the values returned by the
7954 ** ^(This function is used to read data from an open [BLOB handle] into a
7956 ** from the open BLOB, starting at offset iOffset.)^
7983 ** ^(This function is used to write data into an open [BLOB handle] from a
7985 ** into the open BLOB, starting at offset iOffset.)^
8361 ** open database file, then SQLITE_ERROR is returned. ^This error
9067 ** SQLite will typically create one cache instance for each open database file,
9233 ** ^SQLite holds a write transaction open on the destination database file
9269 ** there is already a read or read-write transaction open on the
10367 ** ^If a write-transaction is open on [database connection] D when the
10514 ** number that caused the most recent I/O error or failure to open a file.
10529 ** In [WAL mode], multiple [database connections] that are open on the
10538 ** version of the database file so that it is possible to later open a new read
10555 ** If there is not already a read-transaction open on schema S when
10568 ** <li> There must not be a write transaction open on schema S of database
10608 ** is already a read transaction open on schema S, then the database handle
10614 ** ^A call to sqlite3_snapshot_open() will fail to open if the specified
10618 ** If there is already a read transaction open when this function is
10619 ** invoked, then the same read transaction remains open (on the same
10624 ** read transaction is now open on database snapshot P.
10696 ** will only be able to open the last transaction added to the WAL file
10702 ** transaction open on the database, or if the database is not a WAL mode
12208 ** caller has an open transaction or savepoint when apply_v2() is called,
15073 ** byte ranges are used for Unix. This leaves open the possibility of having
15078 ** using the same locking range we are at least open to the possibility.
15203 ** Each open file is managed by a separate instance of the "Pager" structure.
15469 const char *zFilename, /* Name of database file to open */
15471 Btree **ppBtree, /* Return open Btree* here */
15473 int vfsFlags /* Flags passed through to VFS open */
15657 Btree*, /* BTree containing table to open */
17115 VTable **aVTrans; /* Virtual tables with open transactions */
17290 #define SQLITE_STATE_OPEN 0x76 /* Database is open */
18919 ** the result there. The cursor is left open after
18932 ** is assumed to already be open. SRT_Fifo has
19284 #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
19489 sqlite3_int64 szMmap; /* mmap() space per open file */
21173 ** When testing, keep a count of the number of open files.
22527 Pgno pgnoRoot; /* Root page of the open btree cursor */
22847 VdbeCursor **apCsr; /* One element of this array for each open cursor */
24897 ** When testing, also keep a count of the number of open files.
34995 ** open properly and is not fit for general use but which can be
35839 /* A single open file. There are only two files represented by this
37012 int openFlags; /* The flags specified at open() */
37156 ** Different Unix systems declare open() in different ways. Same use
37157 ** open(const char*,int,mode_t). Others use open(const char*,int,...).
37164 int fd = open(zFile, flags, mode);
37204 { "open", (sqlite3_syscall_ptr)posixOpen, 0 },
37474 ** Invoke open(). Do so multiple times, until it either succeeds or
37509 "attempt to open \"%s\" as file descriptor %d", z, fd);
37719 ** There are never very many files open at one time and lookups are not
37854 ** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
37855 ** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
37907 ** other unixFile open on the same inode that are holding locks, the call
37955 ** An instance of the following structure is allocated for each open
38036 ** failed (e.g. "unlink", "open") and the associated file-system path,
38314 sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
38322 sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
39130 /* failed to open/create the lock directory */
39612 const char *dbPath; /* Name of the open file */
40637 ** Truncate an open file to a specified size
40834 ** Information and control of an open file handle.
41150 ** every open file that does not use shared memory (in other words, most
41151 ** open files) would have to carry around this extra information. So
41191 ** open shared memory connection.
41218 ** Use F_GETLK to check whether or not there are any readers with open
41263 unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */
41400 ** is the first to open it. In this case take an EXCLUSIVE lock on the
41409 ** process might open and use the *-shm file without truncating it.
41445 ** Open a shared-memory area associated with open database file pDbFd.
41449 ** as the open database file and has the same name as the open database
41470 ** file are currently open, in this process or in other processes, then
41555 rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShm);
41622 sqlite3_file *fd, /* Handle open on database file */
41635 /* If the shared-memory file has not yet been opened, open it now. */
42050 int h = pFd->h; /* File descriptor open on db file */
42427 unixFile *pNew /* open file object for the database file */
42491 unixFile *pNew /* the open file object */
42603 ** file descriptors open on the same file. If there were other file
42806 ** other file descriptor open on the same file is holding a file-lock.
42828 ** almost certain that an open() call on the same path will also fail.
42830 ** ignored and -1 is returned. The caller will try to open a new file
42833 ** Even if a subsequent open() call does succeed, the consequences of
42885 ** and a value suitable for passing as the third argument to open(2) is
42906 mode_t *pMode, /* OUT: Permissions to open file with */
42991 int fd = -1; /* File descriptor returned by open() */
42992 int openFlags = 0; /* Flags to pass to open() */
42993 int eType = flags&0x0FFF00; /* Type of file to open */
43010 /* If creating a super- or main-file journal, this function will open
43020 /* If argument zPath is a NULL pointer, this function is required to open
43053 ** here such that two or more threads all trying to open databases at
43101 ** open(). These must be calculated even if open() is not called, as
43129 /* Failed to open the file for read/write access. Try read-only. */
43139 int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
43762 ** close-to-open semantics for ensuring cache coherency
43839 ** The shared lock and an open file descriptor are maintained until
43894 char *dbPath; /* Name of the open file */
43985 ** sqlite3_malloc) and open the file named "path" in the file descriptor.
44003 /* 1. first try to open/create the file
44006 ** 3. if that fails, try to open the file read-only
44123 ** Takes an open conch file, copies the contents to a new path and then moves
44322 ** we'll try to use the path there, if we can't open that path, we'll
44660 /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
45338 sqlite3_vfs *pVfs; /* The VFS used to open this file */
47347 /* Create/open the named mutex */
47424 are to cleanup in case any locks remained open */
47980 ** Truncate an open file to a specified size
48589 ** Control and query of the open file handle.
48832 ** open shared memory connection.
48867 winShmNode *pFile, /* Apply locks to this open shared-memory segment */
48991 ** file are currently open, in this process or in other processes, then
49286 sqlite3_file *fd, /* Handle open on database file */
50108 /* If argument zPath is a NULL pointer, this function is required to open
50115 int eType = flags&0xFFFFFF00; /* Type of file to open */
50401 ** process has it open. Sometimes a virus scanner or indexing program
50402 ** will open a journal file shortly after it is created in order to do
50404 ** file open, we will be unable to delete it. To work around this
51355 /* An open file */
53702 ** open database file (including each in-memory database and each
55410 /* Used by readers to open (lock) and close (unlock) a snapshot. A
55668 ** open. The database size is known in this state.
55683 ** * If the database is a WAL database, then the WAL connection is open.
55684 ** * Even if a read-transaction is not open, it is guaranteed that
55706 ** * If the connection is open in rollback-mode, a RESERVED or greater
55708 ** * If the connection is open in WAL-mode, a WAL write transaction
55709 ** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully
55713 ** * The journal file may or may not be open.
55720 ** is opened (if it is not already open) and a header written to the
55725 ** * The journal file is open and the first header has been written
55738 ** * The journal file is open and the first header has been written
55822 ** connection is open in WAL mode. A WAL connection is always in one
55825 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
55947 ** An open page cache is an instance of struct Pager. A description of
56295 ** Return 0 if it is not open, or non-zero (but not 1) if it is.
56312 ** * the database file is open,
56374 ** And if the journal-mode is "OFF", the journal file must not be open.
56433 ** journal file nor the WAL file are open. This happens during
56570 ** or more open savepoints for which:
56785 ** When this is called the journal file for pager pPager must be open.
56878 ** The journal file must be open when this function is called.
56934 ** The journal file must be open when this routine is called. A journal
56955 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
57050 ** The journal file must be open when this is called. A journal header file
57069 i64 journalSize, /* Size of the open journal file in bytes */
57077 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
57275 ** if it is open and the pager is not in exclusive mode.
57293 ** bitvecs of all open savepoints. Return SQLITE_OK if successful
57319 ** closed (if it is open).
57347 /* If the operating system support deletion of open files, then
57444 ** The write transaction open on pPager is being committed (bCommit==1)
57479 ** If the journal file is open, then it is "finalized". Once a journal
57523 /* Do nothing if the pager does not have an open write transaction
58060 ** If successful, open the super-journal file for reading.
58150 ** If the main database file is not open, or the pager is not in either
58216 ** of the open database file. The sector size will be used
58793 ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
58836 ** If the database is not empty and the *-wal file exists, open the pager
59161 ** attempts to open a temporary file. This information is used for
59418 ** This function may only be called when a read-transaction is open on
59523 ** if one or more savepoints are open, present in the savepoint
59527 ** Pager object may still have open savepoints (Pager.nSavepoint!=0),
59700 /* If it is open, sync the journal file before calling UnlockAndRollback.
59701 ** If this is not done, then an unsynced portion of the open journal
59911 ** is not yet open, it is created and opened before any data is
59939 /* If the file is a temp-file has not yet been opened, open it now. It
60015 ** Ensure that the sub-journal file is open. If it is already open, this
60041 ** for all open savepoints before returning.
60063 /* If the sub-journal was opened successfully (or was already open),
60216 ** The zFilename argument is the path to the database file to open.
60246 const char *zFilename, /* Name of the database file to open */
60327 ** as it will not be possible to open the journal file or even
60678 ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
60697 ** not to delete the journal file if it is already open due to
60729 /* If we cannot open the rollback journal file in order to see if
60769 ** the contents of the page cache and rolling back any open journal
60817 ** EXCLUSIVE lock. If it were, another process might open the
60835 /* If it is not already open and the file exists on disk, open the
60837 ** in exclusive-access mode the file descriptor will be kept open
60886 /* This branch is taken if an error occurs while trying to open
60955 /* If there is a WAL file in the file-system, open this database in WAL
61041 ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
61058 Pager *pPager, /* The pager open on the database file */
61160 Pager *pPager, /* The pager open on the database file */
61170 ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
61232 Pager *pPager, /* The pager open on the database file */
61248 Pager *pPager, /* The pager open on the database file */
61284 ** The btree layer always holds page1 open until the end, so these first
61322 ** to the start of it. If there are active savepoints, open the sub-journal
61327 ** If the journal file is already open (as it may be in exclusive mode),
61329 ** already open file.
61357 /* Open the journal file if it is not already open. */
61387 /* Write the first journal header to the journal file and open
61473 ** when it has an open transaction, but never to DBMOD or FINISHED.
61553 ** of any open savepoints as appropriate.
61560 ** been started. The journal file may or may not be open at this point.
61574 ** rollback journal might not yet be open. Open it now if this is the case.
61622 /* If the statement journal is open and the page is not in it,
62243 ** If a write transaction is open, then all changes made within the
62410 ** Check that there are at least nSavepoint savepoints open. If there are
62411 ** currently less than nSavepoints open, then open one or more savepoints
63112 ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
63151 ** If the pager passed as the first argument is open on a real database
63153 ** is not already open, make an attempt to open it now. If successful,
63158 ** If the pager is open on a temp-file (or in-memory database), or if
63159 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
63177 /* Close any rollback journal previously open */
63206 /* If the log file is not already open, but does exist in the file-system,
63268 ** currently open. Otherwise, return an error.
63311 ** The caller currently has a read transaction open on the database.
63864 ** An open write-ahead log file is represented by an instance of the
64804 ** Close an open wal-index.
64835 sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */
64836 sqlite3_file *pDbFd, /* The open database file */
65770 ** open, and hence the content of the shared-memory is unreliable,
67462 /* Try to open on pSnapshot when the next read-transaction starts
67489 ** The caller currently has a read transaction open on the database.
67893 ** this object for every database file that it has open. This structure
67935 ** of the Btree structure. At most one of these may open a write transaction,
67994 BtCursor *pCursor; /* A list of all open cursors */
68012 int nTransaction; /* Number of open transactions (read + write) */
68022 Btree *pWriter; /* Btree with currently open write transaction */
68037 #define BTS_NO_WAL 0x0020 /* Do not open write-ahead-log files */
68915 /* If requesting a write-lock, then the Btree must have an open write
68917 ** must be an open write transaction on the file itself.
69038 ** This function assumes that Btree p has an open read or write
69150 ** to invalidate any incrblob cursors that are open on the
69155 ** cursors open on any row within the table with root-page pgnoRoot.
69159 ** only those incrblob cursors open on that specific row.
69278 ** If the cursor is open on an intkey table, then the integer key
69280 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
69356 ** Save the positions of all cursors (except pExcept) that are open on
69431 BtCursor *pCur, /* Cursor open on the btree to be searched */
71065 ** and we are in shared cache mode, then the open will fail with an
71453 ** Close an open database and invalidate all cursors.
71462 /* Verify that no other cursors have this Btree open */
71864 ** in WAL mode. If the log is not already open, open it now. Then
71992 ** Return the number of cursors open on pBt. This is for use
72288 ** open savepoints. If the second parameter is greater than 0 and
72289 ** the sub-journal is not already open, then it will be opened here.
72408 ** Move the open database page pDbPage to location iFreePage in the
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
73054 ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
73055 ** are no active savepoints and no other statement-transactions open,
73070 ** SQL statements. It is illegal to open, release or rollback any
73088 ** transaction remains open.
73122 ** the caller already has at least a read-only transaction open
73124 ** the caller is assumed to have an open write transaction.
73136 ** cursors open with wrFlag==0 on the same table. Otherwise
73163 Pgno iTable, /* Root page of table to open */
73179 ** and that no other connection has any open cursor that conflicts with
73230 Pgno iTable, /* Root page of table to open */
73243 Pgno iTable, /* Root page of table to open */
74027 ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
77647 /* Save the positions of any other cursors open on this table.
77697 ** cursors open on the row being replaced */
77929 ** pSrc into cursor pDest. If the cursors are open on intkey tables, then
78141 /* Save the positions of any other cursors open on this table before
78149 ** invalidate any incrblob cursors open on the row being deleted. */
78290 ** held by open cursors.
78332 /* Save the positions of any open cursors. This is required in
78483 ** This routine will fail with SQLITE_LOCKED if there are any open
78499 /* Invalidate all incrblob cursors open on table iTable (assuming iTable
78512 ** Delete all information from the single table that pCur is open on.
78525 ** This routine will fail with SQLITE_LOCKED if there are any open
78636 ** has a read or write transaction open on the database.
79459 ** open so it is safe to access without the BtShared mutex.
79472 ** open so it is safe to access without the BtShared mutex.
79492 ** Return SQLITE_LOCKED if this or any other connection has an open
79620 /* Save the positions of all other cursors open on this table. This is
79624 ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
79632 ** (a) the cursor is open for writing,
79633 ** (b) there is a read/write transaction open,
79670 /* If setting the version fields to 1, do not automatically open the
79771 int bDestLocked; /* True once a write-transaction is open on pDest */
79865 ** Check that there is no open read-transaction on the b-tree passed as the
79867 ** is an open read-transaction, return SQLITE_ERROR and leave an error
79941 ** error was hit. Or there is a transaction open on the destination
80123 /* If there is no open read-transaction on the source database, open
80373 /* If a transaction is still open on the Btree, roll it back. */
85212 ** open cursors.
85319 ** (b) how many database files have open write transactions, not
85321 ** one database file has an open write transaction, a super-journal
91444 ** Exit immediately. All open cursors, etc are closed
93097 ** If P1 is not an open cursor, then this opcode is a no-op.
93976 ** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
93993 /* Assert that the p1 parameter is valid. Also that if there is no open
94005 ** statements (i.e. open read/write incremental blob handles).
94007 sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress");
94029 /* If there is no open transaction, then mark this as a special
94369 ** must be started or there must be an open cursor) before
94470 ** checks to see if the cursor on P1 is already open on the same
94472 ** if the cursor is already open, do not reopen it.
94541 /* If the cursor is not currently open or is open on a different
94659 ** opened for a database. Since there is already an open cursor when this
94723 /* If the ephermeral table is already open and has no duplicates from
94856 ** currently open, this instruction is a no-op.
95393 ** If cursor P1 is not open or if P1 is set to a NULL row using the
95600 ** P1 is the index of a cursor open on an SQL table btree (with integer
95624 ** P1 is the index of a cursor open on an SQL table btree (with integer
95982 ** P1 and P2 are both open cursors. Both must be opened on the same type
96339 ** If cursor P1 is not previously opened, open it now to a special
96348 /* If the cursor is not already open, create a special kind of
96566 ** not open then the behavior is undefined.
96773 ** P1 is an open index cursor and P3 is a cursor on the corresponding
97091 ** that is open on cursor P1.
97295 ** Do an analysis of the currently open database. Store in
99283 int nByte; /* Size of open blob, in bytes */
99285 u16 iCol; /* Table column this handle is open on */
99287 sqlite3_stmt *pStmt; /* Statement holding cursor open */
99342 zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
99422 sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable);
99426 sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable);
99431 sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
99496 zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
100164 ** A single-threaded IncrMerger does not open any temporary files of its
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,
101339 /* If the first temporary PMA file has not been opened, open it now. */
101935 ** incremental-reader (pReadr->pIncr!=0). This function serves to open
103037 ** This structure is a subclass of sqlite3_file. Each open memory-journal
103398 ** The file-handle passed as the only argument is open on a journal file.
109646 ** There must be an open cursor to pTab in iTable when this routine
115586 int iIdxCur; /* Cursor open on index being analyzed */
116667 ** * Transaction currently open
116823 zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
117660 /* The cookie mask contains one bit for each database file open.
118063 ** Look through the list of open database files in db->aDb[] and if
122659 ** Make sure the TEMP database is open and available for use. Return
122676 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
123552 sqlite3 *db, /* An open database */
124008 int addrEphOpen = 0; /* Instruction to open the Ephemeral table */
124272 /* Unless this is a view, open cursors for the table we are
124396 ** 1. iDataCur is an open cursor on the btree that is the canonical data
124401 ** 2. Read/write cursors for all indices of pTab must be open as
124570 ** 1. A read/write cursor "iDataCur" must be open on the canonical storage
124575 ** 2. Read/write cursors for all indices of pTab must be open as
124619 ** iCur is the index of a cursor open on the pTab table and pointing to
127220 ** an INSERT does not open a statement transaction.
127571 ** generated for will not open a statement transaction. */
127630 int iCursor, /* The open cursor on the table */
128623 ** (2) open pTab as cursor iCur.
129211 ** open write cursor to <table> and its indices
129229 ** open a write cursor to <table>
129230 ** open read cursor on <table2>
129234 ** open a write cursor on the <table> index
129235 ** open a read cursor on the corresponding <table2> index
129253 ** B: open write cursor to <table> and its indices
129274 ** B: open temp table
129278 ** M: open write cursor to <table> and its indices
129552 ** B: open temp table
129648 /* If this is not a view, open the table and and all indices */
131223 ** code to open and initialized those cursors.
132040 int (*open)(const char*,sqlite3**);
132392 #define sqlite3_open sqlite3_api->open
133314 "unable to open shared library [%.*s]", SQLITE_MAX_PATHLEN, zFile);
133349 ** default so as not to open security holes in older applications.
134389 ** If the TEMP database is open, close it and mark the database schema
134655 ** pragma, make sure it is open.
134680 ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file
137103 pragmaVtabOpen, /* xOpen - open a cursor */
137389 /* Create a cursor to hold the database open
137400 ** on the b-tree database, open one now. If a transaction is opened, it
137492 /* Ticket #2804: When we open a database in the newer file format,
137648 ** on the b-tree database, open one now. If a transaction is opened, it
139533 /* If the destination is DistFifo, then cursor (iParm+1) is open
139669 /* If the destination is DistQueue, then cursor (iParm+1) is open
145443 /* If the output is destined for a temporary table, open that table.
145842 ** clause, cancel the ephemeral table open coded earlier.
148029 int iEph, /* Cursor for open eph. table */
148437 /* If REPLACE conflict resolution might be invoked, open cursors on all
149050 ** create and open the ephemeral table in which the records created from
149440 ** In this case parameter iCur is a cursor open on the table b-tree that
149846 /* At this point, there is a write transaction open on both the
149911 /* Currently there is an SQL level transaction open on the vacuum
150948 ** not currently open, invoke the xBegin method now.
151000 ** virtual tables that currently have an open transaction. Pass iSavepoint
151006 ** an open transaction is invoked.
153049 ** Cursor iCur is open on an intkey b-tree (a table). Register iRowid contains
153050 ** a rowid value just read from cursor iIdxCur, open on index pIdx. This
156709 ** then also write the indices of open cursors used by ONEPASS
158493 ** reduced by an additional 75%. This means that, by default, an open-ended
159262 int iCur, /* Cursor open on pIdx */
162117 ** And so forth. This routine generates code to open those VDBE cursors
162540 Table *pTab; /* Table to open */
162897 ** return the null-row. So, if the cursor is not open yet,
163081 ** table being referenced really is open.
164704 ** a mere detail). It keeps three cursors open on the temp table. One
165590 ** // Rewind three cursors, all open on the eph table.
174549 ** Close all open savepoints. This function only manipulates fields of the
174550 ** database handle object, it does not close any savepoints that may be open
174649 /* If a transaction is open, the disconnectAllVtab() call above
174715 ** leaves the connection open if there are unfinalized prepared
174752 /* If a transaction is open, roll it back. This also ensures that if
174853 ** attempts to use that cursor. Read cursors remain open and valid
175033 /* SQLITE_CANTOPEN */ "unable to open database file",
175922 ** not currently open in WAL mode.
175924 ** If a transaction is open on the database being checkpointed, this
176320 ** the default flags to open the database handle with. The value stored in
176325 ** the VFS that should be used to open the database file. *pzFile is set to
176326 ** point to a buffer containing the name of the file to open. The value
177207 return sqlite3ReportError(SQLITE_CANTOPEN, lineno, "cannot open file");
177570 ** while any database connection is open results in undefined and
179542 sqlite3_blob *pSegments; /* Blob handle open on %_segments table */
180571 ** is preceded by zFunc and an open bracket, and followed by a closed
186740 /* Skip over any whitespace before checking for a keyword, an open or
186773 ** the next byte must contain either whitespace, an open or close
191074 ** This function may leave an open sqlite3_blob* handle in the
191137 ** Close the blob handle at p->pSegments, if it is open. See comments above
193525 sqlite3_int64 iAbsLevel, /* Absolute level to open */
196444 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
200836 jsonEachOpenEach, /* xOpen - open a cursor */
200864 jsonEachOpenTree, /* xOpen - open a cursor */
201112 u32 nCursor; /* Number of open cursors */
201684 /* If unable to open an sqlite3_blob on the desired row, that can only
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
204433 rtreeOpen, /* xOpen - open a cursor */
205227 /* If there is not already an open transaction, open one now. This is
207095 rtreeOpen, /* xOpen - open a cursor */
207364 ** ("International Components for Unicode", an open-source library
208521 ** While an RBU handle is open, a SHARED lock may be held on the target
208592 ** The vacuum can be resumed by calling this function to open a new RBU
208649 ** The first argument passed to this function must be a valid, open, RBU
209201 rbu_file *pTargetFd; /* File handle open on target db */
211048 int nParen = 0; /* Number of open parenthesis */
211579 ** open on the target database. Use this handle instead of opening a new
212041 /* Re-open the databases. */
212308 ** is already a transaction open, so the prepared statement cannot
212813 /* If the first attempt to open the database file fails and the bRetry
212818 ** when the handle was closed and a second attempt to open the
213039 /* Close any open statement handles. */
213052 /* Close the open database handle and VFS object. */
213242 ** that the values are always trustworthy within an open transaction.
213265 ** Then, when xOpen() is called to open the *-wal file associated with
213884 /* This call is to open a *-wal file. Intead, open the *-oal. */
213962 ** causing SQLite to call xOpen() to open it. This call will also
215061 statOpen, /* xOpen - open a cursor */
215489 dbpageOpen, /* xOpen - open a cursor */
222358 ** The various operations on open token or token prefix iterators opened
222370 ** Close the reader blob handle, if it is open.
222413 ** Also close any open blob handles.
225538 ** to be an open-quote character (see function fts5_isopenquote()).
230300 sqlite3_blob *pReader; /* RO incr-blob open on %_data table */
230623 ** Close the read-only blob handle, if it is open.
230659 /* If the blob handle is not open at this point, open it and seek
236897 int eState; /* 0==closed, 1==open, 2==synced */
236898 int iSavepoint; /* Number of open savepoints (0 -> none) */
236913 Fts5Cursor *pCsr; /* First in list of all open cursors */
237669 ** open on table pTab.
238455 /* A transaction must be open when this is called. */
244552 stmtOpen, /* xOpen - open a cursor */