Lines Matching refs:structure
540 ** presents to client programs. If a C-function, structure, datatype,
719 ** the opaque structure named "sqlite3". It is useful to think of an sqlite3
1097 ** point to a structure that may contain arguments or space in which to
1204 ** object when the iVersion value is increased. Note that the structure
1210 ** structure used by this VFS. mxPathname is the maximum length of
1221 ** structure that SQLite will ever modify. SQLite will only access
1291 ** to hold the [sqlite3_file] structure passed as the third
1293 ** allocate the structure; it should just fill it in. Note that
1315 ** included in the VFS structure for completeness.
1642 ** instance of the [sqlite3_mem_methods] structure. The argument specifies
1645 ** its own private copy of the content of the [sqlite3_mem_methods] structure
1650 ** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods]
1651 ** structure is filled with the currently defined memory allocation routines.)^
1728 ** instance of the [sqlite3_mutex_methods] structure. The argument specifies
1731 ** content of the [sqlite3_mutex_methods] structure before the call to
1740 ** instance of the [sqlite3_mutex_methods] structure. The
1742 ** structure is filled with the currently defined mutex routines.)^
2124 ** Definition: A <b>result table</b> is memory data structure created by the
4664 ** This structure, sometimes called a a "virtual table module",
4666 ** This structure consists mostly of methods for the module.
4669 ** instance of this structure and passing a pointer to that instance
4673 ** of this structure must not change while it is registered with
4711 ** The sqlite3_index_info structure and its substructures is used to
4859 ** following structure to describe cursors that point into the
4866 ** the content of a cursor structure to suit its own needs.
5260 ** An instance of this structure defines the low-level routines
5267 ** creates and populates an instance of this structure to pass
5269 ** Additionally, an instance of this structure can be used as an
5273 ** ^The xMutexInit method defined by this structure is invoked as
5278 ** ^The xMutexEnd method defined by this structure is invoked as
5285 ** ^(The remaining seven methods defined by this structure (xMutexAlloc,
5302 ** by this structure are not required to handle this case, the results
5692 ** its size or internal structure and never deals with the
5707 ** instance of the sqlite3_pcache_methods structure.)^ The majority of the
5716 ** ^(The contents of the sqlite3_pcache_methods structure are copied to an
6216 /* A complete hash table is an instance of the following structure.
6217 ** The internals of this structure are intended to be opaque -- client
6218 ** code should not attempt to access or modify the fields of this structure
6219 ** directly. Change this structure only by using the routines below.
6221 ** accessing this structure are really macros, so we can't really make
6222 ** this structure opaque.
6248 ** structure. All elements are stored on a single doubly-linked list.
6250 ** Again, this structure is intended to be opaque, but it can't really
6664 ** An instance of the following structure is used to store the busy-handler
6842 ** Forward declarations of structure
6850 ** This structure records all of the Btrees that need to hold
6953 BtCursor *pCursor /* Space to write cursor structure */
7073 ** A single VDBE is an opaque structure named "Vdbe". Only routines
7075 ** of this structure.
7090 ** as an instance of the following structure:
7134 int nRef; /* Number of pointers to this structure */
7156 #define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */
7157 #define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */
7158 #define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */
7159 #define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */
7160 #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
7162 #define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */
7168 #define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */
7170 /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
7201 ** of a VdbeOp structure into a negative number so that
7502 ** Each open file is managed by a separate instance of the "Pager" structure.
7659 ** structure.
8063 ** sqlite3_malloc() to obtain space for the file-handle structure.
8152 ** of the following structure. There are normally two of these structures
8159 Btree *pBt; /* The B*Tree structure for this database file */
8166 ** An instance of the following structure stores a database schema.
8172 ** added to the Schema structure and the Schema.db variable populated,
8229 ** The Lookaside structure holds configuration information about the
8258 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
8266 ** Each database is an instance of the following structure.
8450 ** structure. A pointer to this structure is stored in the sqlite.aFunc
8538 ** instance of the following structure, stored in the sqlite3.aModule
8550 ** of this structure.
8568 ** structure. Conceptually, a collating sequence consists of a name and
8651 ** structure for each database connection (sqlite3*) that uses the shared
8677 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
8692 int nRef; /* Number of pointers to this structure */
8698 ** following structure.
8782 ** Each foreign key constraint is an instance of the following structure.
8796 ** Each REFERENCES clause generates an instance of the following structure
8858 ** An instance of the following structure is passed as the first
8871 ** An instance of the following structure holds information about a
8881 ** This structure holds a record that has already been disassembled
8904 ** instance of the following structure.
8907 ** by the aiColumn[] field of this structure. For example, suppose
8913 ** In the Table structure describing Ex1, nCol==3 because there are
8914 ** three columns in the table. In the Index structure describing
8947 ** using a structure of this type.
8960 ** this structure. Tokens are also used as part of an expression.
8972 ** An instance of this structure contains information needed to generate
8976 ** pointer to this structure. The Expr.iColumn field is the index in
8981 ** original Select structure that describes the SELECT statement. These
8982 ** fields do not need to be freed when deallocating the AggInfo structure.
9033 ** of this structure.
9165 ** flag on an expression structure. This flag is used for VV&A only. The
9223 ** An instance of this structure is used by the parser to record both
9234 ** An instance of this structure can hold a simple list of identifiers,
9272 ** The following structure describes the FROM clause of a SELECT statement.
9276 ** With the addition of multiple database support, the following structure
9304 Index *pIndex; /* Index structure corresponding to zIndex, if any */
9346 ** structure contains a single instance of this structure. This structure
9381 ** virtual table in the FROM clause and the WhereLevel structure is
9406 ** this structure is returned by the first half and passed
9459 ** An instance of the following structure contains all information
9529 ** A structure used to customize the behavior of sqlite3Select(). See
9565 ** At least one instance of the following structure is created for each
9591 ** An SQL parser context. A copy of this structure is passed through
9595 ** The structure is divided into two parts. When the parser and code
9596 ** generate call themselves recursively, the first part of the structure
9607 sqlite3 *db; /* The main database structure */
9654 Parse *pToplevel; /* Parse structure for main program (or NULL) */
9698 ** An instance of the following structure can be declared on a stack and used
9703 Parse *pParse; /* The Parse structure */
9807 ** The following structure contains information used by the sqliteFix...
9836 ** A pointer to this structure is used to communicate information
9849 ** This structure also contains some state information.
10991 ** A structure for holding a single date and time.
11197 ** Write the result into the DateTime structure and return 0
11631 ** the resulting time into the DateTime structure p. Return 0
12343 ** sqlite3_mem_methods structure fails to allocate a block of memory
12368 ** structure. If writable static data is unsupported on the target,
12698 ** into a single structure named "mem". This is to keep the
13187 ** into a single structure named "mem3". This is to keep the
13649 /* Store a pointer to the memory block in global structure mem3. */
13840 ** A minimum allocation is an instance of the following structure.
13868 ** into a single structure named "mem5". This is to keep the
14397 ** the default implementation into the sqlite3GlobalConfig structure.
14725 ** Each recursive mutex is an instance of the following structure.
14998 ** Each recursive mutex is an instance of the following structure.
15321 ** Each recursive mutex is an instance of the following structure.
16219 ** ThreadData structure.
16365 #define etTOKEN 12 /* a pointer to a Token structure */
16381 ** by an instance of the following structure
16544 const et_info *infop; /* Pointer to the appropriate info structure */
17288 ** This structure is the current state of the generator.
17475 ** of the following structure.
17492 ** instance of the following structure.
17500 BtCursor *pCursor; /* The cursor structure of the backend */
17542 ** When a sub-program is executed (OP_Program), a structure of this type
17546 ** these values are copied back to the Vdbe from the VdbeFrame structure,
17582 ** integer etc.) of the same value. A value (and therefore Mem structure)
17678 ** instance of this structure is the first argument to the routines used
17681 ** There is a typedef for this structure in sqlite.h. So all routines,
17682 ** even the public interface to SQLite, can use a pointer to this structure.
17684 ** structure are known.
17686 ** This structure is defined inside of vdbeInt.h because it uses substructures
17699 ** A Set structure is used for quick testing to see if a value
17711 ** An instance of the virtual machine. This structure contains the complete
17714 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_compile()
17715 ** is really a pointer to an instance of this structure.
19409 ** to modify the db structure at all. It could be that db is a stale
19502 ** fields of the Hash structure.
20197 ** The os2File structure is subclass of sqlite3_file specific for the OS/2
21436 ** structure are used to store the file descriptor while waiting for an
21447 ** The unixFile structure is subclass of sqlite3_file specific to the unix
21485 /* In test mode, increase the size of this structure a bit so that
21939 ** A pointer to an instance of the following structure can be used as a
21940 ** unique file ID in VxWorks. Each instance of this structure contains
21942 ** The structure is reclaimed when the number of pointers to it drops to
22100 ** st_dev and st_ino fields of the stat structure that fstat() fills in)
22110 ** The sqlite3_file structure for POSIX is no longer just an integer file
22111 ** descriptor. It is now a structure that holds the integer file
22112 ** descriptor and a pointer to a structure that describes the internal
22113 ** locks on the corresponding inode. There is one locking structure
22115 ** point to the same locking structure. The locking structure keeps
22122 ** structure. The fcntl() system call is only invoked to set a
22123 ** POSIX lock if the internal lock structure transitions between
22130 ** released. To work around this problem, each unixFile structure contains
22131 ** a pointer to an unixOpenCnt structure. There is one unixOpenCnt structure
22136 ** The unixOpenCnt structure keeps a list of file descriptors that need to
22157 ** structure to record this information. And on those systems it
22188 ** An instance of the following structure serves as the key used
22189 ** to locate a particular unixOpenCnt structure given its inode. This
22202 ** An instance of the following structure serves as the key used
22203 ** to locate a particular unixLockInfo structure given its inode.
22219 ** An instance of the following structure is allocated for each open
22224 ** structure contains a pointer to an instance of this object and this
22231 int nRef; /* Number of pointers to this structure */
22237 ** An instance of the following structure is allocated for each open
22238 ** inode. This structure keeps track of the number of locks on that
22250 int nRef; /* Number of pointers to this structure */
22299 ** This structure holds information passed into individual test
22362 ** Release a unixLockInfo structure previously allocated by findLockInfo().
22389 ** Release a unixOpenCnt structure previously allocated by findLockInfo().
22438 struct unixLockInfo **ppLock, /* Return the unixLockInfo structure here */
22439 struct unixOpenCnt **ppOpen /* Return the unixOpenCnt structure here */
22443 struct unixLockKey lockKey; /* Lookup key for the unixLockInfo structure */
23133 ** structure to 0.
23539 ** lock states in the sqlite3_file structure, but all locks SHARED or
23724 ** lock states in the sqlite3_file structure, but all locks SHARED or
23836 ** The afpLockingContext structure contains all afp lock specific state
24455 /* The following "ifdef/elif/else/" block has the same structure as
24995 ** Initialize the contents of the unixFile structure pointed to by pId.
25001 sqlite3_file *pId, /* Write to the unixFile structure here */
26527 ** the unix structure properly cleaned up at close time:
27200 ** The winFile structure is a subclass of sqlite3_file* specific to the win32
28918 /* FILETIME structure is a 64-bit value representing the number of
29072 /* Size of the Bitvec structure in bytes. */
29106 ** A bitmap is an instance of the following structure.
29434 /* Free allocated structure */
29460 ** A complete page cache is an instance of this structure.
30073 ** structure. A buffer of PgHdr1.pCache->szPage bytes is allocated
30074 ** directly before this structure in memory (see the PGHDR1_TO_PAGE()
30112 ** All code in this file should access the global structure above via the
30119 ** When a PgHdr1 structure is allocated, the associated PCache1.szPage
30122 ** PGHDR1_TO_PAGE() macro takes a pointer to a PgHdr1 structure as
30126 ** a pointer to the associated PgHdr1 structure.
30351 ** (PCache1.apHash structure) that it is currently stored in.
30888 ** following structure) to reduce memory allocation overhead. The
30898 ** A RowSet in an instance of the following structure.
30900 ** A typedef of this structure if found in sqliteInt.h.
31347 ** An instance of the following structure is allocated for each active
31369 ** A open page cache is an instance of the following structure.
31478 ** modified during normal operations. The other variables in this structure
32330 ** the cache and reset the Pager structure internal state. If there is
32381 ** structure, the second the error-code about to be returned by a pager
33290 ** corresponding bit is set in a bitvec structure (variable pDone in the
34324 Pager **ppPager, /* OUT: Return the Pager structure here */
34399 /* Allocate memory for the Pager structure, PCache object, the
34412 ROUND8(sizeof(*pPager)) + /* Pager structure */
34508 ** Pager structure and close the file.
35193 ** Pager.pInJournal bitvec structure is allocated.
36244 ** Return the VFS structure for the pager.
36842 ** structure is appended and initialized to zero. This structure stores
36850 ** Access to all fields of this structure is controlled by the mutex
36905 ** this object for every database file that it has open. This structure
36907 ** see the internals of this structure and only deals with pointers to
36908 ** this structure.
36917 ** All fields in this structure are accessed under sqlite3.mutex.
36942 ** of the Btree structure. At most one of these may open a write transaction,
36959 ** Fields in this structure are accessed under the BtShared.mutex
37008 int nRef; /* Number of references to this structure */
37019 ** An instance of the following structure is used to hold information
37020 ** about a cell. The parseCellPtr() function fills in this structure
37036 ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
37057 ** Fields in this structure are accessed under the BtShared.mutex
37198 ** This structure is passed around through all the sanity checking routines
37640 ** of each BtShared structure and so this locking is not necessary.
37668 ** as this module treats each table as a separate structure. To determine
38000 ** on the shared btree structure pBt.
38431 ** Parse a cell content block and fill in the CellInfo structure. There
38442 CellInfo *pInfo /* Fill in this structure */
38515 CellInfo *pInfo /* Fill in this structure */
38885 ** and initialize fields of the MemPage structure accordingly.
38941 BtShared *pBt; /* The main btree structure */
39250 BtShared *pBt = 0; /* Shared part of btree structure */
39476 ** remove the BtShared structure from the sharing list. Return
39551 /* Rollback any active transaction and free the handle structure.
39559 ** structure, return now. The remainder of this procedure cleans
40010 ** on this shared-btree structure and a second write transaction is
41002 ** BtCursor.info structure. If it is not already valid, call
41592 ** Move the cursor to point to the root page of its b-tree structure.
41599 ** If the b-tree structure is empty, the cursor state is set to
41607 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
41609 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
42491 /* Now manipulate the actual database free-list structure. There are two
43167 /* Reinitialize page pTo so that the contents of the MemPage structure
43687 ** b-tree structure by one. This is described as the "balance-shallower"
43830 ** This function is called when the root page of a b-tree structure is
44163 ** fails. Internal data structure corruption will result otherwise.
44721 ** page in the B-Tree structure (not including overflow pages).
45469 ** structure may be accessed via two groups of thread-safe entry points:
45474 ** structure, in that order.
45479 ** associated with the source database BtShared structure will always
45589 ** to do here is free the sqlite3_backup structure.
45923 /* Exit the mutexes and free the backup context structure. */
46060 ** This file contains code use to manipulate "Mem" structure. A "Mem"
46061 ** stores a single value in the VDBE. Mem is an opaque structure visible
46453 ** The MEM structure is already a MEM_Real. Try to also make it a
46698 ** Mem structure. Otherwise, any existing buffer is freed and the
46907 ** Move data out of a btree key or data field and into a Mem structure.
46913 ** The pMem structure is assumed to be uninitialized. Any prior content
46924 Mem *pMem /* OUT: Return data in this Mem structure. */
47707 ** If the input FuncDef structure is ephemeral, then free it. If
47778 ** Decrement the ref-count on the SubProgram structure passed as the
47779 ** second argument. If the ref-count reaches zero, free the structure.
47785 ** or indirectly contain a reference to the SubProgram structure itself.
47834 ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
47835 ** A copy is made of the KeyInfo structure into memory obtained from
47837 ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
47843 ** to a string or structure that is guaranteed to exist for the lifetime of
48633 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
49097 ** this routine obtains the mutex associated with each BtShared structure
49368 ** and error message from the VDBE into the main database structure. But
49843 ** record into a UnpackedRecord structure. Return a pointer to
49844 ** that structure.
49848 ** VDbeParsedRecord structure if it is large enough. If it is
49851 ** The returned structure should be closed by a call to
50222 ** Return a pointer to an sqlite3_value structure containing the value bound
50369 ** structure.
50696 ** Extract the user data from a sqlite3_context structure and return a
50705 ** Extract the user data from a sqlite3_context structure and return a
50876 ** value SQL NULL. Even though the Mem structure contains an element
50881 ** that a Mem structure is located on an 8-byte boundary. To prevent
51692 ** field of the sqlite3 structure is set in order to simulate and interrupt.
51814 ** required for this VdbeCursor structure. It is convenient to use a
51816 ** VdbeCursor structure for the following reasons:
53209 ** structure to provide access to the top P1 values as the result
53460 ** Invoke a user function (P4 is a pointer to a Function structure that
53947 ** P4 is a KeyInfo structure that defines collating sequences and sort
54166 ** Interpret the data that cursor P1 points to as a structure built using
54443 ** dynamically allocated space over to the u.am.pDest structure.
54688 /* Create a new savepoint structure. */
55055 ** v-table would have to be ready for the sqlite3_vtab structure itself
55092 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
55093 ** structure, then said structure defines the content and collating
55106 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
55107 ** structure, then said structure defines the content and collating
55210 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
57294 ** structure that specifies the function. Use register
57469 ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
57520 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
57758 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
57787 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
58630 ** If the argument p points to a JournalFile structure, and the underlying
59134 ** prevents ExprDelete() from deleting the Expr structure itself,
59153 ** pExpr->pTab Points to the Table structure of X.Y (even if
60518 ** of any expression tree referenced by the structure passed as the
60554 ** Set the Expr.nHeight variable in the structure passed as an
60868 ** Return the number of bytes allocated for the expression structure
60883 ** dupedExprStructSize() Size of only the Expr structure
60890 ** (1) the space required for a copy of the Expr structure only and
60891 ** (2) the EP_xxx flags that indicate what the structure size should be.
60898 ** The size of the structure can be found by masking the return value
60933 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
60985 /* Figure out where to write the new Expr structure. */
60995 /* Set nNewSize to the size allocated for the structure pointed to
61073 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
61074 ** truncated version of the usual Expr structure that will be stored as
61611 ** It's job is to find or create a b-tree structure that may be used
61641 ** needs to know whether or not the structure contains an SQL NULL
61656 ** has_null = <test if data structure contains null>
61660 ** in order to avoid running the <test if data structure contains null>
63835 ** function that is already in the pAggInfo structure
64570 ** The Table structure pParse->pNewTable was extended to include
64684 ** This routine makes a (partial) copy of the Table structure
64688 ** the copy. The copy of the Table structure is deleted by tokenize.c
65821 ** Initialize a DbFixer structure. This routine must be called prior
65822 ** to passing the structure to one of the sqliteFixAAAA() routines below.
65849 ** was left unspecified in the original SQL statement. The pFix structure
66243 ** be parsed. Initialize the pParse structure as needed.
66252 ** The TableLock structure is only used by the sqlite3TableLock() and
66334 ** VDBE program and resets the pParse structure for the next
66469 ** Locate the in-memory structure that describes a particular database
66496 ** Locate the in-memory structure that describes a particular database
66533 ** Locate the in-memory structure that describes
66712 ** This routine just deletes the data structure. It does not unlink
66713 ** the table data structure from the hash table. But it does destroy
66743 /* Delete the Table structure itself.
66758 ** table structure with all its indices and foreign keys.
67044 ** then record a pointer to this table in the main database structure
67639 ** The table structure that other action routines have been building
67937 ** The Table structure pTable is really a VIEW. Fill in the names of
67938 ** the columns of the view in the pTable structure. Return the number
68352 ** An FKey structure is created and added to the table currently
68580 ** structure. This is used by sqlite3AddPrimaryKey() to mark the index
68773 ** Allocate the index structure.
68778 sizeof(Index) + /* Index structure */
68811 ** load the column indices into the Index structure. Report an error
68924 /* Link the new Index structure to its table and to the other
69613 ** the number of errors. Leave any error messages in the pParse structure.
69884 ** Return a dynamicly allocated KeyInfo structure that can be used
69887 ** If successful, a pointer to the new structure is returned. In this case
70067 ** each collation sequence structure.
70228 ** pointer to the FuncDef structure that defines that function, or return
70232 ** structure is created and liked into the "db" structure if a
70277 ** install a new function. Whatever FuncDef structure is returned will
70316 ** Free all resources held by the schema structure. The void* argument points
70599 sqlite3 *db; /* Main database structure */
70619 ** put in an SrcList structure because some of the subroutines we
71482 ** A structure defining how to do GLOB-style comparisons.
71667 ** This same function (with a different compareInfo structure) computes
72147 ** An instance of the following structure holds the context of a
72223 ** The following structure keeps track of state information for the
72430 ** the first three statements in the compareInfo structure. The
72656 ** sqlite3FkDelete() - Delete an FKey structure.
73110 ** to the FKey structure representing the foreign key constraint on table
73121 ** The second argument is a Trigger structure allocated by the
73122 ** fkActionTrigger() routine. This function deletes the Trigger structure
73125 ** The Trigger structure or any of its sub-components may be allocated from
73329 /* Create a SrcList structure containing a single table (the table
73454 ** It returns a pointer to a Trigger structure containing a trigger
73466 ** then the returned trigger structure is equivalent to:
73782 ** is managed along with the rest of the Index structure. It will be
73789 ** a member of the Index structure for subsequent use.
73792 ** sqliteDeleteIndex() when the Index structure itself is cleaned
73830 ** stored as a member of the Table structure for subsequent use.
73833 ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
73900 ** Locate or create an AutoincInfo structure associated with table pTab
73904 ** There is at most one AutoincInfo structure per table even if the
73906 ** triggers. A new AutoincInfo structure is created if this is the
73908 ** AutoincInfo structure is used.
74167 sqlite3 *db; /* The main database structure */
75736 ** The following structure holds pointers to all of the SQLite API
75740 ** interfaces to the end of this structure only. If you insert new
75741 ** interfaces in the middle of this structure, then older different
75909 ** redirected throught the global sqlite3_api structure.
75913 ** it can get access to the sqlite3_api_routines structure
76179 ** The following structure contains pointers to all SQLite API routines.
76180 ** A pointer to this structure is passed into extensions when they are
76184 ** When adding new APIs, add them to the bottom of this structure
78138 ** Fill the InitData structure with an error message that indicates
78264 ** The master database table has a structure like this
78501 ** bit is set in the flags field of the Db structure. If the database
79011 ** Delete all the content of a Select structure but do not deallocate
79012 ** the select structure itself.
79027 ** Initialize a SelectDest structure.
79039 ** Allocate a new Select structure and return a pointer to that
79040 ** structure.
79089 ** Delete the given Select structure and all of its substructures.
79113 ** a join type, but put an error in the pParse structure.
79303 ** The terms of a FROM clause are contained in the Select.pSrc structure.
79727 ** Given an expression list, generate a KeyInfo structure that records
79731 ** KeyInfo structure is appropriate for initializing a virtual index to
79733 ** then the KeyInfo structure is appropriate for initializing a virtual
79736 ** Space to hold the KeyInfo structure is obtain from malloc. The calling
79737 ** function is responsible for seeing that this structure is eventually
79738 ** freed. Add the KeyInfo structure to the P4 field of an opcode using
79909 Table *pTab = 0; /* Table structure column is extracted from */
80273 ** Given a SELECT statement, generate a Table structure that describes
80725 ** Attach the KeyInfo structure to all temporary tables.
81760 /* Delete the transient table structure associated with the
82071 ** then create a transient table structure to describe the subquery.
82307 ** information to the Table structure that represents the result set
82310 ** The Table structure that represents the result set was constructed
82424 ** in the AggInfo structure.
82503 ** contents of the SelectDest structure pointed to by argument pDest
82550 ** This routine does NOT free the Select structure passed in. The
83030 /* If isSimpleCount() returns a pointer to a Table structure, then
83035 ** where the Table structure returned represents table <tbl>.
83058 ** and pKeyInfo to the KeyInfo structure required to navigate the
83061 ** In practice the KeyInfo structure will not be used. It is only
83275 /* End of the structure debug printing code
83303 ** This structure is used to pass data from sqlite3_get_table() through
83318 ** is to fill in the TabResult structure appropriately, allocating new
83550 ** structure is generated based on the information available and stored
83804 ** a trigger step. Return a pointer to a TriggerStep structure.
83927 ** Recursively delete a Trigger structure
83983 ** Return a pointer to the Table structure for the table that a trigger
84241 ** Parse context structure pFrom has just been used to create a sub-vdbe
84671 sqlite3 *db; /* The database structure */
85647 ** pTab is a pointer to a Table structure representing a virtual-table.
85771 ** Since it is a virtual-table, the Table structure contains a pointer
85773 ** structure is associated with a single sqlite3* user of the schema.
85774 ** The reference count of the VTable structure associated with database
85776 ** structure being xDisconnected and free). Any other VTable structures
86043 /* If everything went according to plan, link the new VTable structure
86288 ** the offset of the method to call in the sqlite3_module structure.
86419 ** new FuncDef structure that is marked as ephemeral using the
86551 ** The query generator uses an array of instances of this structure to
86556 ** All WhereTerms are collected into a single WhereClause structure.
86586 ** but they do so indirectly. A single WhereMaskSet structure translates
86631 ** An instance of the following structure holds all information about a
86651 ** a dynamically allocated instance of the following structure.
86660 ** a dynamically allocated instance of the following structure.
86667 ** An instance of the following structure keeps track of a mapping
86674 ** use of the bits in our bitmasks. This structure provides a mapping
86682 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
86758 ** Initialize a preallocated WhereClause structure.
86793 ** Deallocate a WhereClause structure. The WhereClause structure
86865 ** operator specified in the op parameter. The WhereClause structure
87367 ** stored in a WhereClause structure containing within the WhereOrInfo
87581 ** The input to this routine is an WhereTerm structure with only the
87584 ** structure.
87893 /* Argument pIdx must either point to a 'real' named index structure,
87894 ** or an index structure allocated on the stack by bestBtreeIndex() to
88015 ** structure. Used for testing and debugging only. If neither
88148 ** Allocate and populate an sqlite3_index_info structure. It is the
88149 ** responsibility of the caller to eventually release the structure
88182 ** the sqlite3_index_info structure.
88195 /* Allocate the sqlite3_index_info structure
88206 /* Initialize the structure. The sqlite3_index_info structure contains
88259 ** part of the sqlite3_index_info structure is left populated.
88305 ** the sqlite3_index_info structure that is used to communicate with
88309 ** same virtual table. The sqlite3_index_info structure is created
88311 ** invocations. The sqlite3_index_info structure is also used when
88313 ** routine takes care of freeing the sqlite3_index_info structure after
88340 /* If the sqlite3_index_info structure has not been previously
88351 /* At this point, the sqlite3_index_info structure that pIdxInfo points
88359 ** be a pointer to an sqlite3_vtab structure. Otherwise
88445 ** Argument pIdx is a pointer to an index structure that has an array of
88540 ** an sqlite3_value structure containing the same value, with affinity
88542 ** caller to eventually release this structure by passing it to
88547 ** create an sqlite3_value structure containing this value, again with
88991 ** index and its cost in the pCost structure.
89956 ** Free a WhereInfo structure
89979 ** The return value is a pointer to an opaque structure that contains
90101 /* Allocate and initialize the WhereInfo structure that will become the
90103 ** struct, the contents of WhereInfo.a[], the WhereClause structure
90104 ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
90489 /* Record the continuation address in the WhereInfo structure. Then
90650 ** An instance of this structure holds information about the
90659 ** An instance of this structure is used to store the LIKE,
90668 ** An instance of the following structure describes the event of a
90679 ** An instance of this structure holds the ATTACH key and the key type.
91455 /* The following structure represents a single element of the
91477 ** the following structure */
93867 ** The first argument is a pointer to a structure obtained from
93876 ** <li> A pointer to the parser (an opaque structure.)
94691 ** Run the parser on the given SQL string. The parser structure is
94812 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
94813 ** will take responsibility for freeing the Table structure.
95905 ** structure?
96784 /* Allocate the sqlite data structure */
98127 ** Since we're using a segmented structure, with no docid-oriented
98183 ** interface functions. This is essentially the class structure for
98210 ** sqlite3_tokenizer structure representing the specific tokenizer to
98243 ** to point at the newly created tokenizer structure. The generic
98352 /* A complete hash table is an instance of the following structure.
98353 ** The internals of this structure are intended to be opaque -- client
98354 ** code should not attempt to access or modify the fields of this structure
98355 ** directly. Change this structure only by using the routines below.
98357 ** accessing this structure are really macros, so we can't really make
98358 ** this structure opaque.
98373 ** structure. All elements are stored on a single doubly-linked list.
98375 ** Again, this structure is intended to be opaque, but it can't really
98509 ** structure. The xCreate and xConnect methods create an instance
98510 ** of this structure and xDestroy and xDisconnect free that instance.
98511 ** All other methods receive a pointer to the structure as one of their
98556 ** virtual table cursor (an instance of the following structure) using
98900 ** memory associated with the Fts3Table structure and return SQLITE_OK.
99005 sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
99048 /* Allocate and populate the Fts3Table structure. */
99072 /* Fill in the zName and zDb fields of the vtab structure. */
99216 /* Allocate a buffer large enough for an Fts3Cursor structure. If the
99898 ** A pointer to an instance of this structure is used as the context
99915 void *pContext, /* Pointer to TermSelect structure */
100004 ** b-tree structure to determine which leaves need to be inspected.
101017 ** structure of type FTSQUERY_PHRASE containing a phrase consisting of this
101021 ** Fts3Expr structure (if any) by passing it to sqlite3_free().
101100 ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE
101104 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
101205 ** structure, or set to 0 if the end of the input buffer is reached.
101365 ** The argument is an Fts3Expr structure for a binary operator (any type
101438 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
101606 Fts3Expr **ppExpr /* OUT: Parsed query structure */
101875 ** fields of the Hash structure.
103601 ** Data structure used while accumulating terms in the pending-terms hash
103603 ** instance of this structure.
103615 ** An instance of this structure is used to iterate through the terms on
103617 ** this structure are only manipulated by code in this file, opaque handles
103659 ** An instance of this structure is used to create a segment b-tree in the
103668 SegmentNode *pTree; /* Pointer to interior tree structure */
103899 ** This function also serves to allocate the PendingList structure itself.
103900 ** For example, to create a new PendingList structure containing two
103943 ** Add a docid/column/position entry to a PendingList structure. Non-zero
103944 ** is returned if the structure is sqlite3_realloced as part of adding
103952 PendingList **pp, /* IN/OUT: PendingList structure */
104642 ** This function allocates and initializes a Fts3SegReader structure to
105084 /* Allocate the SegmentWriter structure */
105455 ** The 4th argument to this function is a pointer to a structure of type
105456 ** Fts3SegFilter, defined in fts3Int.h. The contents of this structure
105458 ** modify the behaviour of this function. See comments above structure
105679 /* Allocate a Fts3SegReader structure for each segment being merged. A
105923 ** An instance of the following structure keeps track of generated
106020 ** Release all memory associated with the Snippet structure passed as
106211 ** Remove entries from the pSnippet structure to account for the NEAR
106596 Snippet *p; /* Snippet structure */
106618 Snippet *p; /* Snippet structure */
107042 ** An instance of this structure is used to collect the 'global' part of
107111 void *pCtx /* Pointer to MatchInfo structure */
107134 void *pCtx /* Pointer to MatchInfo structure */
107267 ** same data-structure is used for all, but the algorithms for insert and
107340 int iDepth; /* Current depth of the r-tree structure */
107344 int nBusy; /* Current number of users of this structure */
107409 ** to the Rtree structure associated with the RtreeCoord.
107434 ** An rtree structure node.
107630 Rtree *pRtree, /* R-tree structure */
107827 ** Deserialize cell iCell of node pNode. Populate the structure pointed
107886 ** zero the structure is deleted.
109363 ** cell, adjust the r-tree data structure if required.
109684 ** the r-tree structure.
109933 /* Allocate the sqlite3_vtab structure */
110006 ** For a two-dimensional r-tree structure called "rt", to deserialize
110471 ** a UCollator structure previously allocated using ucol_open().
110480 ** a UCollator structure previously allocated using ucol_open().