Lines Matching refs:cursor
5517 ** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor}
5527 ** the content of a cursor structure to suit its own needs.
5529 ** This superclass exists in order to define fields of the cursor that
5533 sqlite3_vtab *pVtab; /* Virtual table of this cursor */
8063 BtCursor *pCursor /* Space to write cursor structure */
9914 ** when the VDBE cursor to the table is closed. In this case Table.tnum
9915 ** refers VDBE cursor number that holds the table open, not to the root
10255 ** the integer cursor number of a VDBE cursor pointing to that table and
10317 int iTable; /* TK_COLUMN: cursor number of table holding column
10503 int iCursor; /* The VDBE cursor number used to access this table */
10565 int iTabCur; /* The VDBE cursor used to access the table */
10566 int iIdxCur; /* The VDBE cursor used to access pIdx */
10578 int iCur; /* The VDBE cursor used by this IN operator */
10853 int iTable; /* Table cursor number */
12581 ** A cursor is a pointer into a single BTree within a database file.
12582 ** The cursor can seek to a BTree entry with a particular key, or
12584 ** entries or retrieve the key or data from the entry that the cursor
12587 ** Every cursor that the virtual machine has open is represented by an
12591 BtCursor *pCursor; /* The cursor structure of the backend */
12594 int iDb; /* Index of cursor database in db->aDb[] (or -1) */
12607 sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */
12608 const sqlite3_module *pModule; /* Module for cursor pVtabCursor */
12615 ** OP_IsUnique opcode on this cursor. */
12619 ** cursor is currently pointing to. Only valid if cacheStatus matches
12835 VdbeCursor **apCsr; /* One element of this array for each open cursor */
47647 ** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor
47813 ** A cursor is a pointer to a particular entry within a particular
47820 ** but cursors cannot be shared. Each cursor is associated with a
47827 Btree *pBtree; /* The Btree to which this cursor belongs */
47828 BtShared *pBt; /* The BtShared this cursor points to */
47835 void *pKey; /* Saved key that was cursor's last known position */
47843 u8 isIncrblobHandle; /* True if this cursor is an incr. io handle */
47862 ** The table that this cursor was opened on still exists, but has been
47863 ** modified since the cursor was last used. The cursor position is saved
47864 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
47866 ** seek the cursor to the saved position.
47871 ** cursor. The error has left the cache in an inconsistent state.
47872 ** Do nothing else with this cursor. Any attempt to use the cursor
48130 ** Enter and leave a mutex on a Btree given a cursor owned by that
48454 ** have a read cursor.
48683 ** Verify that the cursor holds the mutex on its BtShared
48694 ** Invalidate the overflow page-list cache for cursor pCur, if any.
48821 ** Save the current cursor position in the variables BtCursor.nKey
48822 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
48824 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
48874 ** the table with root-page iRoot. Usually, this is called just before cursor
48894 ** Clear the current cursor position.
48938 ** Restore the cursor to the position it was in (or as close to as possible)
48967 ** Determine whether or not a cursor has moved from the position it
48972 ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
51495 ** For the purposes of this routine, a write-cursor is any cursor that
51496 ** is capable of writing to the databse. That means the cursor was
51497 ** originally opened for writing and the cursor has not be disabled
51512 ** code to errCode for every cursor on BtShared that pBtree
51515 ** Every cursor is tripped, including cursors that belong
51524 ** save the state of the cursor. The cursor must be
51545 ** invalided by this operation. Any attempt to use a cursor
51562 ** trying to save cursor positions. If this is an automatic rollback (as
51675 ** Create a new cursor for the BTree whose root is on the page
51676 ** iTable. If a read-only cursor is requested, it is assumed that
51678 ** on the database already. If a write-cursor is requested, then
51681 ** If wrFlag==0, then the cursor can only be used for reading.
51682 ** If wrFlag==1, then the cursor can be used for reading or for
51687 ** 1: The cursor must have been opened with wrFlag==1
51692 ** the changes made by this write cursor would be visible to
51700 ** root page of a b-tree. If it is not, then the cursor acquired
51711 BtCursor *pCur /* Space for new cursor */
51720 ** and that no other connection has any open cursor that conflicts with
51739 ** variables and link the cursor into the BtShared list. */
51760 BtCursor *pCur /* Write new cursor here */
51773 ** sufficient storage to hold a cursor. The BtCursor object is opaque
51794 ** Set the cached rowid value of every cursor in the same database file
51814 ** Return the cached rowid for the given cursor. A negative or zero
51824 ** Close a cursor. The read lock on the database file is released
51825 ** when the last cursor is closed.
51904 ** Return true if the given BtCursor is valid. A valid cursor is one
51915 ** the key for the current entry. If the cursor is not pointing
51921 ** The caller must position the cursor prior to invoking this routine.
51939 ** cursor currently points to.
51941 ** The caller must guarantee that the cursor is pointing to a non-NULL
51943 ** that the cursor has Cursor.eState==CURSOR_VALID.
52067 ** for the entry that the pCur cursor is pointing to. If the eOp
52079 ** cursor entry uses one or more overflow pages, this function
52085 ** invalidated if some other cursor writes to the same table, or if
52086 ** the cursor is moved to a different row. Additionally, in auto-vacuum
52105 BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
52226 ** Read part of the key associated with cursor pCur. Exactly
52246 ** Read part of the data associated with cursor pCur. Exactly
52276 ** pCur cursor is pointing to. The pointer is to the beginning of
52332 ** For the entry that cursor pCur is point to, return as
52366 ** Move the cursor down to a new child page. The newPgno argument is the
52421 ** Move the cursor up to the parent page.
52445 ** Move the cursor to point to the root page of its b-tree structure.
52447 ** If the table has a virtual root page, then the cursor is moved to point
52452 ** If the b-tree structure is empty, the cursor state is set to
52453 ** CURSOR_INVALID. Otherwise, the cursor is set to point to the first
52454 ** cell located on the root (or virtual root) page and the cursor state
52459 ** kind of b-tree page (i.e. if when opening the cursor the caller did not
52500 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
52514 ** byte to have been modified while this cursor is holding a reference
52538 ** Move the cursor down to the left-most leaf entry beneath the
52560 ** Move the cursor down to the right-most leaf entry beneath the
52589 /* Move the cursor to the first entry in the table. Return SQLITE_OK
52590 ** on success. Set *pRes to 0 if the cursor actually points to something
52612 /* Move the cursor to the last entry in the table. Return SQLITE_OK
52613 ** on success. Set *pRes to 0 if the cursor actually points to something
52622 /* If the cursor already points to the last entry, this is a no-op. */
52625 /* This block serves to assert() that the cursor really does point
52652 /* Move the cursor so that it points to an entry near the key
52659 ** If an exact match is not found, then the cursor is always
52661 ** were present. The cursor might point to an entry that comes
52665 ** comparing the key with the entry to which the cursor is
52669 ** *pRes<0 The cursor is left pointing at an entry that
52671 ** and the cursor is therefore left point to nothing.
52673 ** *pRes==0 The cursor is left pointing at an entry that
52676 ** *pRes>0 The cursor is left pointing at an entry that
52681 BtCursor *pCur, /* The cursor to be moved */
52694 /* If the cursor is already positioned at the point we are trying
52729 ** the cursor would have been INVALID above and this for(;;) loop
52858 ** Return TRUE if the cursor is not pointing at an entry of the table.
52865 /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
52873 ** Advance the cursor to the next entry in the database. If
52874 ** successful then set *pRes=0. If the cursor
52942 ** Step the cursor to the back to the previous entry in the database. If
52943 ** successful then set *pRes=0. If the cursor
53470 /* There is no reason any cursor should have an outstanding reference
54917 ** and the data is given by (pData,nData). The cursor is used only to
54918 ** define what table the record should be inserted into. The cursor
54925 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
54932 ** cursor pCur is pointing at the existing copy of a row that is to be
54933 ** overwritten. If the seekResult parameter is 0, then cursor pCur may
54935 ** the cursor before the new key can be inserted.
54938 BtCursor *pCur, /* Insert data into the table of this cursor */
54964 /* Assert that the caller has been consistent. If this cursor was opened
54966 ** keys with no associated data. If the cursor was opened expecting an
54985 ** that the cursor is already where it needs to be and returns without
54987 ** not to clear the cursor here.
55039 ** the cursor, zero the BtCursor.info.nSize and BtCursor.validNKey
55042 ** Previous versions of SQLite called moveToRoot() to move the cursor
55045 ** set the cursor state to "invalid". This makes common insert operations
55049 ** multiple records into an intkey b-tree using a single cursor (as can
55051 ** is advantageous to leave the cursor pointing to the last entry in
55052 ** the b-tree if possible. If the cursor is left pointing to the last
55055 ** row without seeking the cursor. This can be a big performance boost.
55064 ** Also, set the cursor state to invalid. This stops saveCursorPosition()
55065 ** from trying to save the current position of the cursor. */
55076 ** Delete the entry that the cursor is pointing to. The cursor
55113 ** the cursor to the largest entry in the tree that is smaller than
55138 /* If the cell deleted was not located on a leaf page, then the cursor
55163 ** then the cursor still points to that page. In this case the first
55175 ** walk the cursor up the tree to the internal node and balance it as
55457 ** root page. If an open cursor was using this page a problem would
55621 ** The first argument, pCur, is a cursor opened on some b-tree. Count the
55654 /* pPage is a leaf node. This loop navigates the cursor so that it
55678 /* Descend to the child node of the cell that the cursor currently
56351 ** Argument pCsr must be a cursor opened for writing on an
56376 ** (a) the cursor is open for writing,
56380 ** (e) the cursor points at a valid row of an intKey table.
56394 ** Set a flag on this cursor to cache the locations of pages from the
59792 /* For each cursor required, also allocate a memory cell. Memory
59796 ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1)
59797 ** stores the blob of memory associated with cursor 1, etc.
59819 /* Memory for registers, parameters, cursor, etc, is allocated in two
59870 ** Close a VDBE cursor and release all the resources that cursor
60287 ** has been modified, "trip" or invalidate each cursor in
60288 ** that Btree might have been modified so that the cursor
60291 ** cursor from other VMs in different database connections,
60298 ** the state of the cursor. We have to invalidate the cursor
60782 ** Make sure the cursor p is ready to read or write the row to which it
60784 ** prevents us from positioning the cursor to its correct position.
60786 ** If a MoveTo operation is pending on the given cursor, then do that
60788 ** deleted out from under the cursor and if it has, mark the row as
60791 ** If the cursor is already pointing to the correct row and that row has
60792 ** not been deleted out from under the cursor, then this routine is a no-op.
61424 ** Compare the key of the index entry that cursor pC is pointing to against
61435 VdbeCursor *pC, /* The cursor to compare against */
63067 ** The following global variable is incremented every time a cursor
63166 /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
63205 int iDb, /* When database the cursor belongs to, or -1 */
63213 ** * Sometimes cursor numbers are used for a couple of different
63223 ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
63224 ** cursor 1 is managed by memory cell (p->nMem-1), etc.
63750 VdbeCursor *pC; /* The VDBE cursor */
63752 BtCursor *pCrsr; /* The BTree cursor */
64658 /* Invalidate all ephemeral cursor row caches */
65637 ** Interpret the data that cursor P1 points to as a structure built using
65649 ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
65650 ** then the cache of the cursor is reset prior to extracting the column.
65660 VdbeCursor *pC; /* The VDBE cursor */
65662 BtCursor *pCrsr; /* The BTree cursor */
65697 ** If the record is stored in a cursor, the complete record text
65761 ** into the record header cache fields of the cursor.
66113 ** opened by cursor P1 in register P2
66458 ** must be started or there must be an open cursor) before
66584 ** Open a read-only cursor for the database table whose root page is
66588 ** database. Give the new cursor an identifier of P1. The P1
66596 ** open cursor. If the database was unlocked prior to this instruction
66614 ** Open a read/write cursor named P1 on the table or index whose root
66625 ** This instruction works just like OpenRead except that it opens the cursor
66627 ** cursors or a single read/write cursor but not both.
66714 ** Open a new cursor P1 to a transient table.
66715 ** The cursor is always opened read/write even if
66717 ** table is deleted automatically when the cursor is closed.
66720 ** The cursor points to a BTree table if P4==0 and to a BTree index
66817 ** Open a new cursor that points to a fake table that contains a single
66819 ** register P2. In other words, cursor P1 becomes an alias for the
66825 ** is the only cursor opcode that works with a pseudo-table.
66847 ** Close a cursor previously opened as P1. If P1 is not
66859 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
66860 ** use the value in register P3 as the key. If cursor P1 refers
66864 ** Reposition cursor P1 so that it points to the smallest entry that
66872 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
66873 ** use the value in register P3 as a key. If cursor P1 refers
66877 ** Reposition cursor P1 so that it points to the smallest entry that
66885 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
66886 ** use the value in register P3 as a key. If cursor P1 refers
66890 ** Reposition cursor P1 so that it points to the largest entry that
66898 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
66899 ** use the value in register P3 as a key. If cursor P1 refers
66903 ** Reposition cursor P1 so that it points to the largest entry that
67065 ** P1 is an open table cursor and P2 is a rowid integer. Arrange
67069 ** the cursor is used to read a record. That way, if no reads
67188 ** that make up an unpacked index key that can be used with cursor P1.
67189 ** The value of N can be inferred from the cursor. N includes the rowid
67196 ** Otherwise, this instruction checks if cursor P1 contains an entry
67223 /* Find the index cursor. */
67272 ** If the record does exist, then fall through. The cursor is left
67313 /* This happens when an attempt to open a read cursor on the
67325 ** Find the next available sequence number for cursor P1.
67327 ** The sequence number on the cursor is incremented after this
67342 ** table that cursor P1 points to. The new record number is written
67491 ** Write an entry into the table of cursor P1. A new entry is
67505 ** the insert but will instead overwrite the row that the cursor is
67507 ** has already positioned the cursor correctly. This is an optimization
67519 ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
67520 ** allocated, then ownership of P2 is transferred to the pseudo-cursor
67521 ** and register P2 becomes ephemeral. If the cursor is changed, the
67605 ** Delete the record at which the P1 cursor is currently pointing.
67607 ** The cursor will be left pointing at either the next or the previous
67620 ** If P4 is not NULL then the P1 cursor must have been positioned
67646 ** might move or invalidate the cursor. Hence cursor u.bh.pC is always pointing
67684 ** P1 is a sorter cursor. This instruction compares the record blob in
67685 ** register P3 with the entry that the sorter cursor currently points to.
67707 ** Write into register P2 the current sorter data for sorter cursor P1.
67727 ** Write into register P2 the complete row data for cursor P1.
67732 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
67737 ** Write into register P2 the complete row key for cursor P1.
67742 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
67773 ** the cursor. Hence the following sqlite3VdbeCursorMoveto() call is always
67861 ** Move the cursor P1 to a null row. Any OP_Column operations
67862 ** that occur while the cursor is on the null row will always
67982 ** Advance cursor P1 so that it points to the next key/data pair in its
67984 ** to the following instruction. But if the cursor advance was successful,
67987 ** The P1 cursor must be for a real table, not a pseudo-table.
67999 ** Back up cursor P1 so that it points to the previous key/data pair in its
68001 ** to the following instruction. But if the cursor backup was successful,
68004 ** The P1 cursor must be for a real table, not a pseudo-table.
68110 ** index opened by cursor P1.
68147 ** the end of the index key pointed to by cursor P1. This integer should be
68192 ** that if the key from register P3 is a prefix of the key in the cursor,
68730 ** cell is required for each cursor used by the program. Set local
69302 ** P1 is a cursor number. This opcode opens a cursor to the virtual
69303 ** table and stores that cursor in P1.
69324 /* Initialise vdbe cursor object */
69341 ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
69419 ** P1 cursor is pointing to into register P3.
69502 ** some other method is next invoked on the save virtual table cursor.
69835 int iOffset; /* Byte offset of blob in cursor data */
69838 sqlite3_stmt *pStmt; /* Statement holding cursor open */
69845 ** the b-tree cursor associated with blob handle p to point to row iRow.
69856 ** If an error does occur, then the b-tree cursor is closed. All subsequent
69927 /* This VDBE program seeks a btree cursor to the identified
69933 ** After seeking the cursor, the vdbe executes an OP_ResultRow.
69934 ** Code external to the Vdbe then "borrows" the b-tree cursor and
69939 ** which closes the b-tree cursor and (possibly) commits the
69948 {OP_OpenRead, 0, 0, 0}, /* 3: Open cursor 0 for reading */
69949 {OP_OpenWrite, 0, 0, 0}, /* 4: Open cursor 0 for read/write */
69952 {OP_NotExists, 0, 10, 1}, /* 6: Seek the cursor */
70097 /* Configure the number of columns. Configure the cursor to
70661 ** Initialize the temporary index cursor just opened as a sorter cursor.
70703 ** Free any cursor components allocated by sqlite3VdbeSorterXXX routines.
70888 VdbeCursor *pCsr, /* Sorter cursor */
70984 /* Write the current b-tree to a PMA. Close the b-tree cursor. */
71137 ** Compare the key in memory cell pVal with the key that the sorter cursor
71147 VdbeCursor *pCsr, /* Sorter cursor */
71450 ** An instance of this object serves as a cursor into the rollback journal.
71451 ** The cursor can be either for reading or writing.
71455 FileChunk *pChunk; /* Specific chunk into which cursor points */
71909 ** pExpr->iTable Set to the cursor number for the table obtained
72928 ** Expr.iTable The VDBE cursor number for X.Y
74401 ** The index of the cursor opened on the b-tree (database table, database index
74405 ** IN_INDEX_ROWID - The cursor was opened on a database table.
74406 ** IN_INDEX_INDEX - The cursor was opened on a database index.
74407 ** IN_INDEX_EPH - The cursor was opened on a specially created and
74823 /* Compute the RHS. After this step, the table with cursor
75148 int iTabCur, /* The cursor for this table */
75169 ** There must be an open cursor to pTab in iTable when this routine
75176 int iTable, /* The cursor pointing to the table */
77624 ** writing with cursor iStatCur. If the library was built with the
77626 ** opened for writing using cursor (iStatCur+1)
77641 int iStatCur, /* Open the sqlite_stat1 table on this cursor */
77781 /* Open a cursor to the index to be analyzed. */
77851 /* Check if the record that cursor iIdxCur points to contains a
79336 /* A minimum of one cursor is required if autoincrement is used
79730 ** writing. The table is opened using cursor 0.
81461 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
81462 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
81500 /* Open the sorter cursor if we are to use one. */
83695 /* Assign cursor number to the table and all its indices.
83867 ** 1. A read/write cursor pointing to pTab, the table containing the row
83868 ** to be deleted, must be opened as cursor number $iCur.
83871 ** cursor number base+i for the i-th index.
83895 /* Seek cursor iCur to the row to delete. If this row no longer exists
83930 /* Seek the cursor to the row to be deleted again. It may be that
83976 ** 1. A read/write cursor pointing to pTab, the table containing the row
83977 ** to be deleted, must be opened as cursor number "iCur".
83980 ** cursor number iCur+i for the i-th index.
83982 ** 3. The "iCur" cursor must be pointing to the row that is to be
84005 ** iCur is the index of a cursor open on the pTab table and pointing to
86443 ** a cursor to use to search the unique index on the parent key columns
86902 int iCur, /* The cursor number of the table */
87231 ** open write cursor to <table> and its indices
87249 ** open a write cursor to <table>
87250 ** open read cursor on <table2>
87254 ** open a write cursor on the <table> index
87255 ** open a read cursor on the corresponding <table2> index
87276 ** B: open write cursor to <table> and its indices
87306 ** M: open write cursor to <table> and its indices
87334 int srcTab = 0; /* Data comes from this temporary cursor if >=0 */
88012 ** The calling routine must open a read/write cursor for pTab with
88013 ** cursor number "baseCur". All indices of pTab must also have open
88014 ** read/write cursors with cursor number baseCur+i for the i-th cursor.
88021 int baseCur, /* Index of a read/write cursor pointing at pTab */
88037 int iCur; /* Table cursor number */
88307 int baseCur, /* Index of a read/write cursor pointing at pTab */
88359 ** indices of that table. The "baseCur" parameter is the cursor number used
91695 /* Create a cursor to hold the database open
94856 ** FROM clause of a SELECT such that the VDBE cursor assigned to that
95056 int iParent; /* VDBE cursor number of the pSub result set temp table */
95279 ** the cursor number for the original outer query FROM element in
95280 ** iParent. The iParent cursor will never be used. Subsequent code
95509 ** (1) Make sure VDBE cursor numbers have been assigned to every
95547 /* Make sure cursor numbers have been assigned to all entries in
95924 ** the current cursor position.
96052 ** the result there. The cursor is left open after
96723 /* Open a read-only cursor, execute the OP_Count, close the cursor. */
98434 ** need to occur right after the database cursor. So go ahead and
98636 /* Make cursor iCur point to the record that is being updated. If
100404 ** cursor number and column number for X. WhereTerm.eOperator records
100422 ** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers,
100424 ** cursor number into bits and the translated bit is stored in the prereq
100426 ** bits that will fit in a Bitmask. The VDBE cursor numbers might be
100427 ** spread out over the non-negative integers. For example, the cursor
100429 ** translates these sparse cursor numbers into consecutive integers
100431 ** bits in the Bitmask. So, in the example above, the cursor numbers
100478 WhereMaskSet *pMaskSet; /* Mapping of table cursor numbers to bitmasks */
100510 ** between VDBE cursor numbers and bits of the bitmasks in WhereTerm.
100512 ** The VDBE cursor numbers are small integers contained in
100514 ** clause, the cursor numbers might not begin with 0 and they might
100517 ** from the sparse cursor numbers into consecutive integers beginning
100521 ** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<<A.
100525 ** would map those cursor numbers into bits 0 through 5.
100530 ** does not really matter. What is important is that sparse cursor
100535 int n; /* Number of assigned cursor values */
100609 WhereMaskSet *pMaskSet /* Mapping from table cursor numbers to bitmasks */
100743 ** Return the bitmask for the given cursor number. Return 0 if
100758 ** Create a new mask for cursor iCursor.
100760 ** There is one cursor per table in the FROM clause. The number of
100780 ** the VDBE cursor number of the table. This routine just has to
100781 ** translate the cursor numbers into bitmask values and OR all
101163 ** WhereTerm.u.pOrInfo->indexable |= the cursor number for table T
101316 int iCursor = -1; /* Table cursor common to all terms */
101758 ** Argument iBase is the cursor number used for the table that pIdx refers
101918 ** the table has a cursor number of "base". pIdx is an index on pTab.
101932 WhereMaskSet *pMaskSet, /* Mapping from table cursor numbers to bitmaps */
102144 const int iCur = pSrc->iCursor; /* The cursor of the table to be accessed */
103217 int iCur = pSrc->iCursor; /* The cursor of the table to be accessed */
103899 int iCur = pLevel->iTabCur; /* The cursor of the table */
104127 int iCur; /* The VDBE cursor for the table */
104374 int iIdxCur; /* The VDBE cursor for the index */
104440 /* Seek the index cursor to the start of the range. */
104510 /* Check if the index cursor is past the end of the range. */
104533 /* Seek the table cursor, if required */
104647 ** called on an uninitialized cursor.
104841 ** There are Btree cursors associated with each table. t1 uses cursor
104842 ** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor.
104877 ** move the row2 cursor to a null row
105051 ** pWInfo->a[].iTabCur The VDBE cursor for the database table
105052 ** pWInfo->a[].iIdxCur The VDBE cursor for the index
105494 ** seeking the table cursor to the record corresponding to the current
113855 ** Create a tokenizer cursor to tokenize an input buffer. The caller
113857 ** until the cursor is closed (using the xClose() method).
113862 sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */
113866 ** Destroy an existing tokenizer cursor. The fts3 module calls this
113872 ** Retrieve the next token from the tokenizer cursor pCursor. This
113896 sqlite3_tokenizer_cursor *pCursor, /* Tokenizer cursor */
113910 sqlite3_tokenizer *pTokenizer; /* Tokenizer for this cursor. */
114238 ** virtual table cursor (an instance of the following structure) using
114246 sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */
115507 sqlite3_vtab_cursor *pCsr; /* Allocated cursor */
115524 ** Close the cursor. For additional information see the documentation
116624 ** Set up a cursor object for iterating through a full-text index or a
116686 Fts3Cursor *pCsr, /* Virtual table cursor handle */
116690 Fts3MultiSegReader **ppSegcsr /* OUT: Allocated seg-reader cursor */
116756 Fts3MultiSegReader *pSegcsr; /* Seg-reader cursor for this term */
116820 ** Advance the cursor to the next row in the %_content table that
116865 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
116884 /* In case the cursor has been used before, clear it now. */
116927 /* Compile a SELECT statement for this cursor. For a full-table-scan, the
116975 ** the row that the supplied cursor currently points to.
116996 ** Return a blob which is a pointer to the cursor.
117110 Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
117512 ** An Fts3SegReader object is a cursor that can seek or scan a range of
117524 Fts3Cursor *pCsr, /* FTS cursor handle */
118581 Fts3Cursor *pCsr, /* FTS cursor handle */
118667 ** cursor points to a row that matches the query expression, with the
118781 ** expression rooted at pExpr, the cursor iterates through all rows matched
118943 Fts3Cursor *pCsr, /* FTS cursor handle */
118991 Fts3Cursor *pCsr, /* FTS3 cursor object */
119096 int isEof; /* True if cursor is at EOF */
119250 ** xOpen - Open a cursor.
119253 Fts3auxCursor *pCsr; /* Pointer to cursor object to return */
119266 ** xClose - Close a cursor.
119298 ** xNext - Advance the cursor to the next row, if any.
119392 ** xFilter - Initialize a cursor to point at the start of its data.
119395 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
119416 /* In case this cursor is being reused, close and zero it. */
119453 ** xEof - Return true if the cursor is at EOF, or false otherwise.
119489 ** xRowid - Return the current rowid for the cursor.
119782 ** The first pass, in the block below, uses a tokenizer cursor to iterate
120972 ** string to be tokenized is zInput[0..nInput-1]. A cursor
120979 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
121006 ** Close a tokenization cursor previously opened by a call to
121462 ** Extract the next token from a tokenization cursor. The cursor must
122133 ** string to be tokenized is pInput[0..nBytes-1]. A cursor
122140 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
122167 ** Close a tokenization cursor previously opened by a call to
122178 ** Extract the next token from a tokenization cursor. The cursor must
122344 ** Each cursor has a (possibly empty) linked list of the following objects.
125322 Fts3Cursor *pCsr, /* Fts3 table cursor */
125727 ** Load the doclists for each phrase in the query associated with FTS3 cursor
125737 Fts3Cursor *pCsr, /* Fts3 cursor for current query */
126095 /* Open a cursor on zDoc/nDoc. Check if there are (nSnippet+nDesired)
126122 ** Extract the snippet text for fragment pFragment from cursor pCsr and
126147 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
126160 /* Open a token cursor on the document. */
126533 Fts3Cursor *pCsr, /* FTS3 cursor object */
126889 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
126989 Fts3Cursor *pCsr, /* FTS3 table cursor */
127237 ** An rtree cursor object.
127241 RtreeNode *pNode; /* Node cursor is currently pointing at */
127881 ** Return non-zero if the cursor does not currently point to a valid
127964 ** Test if the cell that cursor pCursor currently points to
128118 /* RtreeCursor.pNode must not be NULL. If is is NULL, then this cursor is
128120 ** a cursor that has already reached EOF.
129887 rtreeOpen, /* xOpen - open a cursor */
129888 rtreeClose, /* xClose - close a cursor */
129890 rtreeNext, /* xNext - advance a cursor */
130902 ** string to be tokenized is pInput[0..nBytes-1]. A cursor
130910 sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
130973 ** Close a tokenization cursor previously opened by a call to icuOpen().
130984 ** Extract the next token from a tokenization cursor.