Lines Matching defs:start
14 ** the text of this file. Search for "Begin file sqlite3.h" to find the start
3596 ** execution of the prepared statement, such as at the start of each
4205 ** of the start of that token. ^The byte offset returned by
4352 ** [prepared statement] may start.</dd>)^
7116 ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
8473 ** <li> Begin every identifier with the letter "Z" as no SQL keywords start
9706 ** start a callback but which do not need the full power (and corresponding
16703 ** at start-time.
16708 ** start-time.
17653 ** But rather than start with 0 or 1, we begin with 'A'. That way,
18353 int iOfst; /* else: start of token from start of statement */
22201 ** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE)
24151 ** start of month
24152 ** start of year
24153 ** start of week
24154 ** start of day
24307 ** start of TTTTT
24312 if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break;
27950 ** mutex routines at start-time using the
30892 ** If pExpr has a byte offset for the start of a token, record that as
33309 /* Set zIn to point at the start of the input buffer and zTerm to point 1
38757 /* When reducing a lock such that other processes can start
39621 unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */
39959 /* When reducing a lock such that other processes can start
42808 ** describing "Posix Advisory Locking" at the start of this file for
43953 int start = 0;
43960 if( lockPath[i] == '/' && (i - start > 0) ){
43962 if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/')
43963 || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){
43975 start=i+1;
44461 continue; /* go back to the do {} while start point, try again */
52229 ** start of a transaction, and is thus usually less than a few thousand,
53567 ** The superclass sqlite3_pcache_page.pBuf points to the start of the
54245 ** configured a start-time buffer for use as page-cache memory using
55525 ** (b) The page was a freelist leaf page at the start of the transaction.
55528 ** the database file at the start of the transaction.
55691 ** required to start a write-transaction are held, but no actual
55721 ** start of it. The database file on disk has not been modified.
56063 ** variable at the start of the transaction. It is used during rollback,
56885 ** zero the 28-byte header at the start of the journal file. In either case,
57079 /* Advance Pager.journalOff to the start of the next sector. If the
57090 ** the magic string found at the start of each journal header, return
57105 ** field, the checksum-initializer and the database size at the start
57743 ** value is increased to the start of the next page in the journal.
57877 ** different from the page content at the start of the transaction.
57878 ** This occurs when a page is changed prior to the start of a statement
57955 ** if the page is on the free-list at the start of the transaction, then
58457 ** state prior to the start of the transaction, so invoke the
58912 ** is reset to the value that it held at the start of the savepoint
59103 ** prior to the start of checkpoint and that the database file is synced
59821 ** byte to the start of it to prevent it from being recognized.
60710 ** at least one non-zero bytes at the start of the journal file.
60917 ** single unnecessary sqlite3OsRead() call at the start-up.
61317 ** This function is called at the start of every write transaction.
61322 ** to the start of it. If there are active savepoints, open the sub-journal
61328 ** then this function just writes a journal header to the start of the
61785 ** have been dirty at the start of the transaction. In that case, if
62221 ** The start of the journal file currently contains a single journal
63059 ** is invoked without any intervening transactions. We need to start
63471 ** To start a read transaction, the reader records the index of the last
63570 ** Then start scanning entries of the hash table, starting with iKey
63675 ** the locking bytes (WalCkptInfo.aLock) start at offset 120 and
63749 ** the writer will first "reset" the WAL back to the beginning and start
63857 ** is to the start of the write-ahead log frame-header.
64358 ** Set output variable pLoc->aHash to point to the start of the hash table
65343 ** writing frames into the start of the log file.
65915 ** is active, wrap the WAL and start overwriting frames that this
65957 /* Check the salt keys at the start of the wal file still match. */
66026 ** Attempt to start a read transaction. This might fail due to a race or
66045 ** This routine will start taking more aggressive measures to clear the
66102 ** an subsequent retries, the delays start becoming longer and longer,
66461 ** from the start of the wal file. This is because, for a system
66662 /* Cannot start a write transaction without first holding a read
66709 ** function moves the write-pointer back to the start of the transaction.
66712 ** to the WAL since the start of the transaction. If the callback returns
66782 ** to the start of the log. Update the savepoint values to match.
66801 ** to the current log file, it is possible to overwrite the start of the
66824 ** frames will overwrite the start of the existing log. Update the
67019 /* See if it is possible to write these frames into the start of the
67027 ** header to the start of the WAL file. See comments at the top of
67986 ** while in the 'pending-lock' state, no connection may start a new
68036 #define BTS_INITIALLY_EMPTY 0x0010 /* Database was empty at trans start */
68048 u8 *pPayload; /* Pointer to the start of payload */
70625 ** the start of the cell content area. A zero value for this integer is
70633 ** start of the first freeblock on the page, or is zero if there are no
70666 /* At this point, nFree contains the sum of the offset to the start
70670 ** serves to verify that the offset to the start of the cell-content
71010 ** so that the cache is restored to its original state at the start of
72093 ** Attempt to start a new transaction. A write-transaction
73043 ** back independently of the main transaction. You must start a transaction
73396 ** Return the offset into the database file for the start of the
73711 ** 2) data is required from the start of this overflow page, and
74467 ** search key, then we can start the search on the current page
75753 ** as many as 4 bytes in front of the start of the aData buffer for
75810 ** apCell[] and szCell[] hold, respectively, pointers to the start of each
75998 ** When this function is called, *ppData points to the start of the
76000 ** *ppData is updated to point to the new start of the content area
76155 /* Remove cells from the start and end of the page */
76173 /* Add cells to the start of the page */
77508 u8 *pDest, /* Pointer to the place to start writing */
79040 int cellStart; /* Offset to the start of the cell pointer array */
79051 u32 contentOffset; /* Offset to the start of the cell content area */
79240 ** pointer index, and the gap between the cell pointer index and the start
81797 u32 offset, /* Offset from the start of data to return bytes from. */
86230 ** types are stored at the start of the record, and the blobs of data at
87284 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
87383 ** at the start of (pKey1/nKey1) fits in a single byte.
87457 ** that the size-of-header varint that occurs at the start of each record
91065 u64 start; /* CPU clock count at start of opcode */
91129 start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
93115 ** start of the payload for the record at which that cursor P1 is currently
93174 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
94214 (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
99135 if( endTime>start ) pOrigOp->cycles += endTime - start;
100175 i64 iStartOff; /* Offset to start writing file at */
100196 i64 iWriteOff; /* Offset of start of buffer in file */
100324 /* Copy as much data as is available in the buffer into the start of
101653 ** except that the number-of-bytes varint is omitted from the start.
101717 ** aFile[0] such that the PmaReader should start rereading it from the
117662 ** set for each database that is used. Generate code to start a
126526 /* First separator length variation seen, start tracking them. */
126939 ** to the global function hash table. This occurs at start-time (as
126950 ** FuncDef.pHash elements at start-time. The elements of this array
137867 ** is not possible for another thread to start a new schema change
141677 int labelCmpr; /* Label for the start of the merge algorithm */
148136 int addrTop = 0; /* VDBE instruction address of the start of the loop */
151384 int addrNxt; /* Jump here to start the next IN combination */
151760 ** first part does the start of the WHERE loop and the second
152668 ** start and termination conditions of the loop.
153239 ** Generate code for the start of the iLevel-th loop in the WHERE clause
153493 int start;
153509 Expr *pX; /* The expression that defines the start bound */
153510 int r1, rTemp; /* Registers for holding the start boundary */
153580 start = sqlite3VdbeCurrentAddr(v);
153583 pLevel->p2 = start;
153647 WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */
153649 int startEq; /* True if range start uses ==, >= or <= */
153656 char *zStartAff; /* Affinity for start of range constraint */
153668 /* Find any inequality constraint terms for the start and end
153732 ** start and end terms (pRangeStart and pRangeEnd).
153766 /* Seek the index cursor to the start of the range. */
153876 ** range-start value, resulting in a wrong answer.
154951 ** pattern prefix boundaries (both the start and end boundaries) must
156485 ** virtual terms, so start analyzing at the end and work forward
156866 int k = pScan->k; /* Where to start scanning */
160498 ** prepared is read-only, then just start read transactions on all
160499 ** schemas. But if this is a write operation, start writes on all
162146 ** start:
162152 ** goto start
162386 sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n");
163263 ** the start of the window frame is declared as anything other than
164575 ** store the start and end index of the current frame. */
164696 ** start,current,end
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
164731 WindowCsrAndReg start;
165383 p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone
165387 p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone
165408 ** start cursor does not advance past the end cursor within the
165418 sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
165440 csr = p->start.csr;
165441 reg = p->start.reg;
165774 ** added to the ephemeral table is the start of a new group. In
165953 s.start.csr = s.current.csr+2;
166008 ** for the main loop, and for each cursor (start, current and end). */
166014 s.start.reg = pParse->nMem+1; pParse->nMem += nPeer;
166029 ** VM code to check if the input row is the start of a new partition.
166086 sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1);
166095 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);
171707 #define CC_X 0 /* The letter 'x', or start of BLOB literal */
171939 /* aKWOffset[i] is the index into zKWText[] of the start of
172698 ** SQL keywords start with the letter 'x'. Fall through */
172912 int nParenAtIN; /* Value of nParent at start of RHS of IN operator */
174040 ** can be changed at start-time using the
175563 ** trace is a pointer to a function that is invoked at the start of each
176372 memset(zFile, 0, 4); /* 4-byte of 0x00 is the start of DB name marker */
177959 ** by four zero bytes. Locate the start of the database filename by searching
178780 ** varint POS_COLUMN; (marks start of position list for new column)
178803 ** at D signals the start of a new column; the 1 at E indicates that the
180143 ** of varints). This function moves *pp to point to the start of that varint,
181545 /* Skip over the 'height' varint that occurs at the start of every
181720 ** start of a position-list. After it returns, *ppPoslist points to the
181764 ** start of a column-list. After it returns, *ppPoslist points to the
181809 ** called, *pp may point to the start of the next varint in the position-list
181841 ** the value of iCol encoded as a varint to *pp. This will start a new
181901 /* At this point, both p1 and p2 point to the start of column-lists
183298 ** set. So to find the start of the poslist, skip forward 2 bytes then
184111 ** This function is used to iterate backwards (from the end to start)
184246 ** point to the start of the next docid value. The following line deals
186076 ** start of a position list for column 0.
186123 ** xFilter - Initialize a cursor to point at the start of its data.
188110 c->iOffset = 0; /* start tokenizing at the beginning */
188798 /* Find the start of the next token. */
189322 c->iOffset = 0; /* start tokenizing at the beginning */
189448 ** CREATE TABLE <tbl>(input, token, start, end, position)
189461 ** start: Byte offset of the token within the input <string>.
189495 int iStart; /* Current 'start' value */
189572 #define FTS3_TOK_SCHEMA "CREATE TABLE x(input, token, start, end, position)"
189757 ** xFilter - Initialize a cursor to point at the start of its data.
189811 /* CREATE TABLE x(input, token, start, end, position) */
194324 ** of interior nodes that are parents of the leaf nodes start at block
194887 ** to start work on some other level. */
195777 char *pList; /* Pointer to start of phrase position list */
195939 ** When this function is called, *pp points to the start of an element of
196378 /* Ideally, the start of the snippet should be pushed forward in the
196465 int iBegin = 0; /* Offset in zDoc of start of token */
196813 ** 1 if the iterator is at EOF or if it now points to the start of the
197144 const char *zStart, /* Snippet start text - "<b>" */
197790 /* Scan past any delimiter characters before the start of the next token.
208245 ** download the update again and start over.
208587 ** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum
213045 ** specifying the current target and state databases to start a new
213770 ** from start to finish. */
215462 ** written by the sqlite_dbpage virtual table, start a write transaction
215633 ** start of the session. Or no initial values if the row was inserted.
217488 ** simply added to the start of it in order to ensure that tables
218450 ** When this function is called, *ppRec points to the start of a record
218501 ** When this function is called, *paChange points to the start of the record
220715 ** simply added to the start of it. This is to ensure that the
221995 ** field that occurs at the start of each leaf page (see fts5_index.c). */
226108 ** int iStart // Byte offset of start of token within input text
230158 ** * The byte offset of the start of the page footer. If the page
230428 ** start of the "position-list-size" field within the page.
230915 /* Read the total number of levels and segments from the start of the
231798 ** Fts5SegIter.iLeafOffset variable is set to the offset of the start of
232178 ** points to the start of the position-list size field. */
233082 ** start of the next columns hits. */
235754 ** Set the 32-bit cookie value stored at the start of all structure
236464 ** The start of buffer (a/n) contains the start of a doclist. The doclist
236672 /* Decode the position list tail at the start of the page */
236884 ** xRollbackTo(int S): Rollback to start of savepoint S.