Lines Matching refs:points
1183 ** into an integer that the pArg argument points to.
1234 ** as part of a multi-database commit, the argument points to a nul-terminated
1302 ** that the fourth parameter of [sqlite3_file_control()] points to.
1348 ** - an array of two (void *) values. The first (void *) actually points
1577 ** the third parameter to entry points of [loadable extensions]. This
2345 ** points to a buffer containing the name of the main database file. If the
2347 ** points to has just been executed. Or, if the fourth parameter is 2, then
3296 ** sqlite3_msize(X) returns zero. If X points to something that is not
3297 ** the beginning of memory allocation, or if it points to a formerly
3383 ** points during the compilation process, as logic is being created
3609 ** X argument points to a 64-bit integer which is the estimated of
6548 ** that this variable points to is held in memory obtained from
6555 ** does not free the memory that sqlite3_temp_directory points to. If
6605 ** that this variable points to is held in memory obtained from
7849 ** ^(If the row that a BLOB handle points to is modified by an
7890 ** ^This function is used to move an existing [BLOB handle] so that it points
8449 ** of bytes in the keyword into *L. The string that *Z points to is not
8456 ** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero
9778 ** ^If parameter zDb is NULL or points to a zero length string, then the
10336 ** points to is unchanged.
10341 ** that pOut points to unchanged.
10459 ** behavior is undefined. The [sqlite3_value] that P points to
10468 ** behavior is undefined. The [sqlite3_value] that P points to
11261 ** the caller to eventually free the buffer that *ppChangeset points to using
11549 ** no error occurs and the iterator points to a valid change after a call
11574 ** depending on the type of change that the iterator currently points to;
11612 ** the table modified by the change that iterator pIter currently points to.
11641 ** currently points to is either [SQLITE_DELETE] or [SQLITE_UPDATE]. Otherwise,
11672 ** currently points to is either [SQLITE_UPDATE] or [SQLITE_INSERT]. Otherwise,
12514 ** argument, pData, points to a buffer (*pnData) bytes in size. Assuming no
12549 ** points to a buffer nData bytes in size containing the chunk of output
13918 ** Hash.first points to the head of this list.
13920 ** There are Hash.htsize buckets. Each bucket points to a spot in
14459 ** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to
14463 ** the end of buffer S. This macro returns true if P points to something
16379 ** comments in VDBE programs that show key decision points in the code
16400 ** for VDBE branch instructions. The coverage testing points are line
17903 char *zTo; /* Name of table that the key points to (aka: Parent) */
18168 ** The memory that "z" points to is owned by other objects. Take care
18170 ** the Token goes out of scope! Very often, the "z" points to some place
18286 ** is a disk table or the "old.*" pseudo-table, then pTab points to the
18717 ** Each subquery gets a new NameContext. The pNext field points to the
19306 ** The "step_list" member points to the first element of a linked list
19772 ** Assuming zIn points to the first byte of a UTF-8 character,
22686 ** If the MEM_Str flag is set then Mem.z points at a string representation.
22715 #define MEM_Static 0x2000 /* Mem.z points to a static string */
22716 #define MEM_Ephem 0x4000 /* Mem.z points to an ephemeral string */
22717 #define MEM_Agg 0x8000 /* Mem.z points to an agg function context */
27279 /* Check that the pointer pOld points to a valid, non-free block. */
30869 ** The z string points to the first character of a token that is
33172 ** During translation, assume that the byte that zTerm points
37902 ** If you close a file descriptor that points to a file that has locks,
43425 ** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes
43516 ** Interfaces for opening a shared library, finding entry points
43553 ** x points to.
50850 ** Interfaces for opening a shared library, finding entry points
52401 /* we didn't find it in the hash. h points to the first */
52638 ** PCache.pDirty points to the first (newest) element in the list and
52644 ** Therefore, pSynced is maintained so that it *almost* always points
52845 ** optimization, as if pSynced points to a page with the NEED_SYNC
53567 ** The superclass sqlite3_pcache_page.pBuf points to the start of the
53568 ** database page content and sqlite3_pcache_page.pExtra points to PgHdr.
53726 unsigned int nPurgeableDummy; /* pnPurgeable points here when not used*/
53803 ** verb to sqlite3_config(). Parameter pBuf points to an allocation large
54899 ** objects. In that alternative use, pRight points to the next entry
54900 ** in the list, pLeft points to the tree, and v is unused. The
54901 ** RowSet.pForest value points to the head of this forest list.
55557 ** Definition: Two databases (or the same database at two points it time)
58103 ** Open it and check if it points at the super-journal. If
59384 ** that pDest points to.
61947 ** Sync the database file for the pager pPager. zSuper points to the name
64821 ** already be opened on connection pDbFd. The buffer that zWalName points
67528 ** If the argument is not NULL, it points to a Wal object that holds a
67592 ** All of the keys on the page that Ptr(0) points to have values less
67773 ** file header points to the first in a linked list of trunk page. Each trunk
67774 ** page points to multiple leaf pages. The content of a leaf page is
67901 ** points to the same BtShared object. The database cache and the
67962 ** private Btree object for the file and each of those Btrees points
68105 BtShared *pBt; /* The BtShared this cursor points to */
68139 ** Cursor points to a valid entry. getPayload() etc. may be called.
68577 ** These entry points are used by incremental I/O only. Enter() is required
70036 /* pIter now points at the 64-bit integer key value, a variable length
71403 ** Make sure pBt->pTmpSpace points to an allocation of
72035 ** If pBt points to an empty file then convert that empty file
72340 ** that it points to iTo. Parameter eType describes the type of pointer to
72343 ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
72346 ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
72349 ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
72468 ** that it points at iFreePage. Also fix the pointer map entry for
72774 ** Otherwise, sync the database file for the btree pBt. zSuperJrnl points to
73371 ** ordinary table btree. If the cursor points to an index btree or
74113 ** on success. Set *pRes to 0 if the cursor actually points to something
74135 ** on success. Set *pRes to 0 if the cursor actually points to something
74144 /* If the cursor already points to the last entry, this is a no-op. */
74180 /* Move the cursor so that it points to an entry in a table (a.k.a INTKEY)
74408 /* Move the cursor so that it points to an entry in an index table
75539 /* If pToRelease is not zero than pPayload points into the data area
75599 /* If pToRelease is not zero than pPrior points into the data area
75674 ** Insert a new cell on pPage at cell index "i". pCell points to the
75992 ** Argument pCellptr points to the first entry in the cell-pointer array
75998 ** When this function is called, *ppData points to the start of the
76003 ** Finally, argument pBegin points to the byte immediately following the
76612 /* Drop the cell from the parent page. apDiv[i] still points to
77363 ** The page that pCur currently points to has just been modified in
77473 /* If pFree is not NULL, it points to the pSpace buffer used
77617 ** to be inserted. If seekResult<0 then pCur points to a cell that is
77618 ** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell
77672 ** points to a valid cell.
78198 ** then the cursor still points to that page. In this case the first
78743 ** points to the first interior cell that it points to the parent of
78767 ** points at. This is the right-child if (iIdx==pPage->nCell).
79636 ** (e) the cursor points at a valid row of an intKey table.
79793 ** structure may be accessed via two groups of thread-safe entry points:
79968 ** Parameter zSrcData points to a buffer containing the data for
80779 ** Make sure pMem->z points to a writable allocation of at least n bytes.
81605 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
83705 ** Change the P2 operand of instruction addr so that it points to
83919 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
86368 ** points (ex: ARM7) then swap the lower 4 bytes with the
87004 ** except 7. The second points to a buffer containing an integer value
87502 ** pCur points at an index entry created using the OP_MakeRecord opcode.
87795 ** the required value will be read from the row the cursor points to.
91581 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
91724 ** P4 points to a blob of data P1 bytes long. Store this
93151 ** Interpret the data that cursor P1 points to as a structure built using
93303 /* Make sure zData points to enough of the record to cover the header. */
94631 ** Open a new cursor P1 that points to the same ephemeral table as
94678 ** The cursor points to a BTree table if P4==0 and to a BTree index
94679 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
94821 ** Open a new cursor that points to a fake table that contains a single
94893 ** Reposition cursor P1 so that it points to the smallest entry that
94920 ** Reposition cursor P1 so that it points to the smallest entry that
94938 ** Reposition cursor P1 so that it points to the largest entry that
94956 ** Reposition cursor P1 so that it points to the largest entry that
95252 /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the
95253 ** OP_IdxGT that follows the OP_SeekGE. Otherwise, it points to the first
95728 ** table that cursor P1 points to. The new record number is written
96031 ** If P4 is not NULL then it points to a Table object. In this case either
96160 ** the sorter cursor currently points to. Only the first P4 fields
96531 ** Advance cursor P1 so that it points to the next key/data pair in its
96555 ** Back up cursor P1 so that it points to the previous key/data pair in its
96794 ** the rowid of the table entry to which this index entry points.
96802 i64 rowid; /* Rowid that P1 current points to */
98747 ** the sqlite3_context object that P4 points to.
98766 ** the sqlite3_context object that P4 points to.
99975 ** merged. An aReadr[] object either points to a valid key or else is at EOF.
99997 ** currently points to the smallest key value. aTree[0] is unused.
100142 ** within a temp file. However, if the PmaReader.pIncr variable points to
102494 ** passed as the first argument currently points to. For the purposes of
103033 FileChunk *pChunk; /* Specific chunk into which cursor points */
103370 ** If the argument p points to a MemJournal structure that is not an
103894 ** pExpr->pLeft Any expression this points to is deleted
103895 ** pExpr->pRight Any expression this points to is deleted.
106372 ** Argument pVector points to a vector expression - either a TK_VECTOR
106645 ** Special case: If op==TK_INTEGER and pToken points to a string that
112203 ** points to. Additional entries are made on the AggInfo object as
113062 ** Technically, as x no longer points into a valid object or to the byte
114685 ** evenly spaced points along the index. Let the number of samples be S
116065 ** The first argument points to a nul-terminated string containing a
116595 ** Return true if zName points to a name that may be used to refer to
118410 ** Parameter zName points to a nul-terminated buffer containing the name
122291 ** points to the table name and the pTable points to the database name.
122406 ** usual case. If the term has an alias, then pAlias points to the
123300 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
123475 /* Bonus points if the text encoding matches */
123636 ** Free all resources held by the schema structure. The void* argument points
124412 ** iDataCur already points to the row to delete. If eMode is ONEPASS_OFF
124426 ** starting at iIdxCur) that already points to the index entry to be deleted.
126680 ** pExpr points to an expression which implements a function. If
127911 ** The second argument points to an FKey object representing a foreign key
127938 ** The second argument points to an FKey object representing a foreign key
128243 ** parameter aChange is passed a NULL value. For an UPDATE, aChange points
130184 ** that regNewData points to) will contain the new rowid, or NULL in the
132294 ** This is the function signature used for all extension entry points. It
135751 Table *pParent; /* Parent table that child points to */
141026 ** "p" points to the right-most of the two queries. the query on the
143615 ** Argument pWith (which may be NULL) points to a linked list of nested
146785 ** Turn a SELECT statement (that the pSelect parameter points to) into
149441 ** currently points to the conflicting table row. Otherwise, if pIdx
149443 ** cursor points to the conflicting row.
151549 ** and the WhereTerm.u.pOrInfo field points to auxiliary information that
151647 ** subclauses points to the WhereClause object for the whole clause.
158940 ** link that points to pX.
161517 /* If we reach this points it means that the new candidate path
164705 ** (current) that points to the next row to return to the query engine
164707 ** points to the next row to call the xStep() method of each window function
164709 ** points to the next row to call the xInverse() method of each window
173559 ** If the following global variable points to a string which is the
173568 ** If the following global variable points to a string which is the
175909 ** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
179265 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
179269 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
179715 ** points to a malloced buffer, size nDoclist bytes, containing the results
179721 ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
180141 ** When this function is called, *pp points to the first byte following a
180146 ** Argument pStart points to the first byte of the doclist that the
180157 /* Pointer p now points at the first byte past the varint we are
180482 ** The pointer returned points to memory obtained from sqlite3_malloc(). It
180520 ** The pointer returned points to a buffer allocated by sqlite3_malloc(). It
180577 ** The pointer returned points to a buffer allocated by sqlite3_malloc(). It
181720 ** start of a position-list. After it returns, *ppPoslist points to the
181725 ** routine advances *ppPoslist so that it points to the next docid in
181743 ** pEnd once more so that it points to the byte immediately following the
181764 ** start of a column-list. After it returns, *ppPoslist points to the
181814 ** If *pp points past the end of the current position-list, set *pi to
182045 ** iCol1 and iCol2) so that it points to either the 0x00 that marks the
182136 ** pEnd points 1 byte past the end of the buffer. When this function is
182137 ** called, if *pp points to pEnd or greater, then the end of the buffer
182396 ** Argument pList points to a position list nList bytes in size. This
183083 ** the row that the supplied cursor currently points to.
183279 ** moves *ppPoslist so that it instead points to the first byte of the
183297 /* At this point p points to that preceding byte without the 0x80 bit
183840 ** This function assumes that pList points to a buffer allocated using
184243 /* pIter now points just past the 0x00 that terminates the position-
184836 ** the example above). When this function is called, *paPoslist points to
184839 ** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to
185144 ** currently points to, or zero if it does not.
185243 ** cursor points to a row that matches the query expression, with the
191393 /* Pointer p currently points at the first byte of an offset list. The
191401 ** incrementally and pointer "p" now points to the first byte past
191711 ** version, it is assumed that each SegReader points to an entry in
191747 ** points to with the term specified by arguments zTerm and nTerm.
192648 ** for, then advance each segment iterator until it points to a term of
192696 /* Advance each segment iterator until it points to the term zTerm/nTerm. */
192815 /* If this is a prefix-search, and if the term that apSegment[0] points
195374 ** based on the row that pCsr currently points to.
195384 sqlite3_int64 iDocid; /* Docid of the row pCsr points to */
195939 ** When this function is called, *pp points to the start of an element of
196050 ** arguments so that it points to the first element with a value greater
196213 ** (b) +1000 points for the first occurrence of each matchable phrase in
196470 ** in the FTS code the variable that the third argument to xNext points to
196813 ** 1 if the iterator is at EOF or if it now points to the start of the
201236 RtreeSearchPoint *aPoint; /* Priority queue for search points */
201259 ** variable pRtree points to the Rtree structure associated with the
202337 ** Compare two search points. Return negative, zero, or positive if the first
202358 ** Interchange two search points in a cursor.
205066 ** Argument pCell points to an array of coordinates stored on an rtree page.
205117 ** the r-tree structure. Argument aParent points to the array of coordinates
205302 ** points to the correct node.
205767 sqlite3_str_appendf(x, "<polyline points=");
207767 ** Collation sequence destructor function. The pCtx argument points to
207776 ** Collation sequence comparison function. The pCtx argument points to
209057 ** * each index of the table (zero or more points to visit), and
209062 ** it points to an array of flags nTblCol elements in size. The flag is
209569 ** Unless it is NULL, argument zSql points to a buffer allocated using
209968 ** Argument *piPk is also of type (int*), and also points to an output
210128 ** the table (not index) that the iterator currently points to.
210681 ** (p->objiter.pSelect) currently points to a valid row. However, there
210696 ** passed as the second argument currently points to if the rbu_control
210779 ** The iterator currently points to a table (not index) of type
210782 ** if the iterator points to a table created as:
211388 ** table object that pIter currently points to, assuming that the
212078 ** (p->objiter.pSelect) currently points to a valid row. This function
212224 ** The object-iterator (p->objiter) currently points to a valid object,
212225 ** and the input cursor (p->objiter.pSelect) currently points to a valid
213362 ** Given that zWal points to a buffer containing a wal file name passed to
216091 ** The buffer that the argument points to contains a serialized SQL value.
216240 ** If, when this function is called, *paTwo points to a valid value (i.e.
216244 ** set to the number of bytes in the value at *paOne. If *paOne points
217684 ** in column iCol of the row that SQL statement pStmt currently points
217739 ** values). The statement handle passed as the second argument points
218450 ** When this function is called, *ppRec points to the start of a record
218452 ** until it points to the byte immediately following that record.
218501 ** When this function is called, *paChange points to the start of the record
218589 ** The input pointer currently points to the second byte of a table-header.
218636 ** The input pointer currently points to the first byte of the first field
218672 ** The input pointer currently points to the second byte of a table-header.
218934 ** the database table affected by the change that pIter currently points
219654 ** are transfered to the statement. Otherwise, if abPK is not NULL, it points
219672 ** argument iterator points to a suitable entry. Make sure that xValue
219696 ** iterator pIter points to to the SELECT and attempts to seek to the table
219706 ** If the iterator currently points to an INSERT record, bind values from the
219707 ** new.* record to the SELECT statement. Or, if it points to a DELETE or
219786 ** currently points to.
219895 ** currently points to to the database. If a conflict is encountered, invoke
220042 ** currently points to to the database. If a conflict is encountered, invoke
222140 /* If non-NULL, points to sqlite3_vtab.base.zErrmsg. Often NULL. */
222335 ** Argument p points to a buffer containing utf-8 text that is n bytes in
224409 ** z points to a buffer containing n bytes of text to append. If n is
224784 /* Advance iterator ctx.iter so that it points to the first coalesced
225443 ** Argument pIn points to a character that is part of a nul-terminated
225456 ** Argument pIn points to a character that is part of a nul-terminated
226136 ** Argument pIn points to the first character in what is expected to be
226802 ** that it points to.
227141 ** Advance iterator pIter until it points to a value equal to or laster
227142 ** than the initial value of *piLast. If this means the iterator points
227408 i64 iLast; /* Lastest rowid any iterator points to */
227420 /* Initialize iLast, the "lastest" rowid any iterator points to. If the
227485 /* Find the firstest rowid any synonym points to. */
227488 /* Advance each iterator that currently points to iRowid. Or, if iFrom
227489 ** is valid - each iterator that points to a rowid before iFrom. */
227656 /* Advance pChild until it points to iLast or laster */
227751 ** If pNode currently points to a match, this function returns SQLITE_OK
230501 ** points to the smaller term/rowid combination. Iterators at EOF are
230504 ** aFirst[1] contains the index in aSeg[] of the iterator that points to
231397 ** points to the first rowid in the doclist-index.
231454 /* Currently iOff points to the first byte of a varint. This block
231455 ** decrements iOff until it points to the first byte of the previous
231620 ** Argument p points to a buffer containing a varint to be interpreted as a
231636 ** Fts5SegIter.iLeafOffset currently points to the first byte of a
231694 ** Fts5SegIter.iLeafOffset currently points to the first byte of the
231802 ** This function advances the iterator so that it points to the last
231805 ** is in its regular state - Fts5SegIter.iLeafOffset points to the first
231914 ** points to a delete marker. A delete marker is an entry with a 0 byte
232160 ** Iterator pIter currently points to the first rowid in a doclist. This
232176 /* Currently, Fts5SegIter.iLeafOffset points to the first byte of
232178 ** points to the start of the position-list size field. */
232221 ** rowid. In this case configure the iterator so that it points to the
232248 ** Iterator pIter currently points to the first rowid of a doclist.
232495 ** 2) the iterator points to EOF, or
232496 ** 3) the iterator points to an entry with term (pTerm/nTerm), or
232497 ** 4) the FTS5INDEX_QUERY_SCAN flag was set and the iterator points
232729 ** Move the seg-iter so that it points to the first rowid on page iLeafPgno.
232855 ** points to the same term though - just a different rowid. This function
233169 ** Iterator pIter currently points to a valid entry (not EOF). This
233208 ** Parameter pPos points to a buffer containing a position list, size nPos.
233246 /* Advance pointer p until it points to pEnd or an 0x01 byte that is
233448 ** The iterator initially points to the first term/rowid entry in the
233520 /* If the above was successful, each component iterators now points
233606 ** Return the rowid of the entry that the iterator currently points
233607 ** to. If the iterator points to EOF when this function is called the
233635 ** entry that the iterator currently points to.
235469 ** Argument p points to a buffer containing utf-8 text that is n bytes in
236123 ** is also a rowid pointer within the leaf page header, it points to a
238232 ** Return the rowid that the cursor currently points to.
239297 ** the row that the supplied cursor currently points to.
239721 ** sqlite3Fts5Init() is omitted and the two standard entry points
240806 ** Argument aCol points to an array of integers containing one entry for