Lines Matching defs:current
694 ** sqlite3_exec(), then execution of the current statement stops and
1180 ** opcode causes the xFileControl method to write the current state of
1189 ** current transaction. This hint is not guaranteed to be accurate but it
1199 ** current limit. Otherwise the limit is set to the larger of the value
1200 ** of the integer pointed to and the current database size. The integer
1262 ** into the array entry, allowing the current retry settings to be
1278 ** WAL mode. If the integer is -1, then it is overwritten with the current
1288 ** mode. If the integer is -1, then it is overwritten with the current
1294 ** reason, the entire database file will be overwritten by the current
1353 ** current operation.
1370 ** the value originally pointed to is negative, and so the current limit
1500 ** by clients within the current process, only within other processes.
1750 ** method returns a Julian Day Number for the current date and time as
1755 ** ^SQLite will use the xCurrentTimeInt64() method to get the current
2281 ** the current page cache implementation into that object.)^ </dd>
2496 ** when the "current value" returned by
3340 ** ^The memory high-water mark is reset to the current value of
3562 ** time is in units of nanoseconds, however the current implementation
3928 ** Open the file "data.db" in the current directory.
3942 ** Open file "data.db" in the current directory for read-only access.
4279 ** ^Hence, to find the current value of a limit without changing it,
4384 ** [sqlite3_finalize()] relatively soon. The current implementation acts
5192 ** current row of the result set of [prepared statement] P.
5267 ** ^These routines return information about a single column of the current
5869 ** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current encoding
6303 ** of the subtype T are preserved in current versions of SQLite;
6471 ** Change the key on an open database. If the current database is not
6503 ** The sqlite3_sleep() function causes the current thread to suspend execution
6586 ** with a relative pathname are relative to the current directory
6627 ** the current directory on the sub-platforms of Win32 where that concept is
6754 ** ^The sqlite3_txn_state(D,S) interface returns the current
6772 ** These constants define the current transaction state of a database file.
6903 ** be some other error code if something goes wrong. The current
6960 ** ^In the current implementation, the update hook
7090 ** then no change is made to the heap limit. Hence, the current
7110 ** ^(The heap limits are not enforced in the current implementation
7464 ** required by the current scan. Virtual table columns are numbered from
7921 ** blob handles or active write statements, the current transaction is
8124 ** used by the current version of SQLite. Future versions of SQLite
8187 ** output variable when querying the system for the current mutex
8590 ** These interfaces return the current status of an [sqlite3_str] object.
8599 ** ^The [sqlite3_str_length(X)] method returns the current length, in bytes,
8604 ** ^The [sqlite3_str_value(X)] method returns a pointer to the current
8627 ** ^The current value of the parameter is returned into *pCurrent.
8633 ** ^(Other parameters record only the highwater mark and not the current
8639 ** If either the current value or the highwater mark is too large to
8663 ** <dd>This parameter is the current amount of memory checked out
8745 ** ^The current value of the requested parameter is written into *pCur
8748 ** reset back down to the current value.
8778 ** the current value is always zero.)^
8786 ** the current value is always zero.)^
8794 ** the current value is always zero.)^
8862 ** <dd>This parameter returns zero for the current value if and only if
8902 ** ^The current value of the requested counter is returned.
9437 ** its current transaction, either by committing it or rolling it back.
9446 ** when the blocking connections current transaction is concluded. ^The
9872 ** or continue processing the current SQL statement as appropriate.
9879 ** [sqlite3_vtab_on_conflict()] function indicates that the current ON
9965 ** current implementation, the sqlite3_vtab_nochange() interface does always
10287 ** be the NLOOP value for the current loop.
10551 ** new [sqlite3_snapshot] object that records the current state of
10571 ** <li> One or more transactions must have been written to the current wal
10944 int iLevel; /* Level of current node or entry */
10946 sqlite3_int64 iRowid; /* Rowid for current entry */
11073 ** enabled following the current call, or 0 otherwise.
11097 ** no-op, and may be used to query the current state of the session.
11125 ** is set. Passing a value less than zero does not modify the current value
11126 ** of the indirect flag, and may be used to query the current state of the
11284 ** both the accumulated records and the current contents of the database
11579 ** the name of the table affected by the current change. The buffer remains
11645 ** of columns in the table affected by the current change. Otherwise,
11676 ** of columns in the table affected by the current change. Otherwise,
11708 ** of columns in the table affected by the current change. Otherwise,
11713 ** "conflicting row" associated with the current conflict-handler callback
11972 ** current contents of the changegroup. If the inputs to the changegroup
12075 ** the current database contents - any trailing database table columns
12260 ** No current or conflicting row information is provided. The only function
12734 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
12770 ** to the total number of tokens in the current row. Or, if iCol is
12772 ** *pnToken to the number of tokens in column iCol of the current row.
12784 ** current document. If successful, (*pz) is set to point to a buffer
12791 ** Returns the number of phrases in the current query expression.
12799 ** the query within the current row. Return SQLITE_OK if successful, or
12808 ** Query for the details of phrase match iIdx within the current row.
12822 ** Returns the rowid of the current row.
12829 ** of the current query. Specifically, a query equivalent to:
12834 ** current query is executed. Any column filter that applies to
12835 ** phrase iPhrase of the current query is included in $p. For each
12855 ** "auxiliary data". The pointer may then be retrieved by the current or any
12880 ** Returns the current auxiliary data pointer for the fts5 extension
12898 ** the current row. This is the same information as is accessible via the
12929 ** of iterating through all instances of a phrase in the current row, these
12930 ** APIs are used to iterate through the set of columns in the current row
17514 ** All current savepoints are stored in a linked list starting at
17920 ** causes the operation in process to fail and for the current transaction
18575 ** The jointype starts out showing the join type between the current table
19192 int nHeight; /* Expression tree height of current sub-select */
19194 int addrExplain; /* Address of current OP_Explain opcode */
22532 const u8 *aRow; /* Data for the current row, if all on one page */
22558 ** is allocated to store the current value of the program counter, as
22559 ** well as the current memory cell array and various other frame specific
23168 ** Return the current value of a status parameter. The caller must
23185 ** The value of N is added to the current status value and the high-water
23188 ** The StatusDown() routine lowers the current value by N. The highwater
23307 int *pCurrent, /* Write current value here */
23837 ** Set the time to the current time reported by the VFS.
24222 ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
24235 ** Treat the current value of p->s as the number of
24309 ** Move the date backwards to the beginning of the current day,
25156 ** method to get the current date and time if that method is available
25332 ** abandons the current operation and returns an error code (usually
26375 u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
26416 ** of the current key chunk. iKeyBlk is 0 if there is no key chunk.
26598 ** the current mem3.iKeyBlk with the new larger chunk. In order for
28291 ** used by the current version of SQLite. Future versions of SQLite
28839 ** used by the current version of SQLite. Future versions of SQLite
29801 ** called via macros that record the current file and line number in the
30159 int precision; /* Precision of the current field */
30162 int width; /* Width of the current field */
31084 /* Return the current length of p in bytes */
31089 /* Return the current value for p */
31220 ** current locale settings. This is important for SQLite because we
32646 ** This structure is the current state of the generator.
33712 ** Set the current error code to err_code and clear any prior error message.
36508 ** Return the current file-size of an kvvfs-file.
36732 ** Return the current time as a Julian Day number in *pTimeOut.
37903 ** all locks on that file that are owned by the current process are
37925 ** current process.
38029 ** set. It logs a message using sqlite3_log() containing the current value of
40687 ** Determine the current size of a file in bytes
41336 ** current system page-size.
42051 u8 *pOrig = (u8 *)pFd->pMapRegion; /* Pointer to current file mapping */
43146 ** the case. The chown() system call will be a no-op if the current
43450 ** current working directory has been unlinked.
43658 ** Find the current time (in Universal Coordinated Time). Write into *piNow
43659 ** the current time and date as a Julian Day number times 86_400_000. In
43695 ** Find the current time (in Universal Coordinated Time). Write the
43696 ** current time and date as a Julian Day number into *prNow and
45164 # define SQLITE_WIN32_GETVERSIONEX 1 /* GetVersionEx() is current */
46448 ** The following routine suspends the current thread for at least ms
47148 ** It logs a message using sqlite3_log() containing the current value of
47660 ** Move the current position of the file handle passed as the first
48154 ** Determine the current size of a file in bytes
50754 ** current working directory has been unlinked.
51016 ** Find the current time (in Universal Coordinated Time). Write into *piNow
51017 ** the current time and date as a Julian Day number times 86_400_000. In
51064 ** Find the current time (in Universal Coordinated Time). Write the
51065 ** current time and date as a Julian Day number into *prNow and
51626 ** Return the current file-size of an memdb-file.
51987 ** Return the current time as a Julian Day number in *pTimeOut.
52882 ** use approximately abs(N*1024) bytes of memory based on the current
54764 ** by the current thread may be sqlite3_free()ed.
55273 /* Only sort the current set of entries if they need it */
55413 ** preserves the current state even if the other threads or processes
55434 /* Return an integer that records the current (uncommitted) write
55541 ** and the content in the database at the beginning of the current
55616 ** The Pager.eState variable stores the current 'state' of a pager. A
55952 ** The current 'state' of the pager object. See the comment and state
55957 ** For a real on-disk database, the current lock held on the database file -
55981 ** updating the change-counter is omitted for the current transaction.
56148 Pgno dbOrigSize; /* dbSize before the current transaction */
56366 /* Regardless of the current state, a temp-file connection always behaves
56881 ** within the current transaction (i.e. if Pager.journalOff==0).
56936 ** current location.
57051 ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
57052 ** file. The current location in the journal file is given by
57174 ** pPager at the current location. The super-journal name must be the last
57365 ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
57484 ** the current journal-mode (Pager.journalMode value), as follows:
57684 ** page of data and the current value of pPager->cksumInit.
57711 ** Report the current page size and number of reserved bytes back
57749 ** is greater than the current value of Pager.dbSize, then playback is
57846 /* If this page has already been played back before during the current
57951 ** current.
58752 ** makes a snapshot of the database at the current point in time and preserves
58818 /* If the current number of pages in the file is greater than the
58954 ** greater than the current database size (pPager->dbSize) but those
59041 ** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
59342 ** maximum page count below the current size of the database.
59344 ** Regardless of mxPage, return the current maximum page count.
59469 ** current database image, in pages, OR
59472 ** be necessary to write the current content out to the sub-journal.
59476 ** routine, pagerStress() would not write the current page content to
59478 ** this happened, the correct behavior would be to restore the current
59509 ** truncation will be done when the current transaction is committed.
60038 ** Append a record of the current state of page pPg to the sub-journal.
60134 ** lead to database corruption. In the current implementation it
60637 ** If the current size of the database file is 0 but a journal file
61006 ** on the current state of the pager.
61788 ** current transaction is rolled back.
61815 ** page data. In this case the file will be updated when the current
62160 ** image was extended as part of the current transaction and then the
62189 ** updated to reflect the changes made by the current transaction and
62192 ** be used as a hot-journal and the current transaction rolled back.
62244 ** transaction are reverted and the current write-transaction is closed.
62264 ** current transaction are either expelled from the cache or reverted to
62378 ** current cache hit or miss count, according to the value of eStat. If the
62493 ** If a negative value is passed to this function, then the current
62718 ** savepoint, then save the current contents of the page into the
62863 ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
62897 ** The returned indicate the current (possibly updated) journal-mode.
62987 ** Return the current journal mode.
63429 ** up to and including the current frame.
63579 ** current index block. Otherwise the iMax-th mapping entry of the
63580 ** current index block corresponds to the last entry that references
63887 WalIndexHdr hdr; /* Wal-index header for current transaction */
65478 /* If the size of the final database is larger than the current
65914 ** have already checkpointed the WAL file and, while the current
66044 ** this routine during the current read attempt that returned WAL_RETRY.
66251 ** happened, then reading the database with the current value of
66370 ** it takes a snapshot of the state of the WAL and wal-index for the current
66371 ** instant in time. The current thread will continue to use this snapshot.
66373 ** that extra content is ignored by the current thread.
66460 /* A client using a non-current snapshot may not ignore any frames
66536 ** current read transaction was opened. Values added after the
66539 ** that any slots written before the current read transaction was
66551 ** table after the current read-transaction had started.
66756 ** "rollback" the write position of the WAL handle back to the current
66801 ** to the current log file, it is possible to overwrite the start of the
66853 ** Information about the current state of the WAL file and where
66927 ** all frames written to the wal file by the current transaction starting
66944 ** first checksum. If the first frame is frame 1 (implying that the current
67085 ** the current transaction. If so, overwrite the existing frame and
67983 ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR
68110 i8 iPage; /* Index of current page in apPage */
68116 MemPage *apPage[BTCURSOR_MAX_DEPTH-1]; /* Stack of parents of current page */
68500 ** Return true if the current thread holds the database connection
69020 /* Set the BtLock.eLock variable to the maximum of the current lock
69115 /* Verify that the cursor and the BtShared agree about what is the current
69274 ** function saves the current cursor key in variables pCur->nKey and
69295 ** that the current key is corrupt. In that case, it is possible that
69320 ** Save the current cursor position in the variables BtCursor.nKey
69416 ** Clear the current cursor position.
70293 /* The next slot in the chain comes before the current slot */
71536 ** The value returned is the current spill size. If zero is passed
71538 ** using mxPage of 0 is a way to query the current spill size.
71666 ** The value returned is the larger of the current reserve size and
72435 /* Move page iDbPage from its current location to page number iFreePage */
72839 /* Set the current transaction state to TRANS_NONE and unlock the
72929 ** cursors save their current positions so that they may continue
72937 ** saving the current position of a read-only cursor, all cursors,
72972 ** Set the pBt->nPage field correctly, according to the current
73323 ** BtCursor.info is a cache of the information in the current cell.
73434 ** The current implementation merely returns the size of the underlying
73565 ** If the current cursor entry uses one or more overflow pages
73590 MemPage *pPage = pCur->pPage; /* Btree page of current entry */
73613 ** but is recast into its current form to avoid integer overflow problems
74272 u8 *pCell; /* Pointer to current cell in pPage */
74395 ** Return true (non-zero) if pCur is current pointing to the last
74467 ** search key, then we can start the search on the current page
74490 goto bypass_moveto_root; /* Start search on the current page */
74516 u8 *pCell; /* Pointer to current cell in pPage */
74689 ** to the next cell on the current page. The (slower) btreeNext() helper
74782 ** to the previous cell on the current page. The (slower) btreePrevious()
75127 ** current transaction has already run one or more incremental-vacuum
75131 ** the current page content before overwriting it.
75253 ** first trunk page in the current free-list. This block tests if it
75909 ** replaces the current contents of page pPg with the contents of the cell
76005 ** all cells - not just those inserted by the current call). If the content
76123 ** balanced. The current page, pPg, has pPg->nCell cells starting with
77276 ** A new child page is allocated and the contents of the current root
77395 ** and copy the current contents of the root-page to it. The
77903 ** from trying to save the current position of the cursor. */
77928 ** This function is used as part of copying the current row from cursor
78097 ** be preserved following this delete operation. If the current delete
78102 ** If the current delete will not cause a rebalance, then the cursor
78326 ** by extending the file), the current page at position pgnoMove
79481 ** to describe the current transaction state of Btree p.
80133 ** is the first call to backup_step() for the current backup operation),
81567 ** its link to a shallow copy and by marking any current shallow
82434 int szField = 0; /* Size of the current data field */
82690 ** than its current size. nOp is guaranteed to be less than or equal
82707 ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
82754 ** Add a new instruction to the list of instructions current in the
82949 ** Return the address of the current EXPLAIN QUERY PLAN baseline.
83444 ** beyond the current address. That is normally a jump to an early
83555 ** verify that the VDBE program can safely call Abort in the current
83571 ** array. Also, *pnMaxArg is set to the larger of its current value and
85167 ** Close all cursors in the current frame.
85765 ** VM, then we do either a commit or rollback of the current transaction.
85825 ** do so. If this operation returns an error, and the current statement
85827 ** current statement error code.
87983 ** Terminate the current execution of an SQL statement and reset it
88807 u32 sz; /* Size of current row in bytes */
88808 Mem sMem; /* Raw content of current row */
88847 ** Return the current time for a statement. If the current time
88941 ** to all functions within the current prepared statement using iArg as an
89012 ** Return the number of values available from the current row of the
89116 ** The following routines are used to access elements of the current row
89363 ** binding a new value to this variable invalidates the current query plan.
90127 ** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1,
90381 ** Test a register to see if it exceeds the current maximum blob size.
91246 ** to the current line should be indented for EXPLAIN output.
91301 ** Write the current address onto register P1
91330 ** and also less than the current address, then the "EXPLAIN" output
91332 ** to be not including the current Return. P2 should be the first opcode
91450 ** whether or not to rollback the current transaction. Do not rollback
92193 ** max() aggregate will set to 1 if the current row is not the minimum or
93952 ** is returned based on the current cursor position.
94071 ** and this is a RELEASE command, then the current transaction
94252 ** and that the current process needs to reread the schema. If the schema
94254 ** if the schema generation counter in P4 differs from the current
94275 /* Writes prohibited due to a prior SQLITE_CORRUPT in the current
94313 /* Store the current value of the database handles deferred constraint
95984 ** the current row from P2 into P1. If the cursors are opened on intkey
96075 ** VdbeCursor.movetoTarget to the current rowid. */
96191 ** Write into register P2 the current sorter data for sorter cursor P1.
96232 ** moves caused by other cursors that "save" the current cursors
96775 ** to the row that corresponds to the current row of P1.
96802 i64 rowid; /* Rowid that P1 current points to */
97504 ** of the current program, and the memory required at runtime to execute
97602 ** cell of the calling (parent) frame to cell P2 in the current frames
97671 ** different from the current frame if this instruction is being executed
97673 ** its current value and the value in register P2.
97749 ** per second (far exceeding the capabilities of any current hardware)
98487 ** the current row of the virtual-table of cursor P1.
98706 ** Write the current number of pages in database P1 to memory cell P2.
98720 ** Do not let the maximum page count fall below the current page count and
99946 ** A container for a temp file handle and the current amount of data
100012 ** The current element is "Apple" (the value of the key indicated by
100020 ** 5 key to the current key of PmaReader 4 (still "Grapefruit"). The PmaReader
100133 u8 *aKey; /* Pointer to current key */
101311 ** Write the current contents of in-memory linked-list pList to a level-0
101396 /* Advance the current PmaReader */
101470 ** Flush the current contents of VdbeSorter.list to a new PMA, possibly
101487 /* Select a sub-task to sort and flush the current list of in-memory
101568 /* Figure out whether or not the current contents of memory should be
101956 ** lead to the current background thread attempting to join itself.
101962 ** the current PmaReader set to point to the first key in its range.
102006 /* Use the current thread to populate aFile[1], even though this
102052 ** using the current thread.
102379 /* Write the current in-memory list to a PMA. When the VdbeSorterWrite()
102446 ** current key.
102450 int *pnKey /* OUT: Size of current key in bytes */
102473 ** Copy the current sorter key into the memory cell pOut.
102502 ** key in pVal is smaller than, equal to or larger than the current sorter
102510 Mem *pVal, /* Value to compare to current sorter key */
102843 ** Return the rowid for the current row. In this implementation, the
104523 ** Resolve symbolic names into TK_COLUMN operators for the current
105445 ** the refcount on all contexts between the current one and the
106539 ** If this maximum height is greater than the current value pointed
106911 ** Check to see if a function is usable according to current access
108654 Bitmask mCol; /* Mask for the current column */
109901 ** Generate code into the current Vdbe to evaluate the given
113016 ** routine is used to keep the mapping current.
114895 StatSample current; /* Current row as a StatSample */
114904 int iGet; /* Index of current sample accessed by stat_get() */
114978 sampleClear(p->db, &p->current);
115055 p->current.anDLt = (tRowcnt*)&p[1];
115056 p->current.anEq = &p->current.anDLt[nColUp];
115066 p->current.anLt = &p->current.anEq[nColUp];
115070 p->a = (struct StatSample*)&p->current.anLt[nColUp];
115251 ** p->current contains a sample that reflects the previous row of the
115262 pBest->anEq[i] = p->current.anEq[i];
115280 if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j];
115294 ** R Rowid for the current row. Might be a key record for
115325 for(i=0; i<p->nCol; i++) p->current.anEq[i] = 1;
115333 ** to the current row of the index. */
115335 p->current.anEq[i]++;
115338 p->current.anDLt[i]++;
115340 if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i];
115342 p->current.anEq[i] = 1;
115351 sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
115353 sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
115356 p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345;
115358 nLt = p->current.anLt[p->nCol-1];
115361 p->current.isPSample = 1;
115362 p->current.iCol = 0;
115363 sampleInsert(p, &p->current, p->nCol-1);
115364 p->current.isPSample = 0;
115369 p->current.iCol = i;
115370 if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){
115371 sampleCopy(p, &p->aBest[i], &p->current);
115378 sqlite3_result_int(context, p->current.anDLt[0]>0);
115472 u64 nDistinct = p->current.anDLt[i] + 1;
115476 assert( p->current.anEq[i] );
120021 ** Return true if zName is a shadow table name in the current database
120474 ** they will persist after the current sqlite3_exec() call returns.
120893 ** Return TRUE if shadow tables should be read-only in the current
121038 ** in the current table point to the foreign key. If pFromCol==0 then
122100 ** When this function is called, *pnEntry contains the current size of
122785 ** and/or current transaction is rolled back.
123770 ** defensive mode, and the current sqlite3_prepare()
124227 /* Extract the rowid or primary key for the current row */
124639 ** computed into register regPrior. If the current pIdx index is generating
127149 ** SQLITE_CONSTRAINT_FOREIGNKEY is returned and the current
127161 ** committed, the commit fails if the current value of the counter is
127734 ** uniquely identify the current row, but the parent key is more convenient
128069 ** If the parent table of an FK constraint on the current table is
128071 ** FK counter for each row of the current table with non-NULL keys.
128306 ** If the current operation is an UPDATE, then the pChanges parameter is
128783 ** by one slot and insert a new OP_TypeCheck where the current
130128 int i; /* Index of the current item from the list */
130131 Index *pIdx; /* The current Index */
130235 ** any ROLLBACK The current transaction is rolled back and
130239 ** any ABORT Back out changes from the current command
130249 ** any IGNORE The attempt in insert or update the current
131005 ** for the current row */
131802 sqlite3_stmt *pStmt = 0; /* The current SQL statement */
134750 ** The first form reports the current persistent setting for the
134752 ** pages in the page cache. The second form sets both the current
134802 ** The first form reports the current setting for the
134829 ** The first form reports the current setting for the
134859 ** The first form reports the current setting for the
134862 ** forms return the current setting.
134902 ** the current default locking mode (which may be different to
134949 ** current mode */
135084 ** The first form reports the current local setting for the
135108 ** The first form reports the current local setting for the
135111 ** current cache_size. The third form sets a spill size that
135262 ** a relative path will probably be based on the current directory for the
136212 /* Validate index entries for the current row */
136221 /* Verify that an index entry exists for the current table row */
136233 ** current key. The entry is unique if (1) any column is NULL
136500 ** after accumulating N frames in the log. Or query for the current value
136549 ** information from the current session in the
136564 ** In the current implementation, a table is analyzed if only if all of
136571 ** the current connection.
136584 Schema *pSchema; /* The current schema */
136606 ** having analysis statistics during the current session, then skip it.
136643 ** Call sqlite3_busy_timeout(db, N). Return the current timeout value
136738 ** Report the current state of file logs for all databases
137538 ** this situation the current sqlite3_prepare() operation will fail,
139042 int iContinue /* Jump here to skip the current record */
139064 ** record formed by the current array of registers. If one is found,
139072 ** table is not required. Instead, the current set of values
139319 ** containing the current result row. In this case regOrig is set to the
139323 int regResult; /* Start of memory holding current results */
139534 ** on an ephemeral index. If the current row is already present
139536 ** current row to the index and proceed with writing it to the
140666 ** The current implementation interprets "LIMIT 0" to mean
141207 /* Code the current SELECT statement
141288 /* Code the current SELECT into temporary table "tab2"
141850 /* Generate a subroutine that outputs the current row of the A
141858 /* Generate a subroutine that outputs the current row of the B
144527 ** the current cursor position.
144668 /* This routine is called before the HAVING clause of the current
145409 ** original setting of the SF_Distinct flag, not the current setting */
145564 int iAMem; /* First Mem address for storing current GROUP BY */
145854 /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
145856 ** Then compare the current GROUP BY terms against the GROUP BY terms
145881 ** This code copies current group by terms in b0,b1,b2,...
145895 ** the current row
147761 ** 1. The trigger is an exact match to the current DML statement
148605 /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
148616 /* Read the PK of the current row into an array of registers. In
148882 /* Delete the index entries associated with the current record. */
149167 /* Extract arguments from the current row of the ephemeral table and
149697 /* Save the current value of the database flags so that it can be
151856 WhereLevel *pLevel, /* The current level pointer */
152399 WhereLoop *pLoop, /* The current loop */
152475 ** The current value for the constraint is left in a register, the index
152478 ** constraint is a TK_EQ or TK_IS, then the current value might be left in
152652 ** a==5 and b IN (1,2,3). The current values for a and b will be stored
152978 ** JOIN for which the current table is not the rhs are omitted
153247 WhereLevel *pLevel, /* The current level pointer */
153292 ** for the current loop. Jump to addrBrk to break out of a loop.
154028 ** RowSetTest are such that the rowid of the current row is inserted
154218 ** rowid (or PRIMARY KEY) for the current row so that the same
154272 ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */
154330 /* Set the P2 operand of the OP_Return opcode that will end the current
154370 ** computed using the current set of tables.
154505 /* For a RIGHT OUTER JOIN, record the fact that the current row has
154516 ** will record that the current row of that table has been matched at
154997 /* If the rhs of the LIKE expression is a variable, and the current
155494 ** current term is from the first iteration. So skip this term. */
156150 ** current expression is of the form "column OP expr" where OP
156627 ** subsequent rows for the current iteration of the inner loop (because they
157157 ** current SELECT is a correlated sub-query.
157772 /* If the ORDER BY clause contains only columns in the current
157937 ** the current configuration of "unusable" flags in sqlite3_index_info can
158958 /* In the current implementation, the rSetup value is either zero
159031 ** (3) The template has same or fewer dependencies than the current loop
159032 ** (4) The template has the same or lower cost than the current loop
159767 ** in the current query. Return true if it can be and false if not.
160538 ** All the tables in mPrereq must be scanned before the current virtual
160541 ** Conversely, all tables in mUnusable must be scanned after the current
160621 ** in the set of terms that apply to the current virtual table. */
160925 int iCur; /* Cursor number for current WhereLoop */
160995 ** the current loop for which there is term in the WHERE
161071 ** If the current term is a column of an ((?,?) IN (SELECT...))
161341 WherePath *aTo; /* The nTo best paths at the current level */
161409 ** depending on the loops added to the current plan. */
161486 ** setting as the current path candidate.
161505 /* The current candidate is no better than any of the mxChoice
163219 ** * The required terminal values are stored in the current row of
163771 ** linked list of WINDOW definitions for the current SELECT statement.
164575 ** store the start and end index of the current frame. */
164696 ** start,current,end
164705 ** (current) that points to the next row to return to the query engine
164708 ** on (so that it is 2 groups ahead of current). And a third (start) that
164712 ** Each cursor (start, current and end) consists of a VDBE cursor
164732 WindowCsrAndReg current;
164768 ** the arguments are extracted from the current row of csr into the
164772 ** already populated with all columns from the current row of the sub-query.
164775 ** number of rows in the current partition.
164928 ** Generate code to calculate the current values of all window functions in the
164929 ** p->pMWin list by doing a full scan of the current window frame. Store the
165028 ** return the current row of Window.iEphCsr. If all window functions are
165145 ** Return true if the current frame should be cached in the ephemeral table,
165383 p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone
165387 p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone
165392 p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone
165434 csr = p->current.csr;
165435 reg = p->current.reg;
165624 ** with arguments read from the current row of cursor csrEnd, then
165628 ** current row of csrCurrent and the current state of all
165632 ** functions with arguments read from the current row of cursor
165792 ** AGGINVERSE step processes the current row of the relevant cursor and
165832 ** In the above notation, "csr.key" means the current value of the ORDER BY
165924 int regPeer = 0; /* Peer values for current row */
165951 s.current.csr = pMWin->iEphCsr;
165952 csrWrite = s.current.csr+1;
165953 s.start.csr = s.current.csr+2;
165954 s.end.csr = s.current.csr+3;
166008 ** for the main loop, and for each cursor (start, current and end). */
166015 s.current.reg = pParse->nMem+1; pParse->nMem += nPeer;
166073 sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
166076 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
166089 sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
166096 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
166114 windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
166140 windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
166218 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
166774 ** current state and lookahead token. These tables are used to implement
171433 ** "sqlite3ParserAlloc" which describes the current state of the parser.
172887 ** Insert a single space character into pStr if the current string
172907 int n; /* length of current token */
172908 int tokenType; /* type of current token */
173812 ** heap subsystem was shutdown. This is only done if the current call to
173886 /* Retrieve the current mutex implementation */
173964 ** object. SQLite copies of the current page cache implementation into
176427 ** value currently being parsed. So ignore the current character
177454 ** Save the current state of the PRNG.
177476 ** x!=0 && db!=0 Seed the PRNG to the current value of the
177882 ** op==0 Store the current sqlite3TreeTrace in *ptr
177884 ** op==3 Store the current sqlite3WhereTrace in *ptr
177926 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
178563 ** until connection pBlocker concludes its current transaction.
178847 ** New data is spilled to a new leaf node when the current node
178899 ** the current node exceeds INTERIOR_MAX bytes (default 2048).
179165 /* TODO(shess) current implementation requires pInput to be
179548 ** The current language id is stored in variable iPrevLangid.
180388 ** Store the current database page-size in bytes in p->nPgsz.
180654 ** representing the indexes maintained by the current FTS table. FTS tables
181814 ** If *pp points past the end of the current position-list, set *pi to
181816 ** increment the current value of *pi by the value read, and set *pp to
181876 int iCol1; /* The current column index in pp1 */
181877 int iCol2; /* The current column index in pp2 */
182255 ** current and previous docid (a positive number - since the list is in
182521 ** to hold the current doclist AND'd with any other doclist. If the
182708 ** In addition to its current configuration, have the Fts3MultiSegReader
183071 ** retrieve the rowid for the current row of the result set. fts3
183940 ** current position list to include only those positions that are really
183942 ** means that the phrase does not appear in the current row, doclist.pList
184385 /* Check if the current entries really are a phrase match */
184524 Fts3Expr *pRoot, /* Root of current AND/NEAR cluster */
184817 ** Invalidate the current position list for phrase pPhrase.
185058 ** Otherwise, it checks if the current row really does match the NEAR
185062 ** If the current row is a match, the position list associated with each
185066 ** match the current row, 0 is returned. The position lists may or may not
185253 ** operators and deferred tokens the current row is still a match for the
185258 ** 2. After scanning the current FTS table row for the deferred tokens,
185261 ** Or, if no error occurs and it seems the current row does match the FTS
185269 /* If there are one or more deferred tokens, load the current row into
185567 ** of the current row.
185801 sqlite3_int64 nDoc; /* 'documents' values for current csr row */
185802 sqlite3_int64 nOcc; /* 'occurrences' values for current csr row */
186268 ** xRowid - Return the current rowid for the cursor.
186893 ** Argument ppHead contains a pointer to the current head of a query
188050 int iOffset; /* current position in zInput */
188052 char *zToken; /* storage for current token */
189233 int iOffset; /* current position in pInput */
189235 char *pToken; /* storage for current token */
189834 ** xRowid - Return the current rowid for the cursor.
190046 int nTerm; /* Number of bytes in current term */
190047 char *zTerm; /* Pointer to current term */
190049 char *aDoclist; /* Pointer to doclist of current entry */
190050 int nDoclist; /* Size of doclist in current entry */
190053 ** through the current doclist (aDoclist/nDoclist).
191326 ** with the current term.
191352 ** associated with the current term.
191363 char **ppOffsetList, /* OUT: Pointer to current position-list */
191681 ** 2) The current terms (if any) are compared using memcmp(). If one
191716 ** 2) By current docid.
191921 /* First try to append the term to the current node. Return early if
191987 ** current node. Create a new node (a right-sibling of the current node).
192181 /* The current leaf node is full. Write it out to the database. */
192187 /* Add the current term to the interior node tree. The term added to
192240 /* Save the current term so that it can be used to prefix-compress the next.
192794 ** forward. Then sort the list in order of current term again.
192859 /* The current term of the first nMerge entries in the array
193440 ** the current contents of the xxx table. Otherwise, it is rebuilt based
193590 Blob key; /* Last key written to the current block */
193623 /* Output variables. Containing the current node entry. */
193658 ** (e.g. because the current entry is the last) set NodeReader->aNode to
193761 ** the current node of layer iLayer. Due to the prefix compression,
193771 /* If the current node of layer iLayer contains zero keys, or if adding
193800 /* Otherwise, flush the current node of layer iLayer to disk.
193892 ** Append the current term and doclist pointed to by cursor pCsr to the
193921 /* If the current block is not empty, and if adding this term/doclist
193922 ** to the current block would make it larger than Fts3Table.nNodeSize
193928 /* Add the current term to the parent node. The term added to the
195067 int iLangid, /* Language id for current row */
195069 i64 iDocid, /* Docid for current row. */
195164 ** Check if the contents of the FTS index match the current contents of the
195255 ** Run the integrity-check. If no error occurs and the current contents of
195772 int iCurrent; /* First token of current snippet */
195928 ** of the difference between the current element and the previous one plus
196024 Fts3Cursor *pCsr, /* Fts3 cursor for current query */
196118 ** Retrieve information about the current candidate snippet of snippet
196438 int iEnd = 0; /* Byte offset of end of current token */
196630 ** current query.
196887 int nThisLcs = 0; /* LCS for the current iterator positions */
197053 ** Populate pCsr->aMatchinfo[] with data for the current row. The
197156 ** the data in the current row. The first iteration of the for(...) loop
197159 ** expression that appear in the current row. If such a fragment of text
197554 char *zToken; /* storage for current token */
198264 ** a BLOB, but there is no support for JSONB in the current implementation.
200371 u32 i; /* Index in sParse.aNode[] of current row */
200677 /* Return the current rowid value */
202379 ** Return the search point with the lowest current score.
202505 /* Remove the search point with the lowest current score.
208552 ** the current state of the update (how many rows have been updated, which
208628 ** not modified (this is useful for querying the current limit).
208630 ** In all cases the returned value is the current limit in bytes (zero
208639 ** Return the current amount of temp file space, in bytes, currently used by
208708 ** current state of the RBU update appliation to the RBU database.
208726 ** current RBU update was started.
208773 ** Obtain an indication as to the current stage of an RBU update or vacuum.
208784 ** will move the *-oal file to the equivalent *-wal path. If the current
208952 ** Only valid if STAGE==1. Number of rows already processed for the current
208967 ** Valid if STAGE==1. The current change-counter cookie value in the
209089 int iTnum; /* Root page of current object */
209095 int nCol; /* Number of columns in current object */
209197 int nStep; /* Rows processed for current object */
209249 ** "sz" is set to the current size of the database file.
209623 ** the current object (table/index pair).
210261 ** in order, for the current table. Before each column name, add the text
210357 ** current operation is writing content to an index. If possible, it
210594 ** Assuming the current table columns are "a", "b" and "c", and the zObj
210637 ** primary key of the current table. For example, if the table is:
210680 ** The SELECT statement iterating through the keys for the current object
210859 /* Figure out the name of the primary key index for the current table.
211778 ** Return the current wal-index header checksum for the target database
211803 ** current wal file, and obtains the set of shm locks required to safely
212077 ** The SELECT statement iterating through the keys for the current object
212559 ** lies on a different disk sector to the current one. */
213045 ** specifying the current target and state databases to start a new
213079 ** current RBU update was started.
213122 ** Return the current state of the RBU vacuum or update operation.
213577 ** Return the current file-size of an rbuVfs-file.
214057 ** Return the current time as a Julian Day number in *pTimeOut.
214309 StatPage aPage[32]; /* Pages in path to current page */
214317 int nPage; /* Number of pages in current btree */
214690 ** the current value of pCsr->iPageno.
215592 int iCurrent; /* Offset in aData[] of current change */
215617 int bIndirect; /* True if current change was indirect */
216357 ** It determines if the current pre-update-hook change affects the same row
216938 /* If the existing change is considered "indirect", but this current
217740 ** at the current version of the row (the new.* values).
218047 ** (if it is non-zero) based on the current contents of the session object
218753 /* Free the current contents of p->apValue[], if any. */
218914 ** The following function extracts information on the current change
219088 int nCol = 0; /* Number of cols in current table */
219089 u8 *abPK = 0; /* PK array for current table */
219091 SessionBuffer sPK = {0, 0, 0}; /* PK array for current table */
219634 /* COVERAGE: The (pVal->z==0) branch is never true using current versions
219649 ** transfers new.* values from the current iterator entry to statement
219748 sqlite3_changeset_iter *pIter /* Iterator pointing at current change */
220181 const char *zTab = 0; /* Name of current table */
220297 /* If there is a schema mismatch on the current table, proceed to the
220472 SessionTable *pList; /* List of tables in current patch */
221020 ** or more remote UPDATE changes. The aRec/nRec buffer contains the current
221092 ** that changeset according to the current configuration of the rebaser
221269 ** Rebase a changeset according to current rebaser configuration
221288 ** Rebase a changeset according to current rebaser configuration
221395 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
221431 ** to the total number of tokens in the current row. Or, if iCol is
221433 ** *pnToken to the number of tokens in column iCol of the current row.
221445 ** current document. If successful, (*pz) is set to point to a buffer
221452 ** Returns the number of phrases in the current query expression.
221460 ** the query within the current row. Return SQLITE_OK if successful, or
221469 ** Query for the details of phrase match iIdx within the current row.
221483 ** Returns the rowid of the current row.
221490 ** of the current query. Specifically, a query equivalent to:
221495 ** current query is executed. Any column filter that applies to
221496 ** phrase iPhrase of the current query is included in $p. For each
221516 ** "auxiliary data". The pointer may then be retrieved by the current or any
221541 ** Returns the current auxiliary data pointer for the fts5 extension
221559 ** the current row. This is the same information as is accessible via the
221590 ** of iterating through all instances of a phrase in the current row, these
221591 ** APIs are used to iterate through the set of columns in the current row
222407 int bDelete, /* True if current operation is a delete */
222990 ** current state and lookahead token. These tables are used to implement
224039 ** "sqlite3Fts5ParserAlloc" which describes the current state of the parser.
224302 ** a single column of the current row. If the phrase instances in the
224321 const Fts5ExtensionApi *pApi; /* API offered by current FTS version */
224486 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
224601 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
224658 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
224839 ** Set *ppData to point to the Fts5Bm25Data object for the current query.
224917 const Fts5ExtensionApi *pApi, /* API offered by current FTS version */
224931 double *aFreq = 0; /* Array of phrase freq. for current row */
224934 ** for each phrase in the query for the current row. */
224950 /* Figure out the total size of the current row in tokens. */
224957 /* Determine and return the BM25 score for the current row. Or, if an
226801 ** Argument pTerm must be a synonym iterator. Return the current rowid
226904 ** checks if the current rowid really is a match, and if so populates
226909 ** otherwise. It is not considered an error code if the current rowid is
227037 ** tests if the current row contains instances of each phrase sufficiently
227229 /* Check that each phrase in the nearset matches the current row.
227867 /* If not at EOF but the current rowid occurs earlier than iFirst in
229211 ** This function is used to access the current position list for phrase
229484 ** its current data are stored in a single memory allocation. The
230163 ** on the page. Each varint is the byte offset of the current term
230293 i64 iWriteRowid; /* Rowid for current doc being written */
230365 i64 iPrevRowid; /* Previous rowid written to current leaf */
230398 ** Byte offset within the current leaf that is the first byte of the
230400 ** rowid field of the current entry. Usually this is the size field of the
230401 ** position list data. The exception is if the rowid for the current entry
230405 ** Buffer containing current leaf page data. Set to NULL at EOF.
230415 ** If set, set the iterator to point to EOF after the current doclist
230426 ** For each rowid on the page corresponding to the current term, the
230431 ** Index of current term on iTermLeafPgno.
230439 i64 iLeafOffset; /* Byte offset within current leaf */
230444 /* The page and offset from which the current term was read. The offset
230445 ** is the offset of the first rowid in the current doclist. */
230459 /* Variables populated based on current entry. */
230462 int nPos; /* Number of bytes in current position list */
230515 Fts5Buffer poslist; /* Buffer containing current poslist */
230542 ** Set to the current offset within record pData.
230545 Fts5Data *pData; /* Data for current page of this level */
230551 int iLeafPgno; /* Page number of current leaf page */
231189 /* Append the current configuration cookie */
231984 /* Next entry is on the current page */
232048 /* Search for the end of the position list within the current page. */
232056 /* The next entry is on the current page. */
232095 /* Next entry is not on the current page */
232177 ** position-list content for the current rowid. Back it up so that it
232188 /* If this condition is true then the largest rowid for the current
232189 ** term may not be stored on the current page. So search forward to
232195 /* The last rowid in the doclist may not be on the current page. Search
232249 ** There is a doclist-index associated with the final term on the current
232250 ** page. If the current term is the last term on the page, load the
232261 /* Check if the current doclist ends on this page. If it does, return
232285 ** current page.
232588 ** in *pRes is the correct result of comparing the current positions of the
233170 ** function appends the position list data for the current entry to
233297 /* All data is stored on the current page. Populate the output
233390 /* All data is stored on the current page. Populate the output
233496 /* Add a segment iterator for the current contents of the hash table. */
233780 ** If the current doclist-index accumulating in pWriter->aDlidx[] is large
233879 ** Rowid iRowid has just been appended to the current leaf page. It is the
233880 ** first on the page. This function appends an appropriate entry to the current
233896 /* The current doclist-index page is full. Write it to disk and push
234003 /* If the current leaf page is full, flush it to disk. */
234202 /* Bind the current output segment id to the index-writer. This is an
234204 ** inserted into %_idx by the current writer. */
234310 int bTermWritten = 0; /* True if current term already output */
234625 /* The entire doclist will fit on the current leaf. */
234633 ** loop iterates through the poslists that make up the current
234668 /* The entire poslist will fit on the current leaf. So copy
235687 ** Return the current term.
235736 ** Replace the current "averages" record with the contents of the buffer
236024 /* Now check that the iter.nEmpty leaves following the current leaf
236149 /* Now check that the iter.nEmpty leaves following the current leaf
236169 /* Check any rowid-less pages that occur before the current leaf. */
236892 ** structure is used to record the current transaction state. This information
236954 Fts5Buffer *pPoslist; /* Pointer to current poslist */
236970 const u8 *aPoslist; /* Position lists for current row */
236972 int aIdx[1]; /* Offsets into aPoslist for current row */
237686 ** (in the cursors sort order - ASC or DESC) than the current rowid.
238164 ** return results to the user for this query. The current cursor
238248 ** retrieve the rowid for the current row of the result set. fts5
238527 /* If this is a REPLACE, first remove the current entry (if any) */
238736 ** correctly for the current view. Return SQLITE_OK if successful, or an
239228 ** Return a "position-list blob" corresponding to the current position of
239230 ** the current position-list for each phrase in the query associated with
240256 ** Store the current contents of the p->nTotalRow and p->aTotalSize[]
243538 i64 rowid; /* This table's current rowid value */
244213 ** retrieve the rowid for the current row of the result set. The
244447 ** Return the rowid for the current row. In this implementation, the