Lines Matching defs:current
697 ** sqlite3_exec(), then execution of the current statement stops and
1187 ** opcode causes the xFileControl method to write the current state of
1196 ** current transaction. This hint is not guaranteed to be accurate but it
1206 ** current limit. Otherwise the limit is set to the larger of the value
1207 ** of the integer pointed to and the current database size. The integer
1269 ** into the array entry, allowing the current retry settings to be
1285 ** WAL mode. If the integer is -1, then it is overwritten with the current
1295 ** mode. If the integer is -1, then it is overwritten with the current
1301 ** reason, the entire database file will be overwritten by the current
1360 ** current operation.
1377 ** the value originally pointed to is negative, and so the current limit
1506 ** by clients within the current process, only within other processes.
1756 ** method returns a Julian Day Number for the current date and time as
1761 ** ^SQLite will use the xCurrentTimeInt64() method to get the current
2307 ** the current page cache implementation into that object.)^ </dd>
2465 ** defaults to on. This configuration option queries the current setting or
2539 ** when the "current value" returned by
3423 ** ^The memory high-water mark is reset to the current value of
3645 ** time is in units of nanoseconds, however the current implementation
4025 ** Open the file "data.db" in the current directory.
4039 ** Open file "data.db" in the current directory for read-only access.
4379 ** ^Hence, to find the current value of a limit without changing it,
4484 ** [sqlite3_finalize()] relatively soon. The current implementation acts
5324 ** current row of the result set of [prepared statement] P.
5399 ** ^These routines return information about a single column of the current
6109 ** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current text encoding
6556 ** of the subtype T are preserved in current versions of SQLite;
6732 ** The sqlite3_sleep() function causes the current thread to suspend execution
6822 ** with a relative pathname are relative to the current directory
6863 ** the current directory on the sub-platforms of Win32 where that concept is
6990 ** ^The sqlite3_txn_state(D,S) interface returns the current
7008 ** These constants define the current transaction state of a database file.
7139 ** be some other error code if something goes wrong. The current
7196 ** ^In the current implementation, the update hook
7332 ** then no change is made to the heap limit. Hence, the current
7352 ** ^(The heap limits are not enforced in the current implementation
7701 ** required by the current scan. Virtual table columns are numbered from
8148 ** blob handles or active write statements, the current transaction is
8351 ** used by the current version of SQLite. Future versions of SQLite
8416 ** output variable when querying the system for the current mutex
8822 ** These interfaces return the current status of an [sqlite3_str] object.
8831 ** ^The [sqlite3_str_length(X)] method returns the current length, in bytes,
8836 ** ^The [sqlite3_str_value(X)] method returns a pointer to the current
8859 ** ^The current value of the parameter is returned into *pCurrent.
8865 ** ^(Other parameters record only the highwater mark and not the current
8871 ** If either the current value or the highwater mark is too large to
8895 ** <dd>This parameter is the current amount of memory checked out
8977 ** ^The current value of the requested parameter is written into *pCur
8980 ** reset back down to the current value.
9010 ** the current value is always zero.)^
9018 ** the current value is always zero.)^
9026 ** the current value is always zero.)^
9094 ** <dd>This parameter returns zero for the current value if and only if
9134 ** ^The current value of the requested counter is returned.
9669 ** its current transaction, either by committing it or rolling it back.
9678 ** when the blocking connections current transaction is concluded. ^The
10104 ** or continue processing the current SQL statement as appropriate.
10111 ** [sqlite3_vtab_on_conflict()] function indicates that the current ON
10186 ** current implementation, the sqlite3_vtab_nochange() interface does always
10532 ** be the NLOOP value for the current loop.
10552 ** the id of the parent of the current query element, if applicable, or
10833 ** new [sqlite3_snapshot] object that records the current state of
10853 ** <li> One or more transactions must have been written to the current wal
11256 int iLevel; /* Level of current node or entry */
11258 sqlite3_int64 iRowid; /* Rowid for current entry */
11389 ** enabled following the current call, or 0 otherwise.
11422 ** no-op, and may be used to query the current state of the session.
11450 ** is set. Passing a value less than zero does not modify the current value
11451 ** of the indirect flag, and may be used to query the current state of the
11609 ** both the accumulated records and the current contents of the database
11904 ** the name of the table affected by the current change. The buffer remains
11970 ** of columns in the table affected by the current change. Otherwise,
12001 ** of columns in the table affected by the current change. Otherwise,
12033 ** of columns in the table affected by the current change. Otherwise,
12038 ** "conflicting row" associated with the current conflict-handler callback
12370 ** current contents of the changegroup. If the inputs to the changegroup
12473 ** the current database contents - any trailing database table columns
12679 ** No current or conflicting row information is provided. The only function
13153 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
13189 ** to the total number of tokens in the current row. Or, if iCol is
13191 ** *pnToken to the number of tokens in column iCol of the current row.
13206 ** the current document. If successful, (*pz) is set to point to a buffer
13213 ** Returns the number of phrases in the current query expression.
13217 ** number of phrases in the current query, as returned by xPhraseCount,
13223 ** the query within the current row. Return SQLITE_OK if successful, or
13232 ** Query for the details of phrase match iIdx within the current row.
13247 ** Returns the rowid of the current row.
13254 ** of the current query. Specifically, a query equivalent to:
13259 ** current query is executed. Any column filter that applies to
13260 ** phrase iPhrase of the current query is included in $p. For each
13284 ** "auxiliary data". The pointer may then be retrieved by the current or any
13309 ** Returns the current auxiliary data pointer for the fts5 extension
13327 ** the current row. This is the same information as is accessible via the
13358 ** of iterating through all instances of a phrase in the current row, these
13359 ** APIs are used to iterate through the set of columns in the current row
13387 ** This is used to access token iToken of phrase iPhrase of the current
13404 ** current row. If iIdx is less than zero or greater than or equal to the
18152 ** All current savepoints are stored in a linked list starting at
18568 ** causes the operation in process to fail and for the current transaction
19245 ** The jointype starts out showing the join type between the current table
19880 int nHeight; /* Expression tree height of current sub-select */
19882 int addrExplain; /* Address of current OP_Explain opcode */
23229 const u8 *aRow; /* Data for the current row, if all on one page */
23269 ** is allocated to store the current value of the program counter, as
23270 ** well as the current memory cell array and various other frame specific
23884 ** Return the current value of a status parameter. The caller must
23901 ** The value of N is added to the current status value and the high-water
23904 ** The StatusDown() routine lowers the current value by N. The highwater
24023 int *pCurrent, /* Write current value here */
24513 ** Given the YYYY-MM-DD information current in p, determine if there
24584 ** Set the time to the current time reported by the VFS.
25019 ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
25034 ** Treat the current value of p->s as the number of
25109 ** Move the date backwards to the beginning of the current day,
25540 ** current year:
26330 ** method to get the current date and time if that method is available
26506 ** abandons the current operation and returns an error code (usually
27549 u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
27590 ** of the current key chunk. iKeyBlk is 0 if there is no key chunk.
27772 ** the current mem3.iKeyBlk with the new larger chunk. In order for
29465 ** used by the current version of SQLite. Future versions of SQLite
30013 ** used by the current version of SQLite. Future versions of SQLite
30995 ** called via macros that record the current file and line number in the
31321 int precision; /* Precision of the current field */
31324 int width; /* Width of the current field */
32258 /* Return the current length of p in bytes */
32263 /* Return the current value for p */
32394 ** current locale settings. This is important for SQLite because we
33925 ** This structure is the current state of the generator.
35035 ** Set the current error code to err_code and clear any prior error message.
38092 ** Return the current file-size of an kvvfs-file.
38320 ** Return the current time as a Julian Day number in *pTimeOut.
39490 ** all locks on that file that are owned by the current process are
39512 ** current process.
39616 ** set. It logs a message using sqlite3_log() containing the current value of
42227 ** Determine the current size of a file in bytes
42874 ** current system page-size.
43675 u8 *pOrig = (u8 *)pFd->pMapRegion; /* Pointer to current file mapping */
44782 ** the case. The chown() system call will be a no-op if the current
45249 ** Find the current time (in Universal Coordinated Time). Write into *piNow
45250 ** the current time and date as a Julian Day number times 86_400_000. In
45286 ** Find the current time (in Universal Coordinated Time). Write the
45287 ** current time and date as a Julian Day number into *prNow and
46742 # define SQLITE_WIN32_GETVERSIONEX 1 /* GetVersionEx() is current */
48026 ** The following routine suspends the current thread for at least ms
48726 ** It logs a message using sqlite3_log() containing the current value of
49238 ** Move the current position of the file handle passed as the first
49732 ** Determine the current size of a file in bytes
52348 ** current working directory has been unlinked.
52610 ** Find the current time (in Universal Coordinated Time). Write into *piNow
52611 ** the current time and date as a Julian Day number times 86_400_000. In
52658 ** Find the current time (in Universal Coordinated Time). Write the
52659 ** current time and date as a Julian Day number into *prNow and
53220 ** Return the current file-size of an memdb-file.
53581 ** Return the current time as a Julian Day number in *pTimeOut.
54504 ** use approximately abs(N*1024) bytes of memory based on the current
56386 ** by the current thread may be sqlite3_free()ed.
56895 /* Only sort the current set of entries if they need it */
57036 ** preserves the current state even if the other threads or processes
57057 /* Return an integer that records the current (uncommitted) write
57168 ** and the content in the database at the beginning of the current
57243 ** The Pager.eState variable stores the current 'state' of a pager. A
57565 ** The current 'state' of the pager object. See the comment and state
57570 ** For a real on-disk database, the current lock held on the database file -
57594 ** updating the change-counter is omitted for the current transaction.
57761 Pgno dbOrigSize; /* dbSize before the current transaction */
57969 /* Regardless of the current state, a temp-file connection always behaves
58480 ** within the current transaction (i.e. if Pager.journalOff==0).
58535 ** current location.
58613 ** written by the current transaction and rolled back into the database
58673 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
58674 ** file. The current location in the journal file is given by
58796 ** pPager at the current location. The super-journal name must be the last
58987 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
59106 ** the current journal-mode (Pager.journalMode value), as follows:
59324 ** page of data and the current value of pPager->cksumInit.
59360 ** is greater than the current value of Pager.dbSize, then playback is
59452 /* If this page has already been played back before during the current
59543 ** current.
60339 ** makes a snapshot of the database at the current point in time and preserves
60405 /* If the current number of pages in the file is greater than the
60541 ** greater than the current database size (pPager->dbSize) but those
60628 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
60927 ** maximum page count below the current size of the database.
60929 ** Regardless of mxPage, return the current maximum page count.
61054 ** current database image, in pages, OR
61057 ** be necessary to write the current content out to the sub-journal.
61061 ** routine, pagerStress() would not write the current page content to
61063 ** this happened, the correct behavior would be to restore the current
61094 ** truncation will be done when the current transaction is committed.
61617 ** Append a record of the current state of page pPg to the sub-journal.
61707 ** lead to database corruption. In the current implementation it
62195 ** If the current size of the database file is 0 but a journal file
62564 ** on the current state of the pager.
63361 ** current transaction is rolled back.
63388 ** page data. In this case the file will be updated when the current
63740 ** image was extended as part of the current transaction and then the
63769 ** updated to reflect the changes made by the current transaction and
63772 ** be used as a hot-journal and the current transaction rolled back.
63824 ** transaction are reverted and the current write-transaction is closed.
63844 ** current transaction are either expelled from the cache or reverted to
63958 ** current cache hit or miss count, according to the value of eStat. If the
64073 ** If a negative value is passed to this function, then the current
64260 ** savepoint, then save the current contents of the page into the
64405 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
64439 ** The returned indicate the current (possibly updated) journal-mode.
64529 ** Return the current journal mode.
64979 ** up to and including the current frame.
65129 ** current index block. Otherwise the iMax-th mapping entry of the
65130 ** current index block corresponds to the last entry that references
65437 WalIndexHdr hdr; /* Wal-index header for current transaction */
65562 ** current exception. Return EXCEPTION_EXECUTE_HANDLER if the exception code
67176 /* If the size of the final database is larger than the current
67705 ** have already checkpointed the WAL file and, while the current
67866 ** this routine during the current read attempt that returned WAL_RETRY.
68110 ** happened, then reading the database with the current value of
68330 /* A client using a non-current snapshot may not ignore any frames
68357 ** it takes a snapshot of the state of the WAL and wal-index for the current
68358 ** instant in time. The current thread will continue to use this snapshot.
68360 ** that extra content is ignored by the current thread.
68428 ** current read transaction was opened. Values added after the
68431 ** that any slots written before the current read transaction was
68443 ** table after the current read-transaction had started.
68682 ** "rollback" the write position of the WAL handle back to the current
68730 ** to the current log file, it is possible to overwrite the start of the
68782 ** Information about the current state of the WAL file and where
68848 ** all frames written to the wal file by the current transaction starting
68865 ** first checksum. If the first frame is frame 1 (implying that the current
69008 ** the current transaction. If so, overwrite the existing frame and
69929 ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR
70056 i8 iPage; /* Index of current page in apPage */
70062 MemPage *apPage[BTCURSOR_MAX_DEPTH-1]; /* Stack of parents of current page */
70217 Pgno v1; /* Value for second %u substitution in zPfx (current pg) */
70222 i64 nRow; /* Number of rows visited in current tree */
70449 ** Return true if the current thread holds the database connection
70988 /* Set the BtLock.eLock variable to the maximum of the current lock
71088 /* Verify that the cursor and the BtShared agree about what is the current
71247 ** function saves the current cursor key in variables pCur->nKey and
71268 ** that the current key is corrupt. In that case, it is possible that
71293 ** Save the current cursor position in the variables BtCursor.nKey
71389 ** Clear the current cursor position.
72331 /* The next slot in the chain comes before the current slot */
73534 ** The value returned is the current spill size. If zero is passed
73536 ** using mxPage of 0 is a way to query the current spill size.
73664 ** The value returned is the larger of the current reserve size and
74460 /* Move page iDbPage from its current location to page number iFreePage */
74864 /* Set the current transaction state to TRANS_NONE and unlock the
74954 ** cursors save their current positions so that they may continue
74962 ** saving the current position of a read-only cursor, all cursors,
74997 ** Set the pBt->nPage field correctly, according to the current
75348 ** BtCursor.info is a cache of the information in the current cell.
75457 ** The current implementation merely returns the size of the underlying
75588 ** If the current cursor entry uses one or more overflow pages
75613 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
75636 ** but is recast into its current form to avoid integer overflow problems
76321 u8 *pCell; /* Pointer to current cell in pPage */
76444 ** Return true (non-zero) if pCur is current pointing to the last
76516 ** search key, then we can start the search on the current page
76539 goto bypass_moveto_root; /* Start search on the current page */
76565 u8 *pCell; /* Pointer to current cell in pPage */
76764 ** to the next cell on the current page. The (slower) btreeNext() helper
76858 ** to the previous cell on the current page. The (slower) btreePrevious()
77206 ** current transaction has already run one or more incremental-vacuum
77210 ** the current page content before overwriting it.
77332 ** first trunk page in the current free-list. This block tests if it
78078 ** replaces the current contents of page pPg with the contents of the cell
78175 ** all cells - not just those inserted by the current call). If the content
78304 ** balanced. The current page, pPg, has pPg->nCell cells starting with
79462 ** A new child page is allocated and the contents of the current root
79581 ** and copy the current contents of the root-page to it. The
80116 ** from trying to save the current position of the cursor. */
80141 ** This function is used as part of copying the current row from cursor
80313 ** be preserved following this delete operation. If the current delete
80318 ** If the current delete will not cause a rebalance, then the cursor
80542 ** by extending the file), the current page at position pgnoMove
81747 ** to describe the current transaction state of Btree p.
82368 ** is the first call to backup_step() for the current backup operation),
83822 ** its link to a shallow copy and by marking any current shallow
84737 u32 szField = 0; /* Size of the current data field */
84993 ** than its current size. nOp is guaranteed to be less than or equal
85010 ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
85089 ** Add a new instruction to the list of instructions current in the
85329 ** Return the address of the current EXPLAIN QUERY PLAN baseline.
85822 ** beyond the current address. That is normally a jump to an early
85937 ** verify that the VDBE program can safely call Abort in the current
85953 ** array. Also, *pnMaxArg is set to the larger of its current value and
87604 ** Close all cursors in the current frame.
88199 ** VM, then we do either a commit or rollback of the current transaction.
88262 ** do so. If this operation returns an error, and the current statement
88264 ** current statement error code.
90496 ** Terminate the current execution of an SQL statement and reset it
91417 u32 sz; /* Size of current row in bytes */
91418 Mem sMem; /* Raw content of current row */
91457 ** Return the current time for a statement. If the current time
91554 ** to all functions within the current prepared statement using iArg as an
91630 ** Return the number of values available from the current row of the
91734 ** The following routines are used to access elements of the current row
92023 ** binding a new value to this variable invalidates the current query plan.
92968 ** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1,
93222 ** Test a register to see if it exceeds the current maximum blob size.
94130 ** to the current line should be indented for EXPLAIN output.
94185 ** Write the current address onto register P1
94214 ** and also less than the current address, then the "EXPLAIN" output
94216 ** to be not including the current Return. P2 should be the first opcode
94336 ** whether or not to rollback the current transaction. Do not rollback
95037 ** max() aggregate will set to 1 if the current row is not the minimum or
96818 ** is returned based on the current cursor position.
96937 ** and this is a RELEASE command, then the current transaction
97118 ** and that the current process needs to reread the schema. If the schema
97120 ** if the schema generation counter in P4 differs from the current
97141 /* Writes prohibited due to a prior SQLITE_CORRUPT in the current
97179 /* Store the current value of the database handles deferred constraint
98857 ** the current row from P2 into P1. If the cursors are opened on intkey
98953 ** VdbeCursor.movetoTarget to the current rowid. */
99070 ** Write into register P2 the current sorter data for sorter cursor P1.
99111 ** moves caused by other cursors that "save" the current cursors
99670 ** to the row that corresponds to the current row of P1.
99697 i64 rowid; /* Rowid that P1 current points to */
100445 ** of the current program, and the memory required at runtime to execute
100537 ** cell of the calling (parent) frame to cell P2 in the current frames
100606 ** different from the current frame if this instruction is being executed
100608 ** its current value and the value in register P2.
100684 ** per second (far exceeding the capabilities of any current hardware)
101455 ** the current row of the virtual-table of cursor P1.
101678 ** Write the current number of pages in database P1 to memory cell P2.
101692 ** Do not let the maximum page count fall below the current page count and
102969 ** A container for a temp file handle and the current amount of data
103035 ** The current element is "Apple" (the value of the key indicated by
103043 ** 5 key to the current key of PmaReader 4 (still "Grapefruit"). The PmaReader
103156 u8 *aKey; /* Pointer to current key */
104334 ** Write the current contents of in-memory linked-list pList to a level-0
104419 /* Advance the current PmaReader */
104493 ** Flush the current contents of VdbeSorter.list to a new PMA, possibly
104510 /* Select a sub-task to sort and flush the current list of in-memory
104591 /* Figure out whether or not the current contents of memory should be
104979 ** lead to the current background thread attempting to join itself.
104985 ** the current PmaReader set to point to the first key in its range.
105029 /* Use the current thread to populate aFile[1], even though this
105075 ** using the current thread.
105402 /* Write the current in-memory list to a PMA. When the VdbeSorterWrite()
105469 ** current key.
105473 int *pnKey /* OUT: Size of current key in bytes */
105496 ** Copy the current sorter key into the memory cell pOut.
105525 ** key in pVal is smaller than, equal to or larger than the current sorter
105533 Mem *pVal, /* Value to compare to current sorter key */
105886 ** Return the rowid for the current row. In this implementation, the
107675 ** Resolve symbolic names into TK_COLUMN operators for the current
108632 ** the refcount on all contexts between the current one and the
109809 ** If this maximum height is greater than the current value pointed
110255 ** Check to see if a function is usable according to current access
112217 Bitmask mCol; /* Mask for the current column */
113523 ** Generate code into the current Vdbe to evaluate the given
116832 ** routine is used to keep the mapping current.
117488 ** pStep->pExprList to ENAME_SPAN (from their current value of
118740 StatSample current; /* Current row as a StatSample */
118749 int iGet; /* Index of current sample accessed by stat_get() */
118823 sampleClear(p->db, &p->current);
118900 p->current.anDLt = (tRowcnt*)&p[1];
118903 p->current.anEq = &p->current.anDLt[nColUp];
118911 p->current.anLt = &p->current.anEq[nColUp];
118915 p->a = (struct StatSample*)&p->current.anLt[nColUp];
119096 ** p->current contains a sample that reflects the previous row of the
119107 pBest->anEq[i] = p->current.anEq[i];
119125 if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
119139 ** R Rowid for the current row. Might be a key record for
119171 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
119180 ** to the current row of the index. */
119183 p->current.anEq[i]++;
119187 p->current.anDLt[i]++;
119189 if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i];
119190 p->current.anEq[i] = 1;
119200 sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
119202 sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
119205 p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345;
119207 nLt = p->current.anLt[p->nCol-1];
119210 p->current.isPSample = 1;
119211 p->current.iCol = 0;
119212 sampleInsert(p, &p->current, p->nCol-1);
119213 p->current.isPSample = 0;
119218 p->current.iCol = i;
119219 if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){
119220 sampleCopy(p, &p->aBest[i], &p->current);
119227 sqlite3_result_int(context, p->current.anDLt[0]>0);
119321 u64 nDistinct = p->current.anDLt[i] + 1;
119326 assert( p->current.anEq[i] || p->nRow==0 );
123919 ** Return true if zName is a shadow table name in the current database
124384 ** they will persist after the current sqlite3_exec() call returns.
124802 ** Return TRUE if shadow tables should be read-only in the current
124947 ** in the current table point to the foreign key. If pFromCol==0 then
126009 ** When this function is called, *pnEntry contains the current size of
126694 ** and/or current transaction is rolled back.
127685 ** defensive mode, and the current sqlite3_prepare()
128151 /* Extract the rowid or primary key for the current row */
128565 ** computed into register regPrior. If the current pIdx index is generating
131425 ** SQLITE_CONSTRAINT_FOREIGNKEY is returned and the current
131437 ** committed, the commit fails if the current value of the counter is
132010 ** uniquely identify the current row, but the parent key is more convenient
132346 ** If the parent table of an FK constraint on the current table is
132348 ** FK counter for each row of the current table with non-NULL keys.
132589 ** If the current operation is an UPDATE, then the pChanges parameter is
133070 ** by one slot and insert a new OP_TypeCheck where the current
133533 ** a) If the current statement has a WITH clause. This is to avoid
134619 int i; /* Index of the current item from the list */
134622 Index *pIdx; /* The current Index */
134726 ** any ROLLBACK The current transaction is rolled back and
134730 ** any ABORT Back out changes from the current command
134740 ** any IGNORE The attempt in insert or update the current
135497 ** for the current row */
136299 sqlite3_stmt *pStmt = 0; /* The current SQL statement */
139240 ** The first form reports the current persistent setting for the
139242 ** pages in the page cache. The second form sets both the current
139292 ** The first form reports the current setting for the
139319 ** The first form reports the current setting for the
139349 ** The first form reports the current setting for the
139352 ** forms return the current setting.
139392 ** the current default locking mode (which may be different to
139439 ** current mode */
139574 ** The first form reports the current local setting for the
139598 ** The first form reports the current local setting for the
139601 ** current cache_size. The third form sets a spill size that
139752 ** a relative path will probably be based on the current directory for the
140759 /* Validate index entries for the current row */
140769 /* Verify that an index entry exists for the current table row */
140818 ** current key. The entry is unique if (1) any column is NULL
141104 ** after accumulating N frames in the log. Or query for the current value
141153 ** is the lessor of the current analysis_limit and the
141163 ** queried during the current connection. Off by default.
141165 ** The default MASK is and always shall be 0x0fffe. In the current
141173 ** In the current implementation, a table is analyzed if only if all of
141188 ** of the current connection.
141194 ** 10-fold. In other words, the current size of the table is
141196 ** current size is less than 1/10th the size in sqlite_stat1.
141207 Schema *pSchema; /* The current schema */
141216 int nIndex; /* Number of indexes on the current table */
141260 ** having analysis statistics during the current session, then skip it,
141332 ** Call sqlite3_busy_timeout(db, N). Return the current timeout value
141427 ** Report the current state of file logs for all databases
142196 ** this situation the current sqlite3_prepare() operation will fail,
143729 int iContinue /* Jump here to skip the current record */
143751 ** record formed by the current array of registers. If one is found,
143759 ** table is not required. Instead, the current set of values
144006 ** containing the current result row. In this case regOrig is set to the
144010 int regResult; /* Start of memory holding current results */
144200 ** on an ephemeral index. If the current row is already present
144202 ** current row to the index and proceed with writing it to the
145368 ** The current implementation interprets "LIMIT 0" to mean
145909 /* Code the current SELECT statement
145990 /* Code the current SELECT into temporary table "tab2"
146550 /* Generate a subroutine that outputs the current row of the A
146558 /* Generate a subroutine that outputs the current row of the B
149673 ** aggregate based on the current cursor position.
149883 /* This routine is called before the HAVING clause of the current
150741 ** original setting of the SF_Distinct flag, not the current setting */
150896 int iAMem; /* First Mem address for storing current GROUP BY */
151189 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
151191 ** Then compare the current GROUP BY terms against the GROUP BY terms
151216 ** This code copies current group by terms in b0,b1,b2,...
151230 ** the current row
153182 ** 1. The trigger is an exact match to the current DML statement
154040 /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
154051 /* Read the PK of the current row into an array of registers. In
154322 /* Delete the index entries associated with the current record. */
154611 /* Extract arguments from the current row of the ephemeral table and
155154 /* Save the current value of the database flags so that it can be
157331 WhereLevel *pLevel, /* The current level pointer */
157898 WhereLoop *pLoop, /* The current loop */
157981 ** The current value for the constraint is left in a register, the index
157984 ** constraint is a TK_EQ or TK_IS, then the current value might be left in
158158 ** a==5 and b IN (1,2,3). The current values for a and b will be stored
158482 ** JOIN for which the current table is not the rhs are omitted
158772 WhereLevel *pLevel, /* The current level pointer */
158819 ** for the current loop. Jump to addrBrk to break out of a loop.
159548 ** RowSetTest are such that the rowid of the current row is inserted
159738 ** rowid (or PRIMARY KEY) for the current row so that the same
159792 ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */
159850 /* Set the P2 operand of the OP_Return opcode that will end the current
159890 ** computed using the current set of tables.
160031 /* For a RIGHT OUTER JOIN, record the fact that the current row has
160042 ** will record that the current row of that table has been matched at
160532 /* If the rhs of the LIKE expression is a variable, and the current
161029 ** current term is from the first iteration. So skip this term. */
161695 ** current expression is of the form "column OP expr" where OP
162185 ** subsequent rows for the current iteration of the inner loop (because they
162759 ** current SELECT is a correlated sub-query.
162988 ** Argument pIdx represents an automatic index that the current statement
163480 /* If the ORDER BY clause contains only columns in the current
163645 ** the current configuration of "unusable" flags in sqlite3_index_info can
164716 /* In the current implementation, the rSetup value is either zero
164789 ** (3) The template has same or fewer dependencies than the current loop
164790 ** (4) The template has the same or lower cost than the current loop
165558 ** in the current query. Return true if it can be and false if not.
166522 ** All the tables in mPrereq must be scanned before the current virtual
166525 ** Conversely, all tables in mUnusable must be scanned after the current
166605 ** in the set of terms that apply to the current virtual table. */
166907 int iCur; /* Cursor number for current WhereLoop */
166977 ** the current loop for which there is term in the WHERE
167053 ** If the current term is a column of an ((?,?) IN (SELECT...))
167342 WherePath *aTo; /* The nTo best paths at the current level */
167411 ** depending on the loops added to the current plan. */
167481 ** setting as the current path candidate.
167500 /* The current candidate is no better than any of the mxChoice
168520 ** the current subquery (condition 1). The term might include variables
168522 ** invocation of the current subquery to the next.
169450 ** * The required terminal values are stored in the current row of
170002 ** linked list of WINDOW definitions for the current SELECT statement.
170809 ** store the start and end index of the current frame. */
170930 ** start,current,end
170939 ** (current) that points to the next row to return to the query engine
170942 ** on (so that it is 2 groups ahead of current). And a third (start) that
170946 ** Each cursor (start, current and end) consists of a VDBE cursor
170966 WindowCsrAndReg current;
171002 ** the arguments are extracted from the current row of csr into the
171006 ** already populated with all columns from the current row of the sub-query.
171009 ** number of rows in the current partition.
171162 ** Generate code to calculate the current values of all window functions in the
171163 ** p->pMWin list by doing a full scan of the current window frame. Store the
171262 ** return the current row of Window.iEphCsr. If all window functions are
171379 ** Return true if the current frame should be cached in the ephemeral table,
171617 p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone
171621 p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone
171626 p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone
171668 csr = p->current.csr;
171669 reg = p->current.reg;
171858 ** with arguments read from the current row of cursor csrEnd, then
171862 ** current row of csrCurrent and the current state of all
171866 ** functions with arguments read from the current row of cursor
172026 ** AGGINVERSE step processes the current row of the relevant cursor and
172066 ** In the above notation, "csr.key" means the current value of the ORDER BY
172158 int regPeer = 0; /* Peer values for current row */
172185 s.current.csr = pMWin->iEphCsr;
172186 csrWrite = s.current.csr+1;
172187 s.start.csr = s.current.csr+2;
172188 s.end.csr = s.current.csr+3;
172242 ** for the main loop, and for each cursor (start, current and end). */
172249 s.current.reg = pParse->nMem+1; pParse->nMem += nPeer;
172307 sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);
172309 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
172321 sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);
172326 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
172344 windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
172370 windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
172448 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
173040 ** current state and lookahead token. These tables are used to implement
177763 ** "sqlite3ParserAlloc" which describes the current state of the parser.
179245 ** Insert a single space character into pStr if the current string
179265 int n; /* length of current token */
179266 int tokenType; /* type of current token */
180195 ** heap subsystem was shutdown. This is only done if the current call to
180281 /* Retrieve the current mutex implementation */
180360 ** object. SQLite copies of the current page cache implementation into
182853 ** value currently being parsed. So ignore the current character
183902 ** Save the current state of the PRNG.
183924 ** x!=0 && db!=0 Seed the PRNG to the current value of the
184354 ** op==0 Store the current sqlite3TreeTrace in *ptr
184356 ** op==2 Store the current sqlite3WhereTrace in *ptr
184415 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
184448 ** to be the current setting.
185077 ** until connection pBlocker concludes its current transaction.
185361 ** New data is spilled to a new leaf node when the current node
185413 ** the current node exceeds INTERIOR_MAX bytes (default 2048).
185679 /* TODO(shess) current implementation requires pInput to be
186063 ** The current language id is stored in variable iPrevLangid.
186908 ** Store the current database page-size in bytes in p->nPgsz.
187174 ** representing the indexes maintained by the current FTS table. FTS tables
188334 ** If *pp points past the end of the current position-list, set *pi to
188336 ** increment the current value of *pi by the value read, and set *pp to
188396 int iCol1; /* The current column index in pp1 */
188397 int iCol2; /* The current column index in pp2 */
188775 ** current and previous docid (a positive number - since the list is in
189041 ** to hold the current doclist AND'd with any other doclist. If the
189228 ** In addition to its current configuration, have the Fts3MultiSegReader
189591 ** retrieve the rowid for the current row of the result set. fts3
190516 ** current position list to include only those positions that are really
190518 ** means that the phrase does not appear in the current row, doclist.pList
190961 /* Check if the current entries really are a phrase match */
191100 Fts3Expr *pRoot, /* Root of current AND/NEAR cluster */
191393 ** Invalidate the current position list for phrase pPhrase.
191633 ** Otherwise, it checks if the current row really does match the NEAR
191637 ** If the current row is a match, the position list associated with each
191641 ** match the current row, 0 is returned. The position lists may or may not
191828 ** operators and deferred tokens the current row is still a match for the
191833 ** 2. After scanning the current FTS table row for the deferred tokens,
191836 ** Or, if no error occurs and it seems the current row does match the FTS
191844 /* If there are one or more deferred tokens, load the current row into
192153 ** of the current row.
192393 sqlite3_int64 nDoc; /* 'documents' values for current csr row */
192394 sqlite3_int64 nOcc; /* 'occurrences' values for current csr row */
192860 ** xRowid - Return the current rowid for the cursor.
193486 ** Argument ppHead contains a pointer to the current head of a query
194643 int iOffset; /* current position in zInput */
194645 char *zToken; /* storage for current token */
195826 int iOffset; /* current position in pInput */
195828 char *pToken; /* storage for current token */
196427 ** xRowid - Return the current rowid for the cursor.
196640 int nTerm; /* Number of bytes in current term */
196641 char *zTerm; /* Pointer to current term */
196643 char *aDoclist; /* Pointer to doclist of current entry */
196644 int nDoclist; /* Size of doclist in current entry */
196647 ** through the current doclist (aDoclist/nDoclist).
197920 ** with the current term.
197946 ** associated with the current term.
197957 char **ppOffsetList, /* OUT: Pointer to current position-list */
198275 ** 2) The current terms (if any) are compared using memcmp(). If one
198310 ** 2) By current docid.
198515 /* First try to append the term to the current node. Return early if
198581 ** current node. Create a new node (a right-sibling of the current node).
198775 /* The current leaf node is full. Write it out to the database. */
198781 /* Add the current term to the interior node tree. The term added to
198834 /* Save the current term so that it can be used to prefix-compress the next.
199390 ** forward. Then sort the list in order of current term again.
199455 /* The current term of the first nMerge entries in the array
200039 ** the current contents of the xxx table. Otherwise, it is rebuilt based
200189 Blob key; /* Last key written to the current block */
200222 /* Output variables. Containing the current node entry. */
200257 ** (e.g. because the current entry is the last) set NodeReader->aNode to
200360 ** the current node of layer iLayer. Due to the prefix compression,
200370 /* If the current node of layer iLayer contains zero keys, or if adding
200399 /* Otherwise, flush the current node of layer iLayer to disk.
200493 ** Append the current term and doclist pointed to by cursor pCsr to the
200522 /* If the current block is not empty, and if adding this term/doclist
200523 ** to the current block would make it larger than Fts3Table.nNodeSize bytes,
200533 /* Add the current term to the parent node. The term added to the
201673 int iLangid, /* Language id for current row */
201675 i64 iDocid, /* Docid for current row. */
201770 ** Check if the contents of the FTS index match the current contents of the
201866 ** Run the integrity-check. If no error occurs and the current contents of
202386 int iCurrent; /* First token of current snippet */
202542 ** of the difference between the current element and the previous one plus
202637 Fts3Cursor *pCsr, /* Fts3 cursor for current query */
202731 ** Retrieve information about the current candidate snippet of snippet
203054 int iEnd = 0; /* Byte offset of end of current token */
203246 ** current query.
203503 int nThisLcs = 0; /* LCS for the current iterator positions */
203669 ** Populate pCsr->aMatchinfo[] with data for the current row. The
203772 ** the data in the current row. The first iteration of the for(...) loop
203775 ** expression that appear in the current row. If such a fragment of text
204172 char *zToken; /* storage for current token */
204955 ** The value (X>>4)==15 is not actually used in the current implementation
209291 ** compatibility, the current implementation raises an error if any bit
209643 u32 i; /* Index in sParse.aBlob[] of current row */
209770 ** current pointer position, which is the value.
209783 ** Append the path name for the current element.
210000 /* Return the current rowid value */
211766 ** Return the search point with the lowest current score.
211892 /* Remove the search point with the lowest current score.
217871 ** the current state of the update (how many rows have been updated, which
217947 ** not modified (this is useful for querying the current limit).
217949 ** In all cases the returned value is the current limit in bytes (zero
217958 ** Return the current amount of temp file space, in bytes, currently used by
218027 ** current state of the RBU update appliation to the RBU database.
218045 ** current RBU update was started.
218092 ** Obtain an indication as to the current stage of an RBU update or vacuum.
218103 ** will move the *-oal file to the equivalent *-wal path. If the current
218271 ** Only valid if STAGE==1. Number of rows already processed for the current
218286 ** Valid if STAGE==1. The current change-counter cookie value in the
218409 int iTnum; /* Root page of current object */
218415 int nCol; /* Number of columns in current object */
218517 int nStep; /* Rows processed for current object */
218569 ** "sz" is set to the current size of the database file.
218943 ** the current object (table/index pair).
219582 ** in order, for the current table. Before each column name, add the text
219678 ** current operation is writing content to an index. If possible, it
219915 ** Assuming the current table columns are "a", "b" and "c", and the zObj
219958 ** primary key of the current table. For example, if the table is:
220001 ** The SELECT statement iterating through the keys for the current object
220180 /* Figure out the name of the primary key index for the current table.
221099 ** Return the current wal-index header checksum for the target database
221124 ** current wal file, and obtains the set of shm locks required to safely
221414 ** The SELECT statement iterating through the keys for the current object
221896 ** lies on a different disk sector to the current one. */
222383 ** specifying the current target and state databases to start a new
222417 ** current RBU update was started.
222460 ** Return the current state of the RBU vacuum or update operation.
222918 ** Return the current file-size of an rbuVfs-file.
223422 ** Return the current time as a Julian Day number in *pTimeOut.
223674 StatPage aPage[32]; /* Pages in path to current page */
223682 int nPage; /* Number of pages in current btree */
224057 ** the current value of pCsr->iPageno.
224975 int iCurrent; /* Offset in aData[] of current change */
225000 int bIndirect; /* True if current change was indirect */
225764 ** It determines if the current pre-update-hook change affects the same row
226712 /* If the existing change is considered "indirect", but this current
227491 ** at the current version of the row (the new.* values).
227851 ** (if it is non-zero) based on the current contents of the session object
228568 /* Free the current contents of p->apValue[], if any. */
228729 ** The following function extracts information on the current change
228903 int nCol = 0; /* Number of cols in current table */
228904 u8 *abPK = 0; /* PK array for current table */
228906 SessionBuffer sPK = {0, 0, 0}; /* PK array for current table */
229453 /* COVERAGE: The (pVal->z==0) branch is never true using current versions
229468 ** transfers new.* values from the current iterator entry to statement
229579 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
230018 const char *zTab = 0; /* Name of current table */
230136 /* If there is a schema mismatch on the current table, proceed to the
230324 SessionTable *pList; /* List of tables in current patch */
231096 ** or more remote UPDATE changes. The aRec/nRec buffer contains the current
231168 ** that changeset according to the current configuration of the rebaser
231345 ** Rebase a changeset according to current rebaser configuration
231364 ** Rebase a changeset according to current rebaser configuration
231472 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
231508 ** to the total number of tokens in the current row. Or, if iCol is
231510 ** *pnToken to the number of tokens in column iCol of the current row.
231525 ** the current document. If successful, (*pz) is set to point to a buffer
231532 ** Returns the number of phrases in the current query expression.
231536 ** number of phrases in the current query, as returned by xPhraseCount,
231542 ** the query within the current row. Return SQLITE_OK if successful, or
231551 ** Query for the details of phrase match iIdx within the current row.
231566 ** Returns the rowid of the current row.
231573 ** of the current query. Specifically, a query equivalent to:
231578 ** current query is executed. Any column filter that applies to
231579 ** phrase iPhrase of the current query is included in $p. For each
231603 ** "auxiliary data". The pointer may then be retrieved by the current or any
231628 ** Returns the current auxiliary data pointer for the fts5 extension
231646 ** the current row. This is the same information as is accessible via the
231677 ** of iterating through all instances of a phrase in the current row, these
231678 ** APIs are used to iterate through the set of columns in the current row
231706 ** This is used to access token iToken of phrase iPhrase of the current
231723 ** current row. If iIdx is less than zero or greater than or equal to the
232553 int bDelete, /* True if current operation is a delete */
233184 ** current state and lookahead token. These tables are used to implement
234237 ** "sqlite3Fts5ParserAlloc" which describes the current state of the parser.
234493 ** a single column of the current row. If the phrase instances in the
234512 const Fts5ExtensionApi *pApi; /* API offered by current FTS version */
234648 /* If the parenthesis is open, and this token is not part of the current
234706 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
234827 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
234884 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
235069 ** Set *ppData to point to the Fts5Bm25Data object for the current query.
235147 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
235161 double *aFreq = 0; /* Array of phrase freq. for current row */
235164 ** for each phrase in the query for the current row. */
235180 /* Figure out the total size of the current row in tokens. */
235187 /* Determine and return the BM25 score for the current row. Or, if an
237162 ** Argument pTerm must be a synonym iterator. Return the current rowid
237265 ** checks if the current rowid really is a match, and if so populates
237270 ** otherwise. It is not considered an error code if the current rowid is
237398 ** tests if the current row contains instances of each phrase sufficiently
237590 /* Check that each phrase in the nearset matches the current row.
238228 /* If not at EOF but the current rowid occurs earlier than iFirst in
239606 ** This function is used to access the current position list for phrase
239977 ** following type. Each object, its key, and its current data are stored
240713 ** on the page. Each varint is the byte offset of the current term
240885 i64 iWriteRowid; /* Rowid for current doc being written */
240976 i64 iPrevRowid; /* Previous rowid written to current leaf */
241009 ** Byte offset within the current leaf that is the first byte of the
241013 ** Buffer containing current leaf page data. Set to NULL at EOF.
241023 ** If set, set the iterator to point to EOF after the current doclist
241034 ** For each rowid on the page corresponding to the current term, the
241039 ** Index of current term on iTermLeafPgno.
241054 i64 iLeafOffset; /* Byte offset within current leaf */
241060 /* The page and offset from which the current term was read. The offset
241061 ** is the offset of the first rowid in the current doclist. */
241075 /* Variables populated based on current entry. */
241078 int nPos; /* Number of bytes in current position list */
241147 Fts5Buffer poslist; /* Buffer containing current poslist */
241173 ** Set to the current offset within record pData.
241176 Fts5Data *pData; /* Data for current page of this level */
241182 int iLeafPgno; /* Page number of current leaf page */
241903 /* Append the current configuration cookie */
242714 /* Next entry is on the current page */
242779 /* Search for the end of the position list within the current page. */
242787 /* The next entry is on the current page. */
242826 /* Next entry is not on the current page */
242908 ** position-list content for the current rowid. Back it up so that it
242919 /* If this condition is true then the largest rowid for the current
242920 ** term may not be stored on the current page. So search forward to
242926 /* The last rowid in the doclist may not be on the current page. Search
242980 ** There is a doclist-index associated with the final term on the current
242981 ** page. If the current term is the last term on the page, load the
242992 /* Check if the current doclist ends on this page. If it does, return
243016 ** current page.
243434 ** in *pRes is the correct result of comparing the current positions of the
244100 ** function appends the position list data for the current entry to
244227 /* All data is stored on the current page. Populate the output
244320 /* All data is stored on the current page. Populate the output
244452 /* Add a segment iterator for the current contents of the hash table. */
244721 ** If the current doclist-index accumulating in pWriter->aDlidx[] is large
244820 ** Rowid iRowid has just been appended to the current leaf page. It is the
244821 ** first on the page. This function appends an appropriate entry to the current
244837 /* The current doclist-index page is full. Write it to disk and push
244944 /* If the current leaf page is full, flush it to disk. */
245143 /* Bind the current output segment id to the index-writer. This is an
245145 ** inserted into %_idx by the current writer. */
245251 int bTermWritten = 0; /* True if current term already output */
245647 /* Unless the current page footer is 0 bytes in size (in which case
246077 /* The entire doclist will fit on the current leaf. */
246086 ** loop iterates through the poslists that make up the current
246160 /* The entire poslist will fit on the current leaf. So copy
247237 ** variables (pIter->base.*) according to the contents of the current
247692 ** Return the current term.
247769 ** current row and configures the token-mapping via multiple calls to this
247835 ** Replace the current "averages" record with the contents of the buffer
247971 Fts5Data *pData1, /* One page of current hash - or NULL */
247972 int iPg1, /* Which page of the current hash is pData1 */
247986 /* Loop through the current pages of the hash table. */
247988 Fts5Data *pData = 0; /* Page ii of the current hash table */
248050 Fts5Data *pData1, /* One page of current hash - or NULL */
248051 int iPg1, /* Which page of the current hash is pData1 */
248075 ** slots each, where nPg is the current number of pages in the
248466 /* Now check that the iter.nEmpty leaves following the current leaf
248604 /* Now check that the iter.nEmpty leaves following the current leaf
248624 /* Check any rowid-less pages that occur before the current leaf. */
249663 ** structure is used to record the current transaction state. This information
249727 Fts5Buffer *pPoslist; /* Pointer to current poslist */
249743 const u8 *aPoslist; /* Position lists for current row */
249745 int aIdx[1]; /* Offsets into aPoslist for current row */
250469 ** (in the cursors sort order - ASC or DESC) than the current rowid.
250960 ** return results to the user for this query. The current cursor
251045 ** retrieve the rowid for the current row of the result set. fts5
251357 ** the current entry (if any). */
251590 ** correctly for the current view. Return SQLITE_OK if successful, or an
252121 ** Return a "position-list blob" corresponding to the current position of
252123 ** the current position-list for each phrase in the query associated with
253261 ** Store the current contents of the p->nTotalRow and p->aTotalSize[]
255314 int iNext; /* Start of character following current tri */
255325 /* Pass the current trigram back to fts5 */
256596 i64 rowid; /* This table's current rowid value */
257271 ** retrieve the rowid for the current row of the result set. The
257510 ** Return the rowid for the current row. In this implementation, the