Lines Matching refs:STRUCTURE
563 ** presents to client programs. If a C-function, structure, datatype,
769 ** the opaque structure named "sqlite3". It is useful to think of an sqlite3
1182 ** point to a structure that may contain arguments or space in which to
1426 ** object when the iVersion value is increased. Note that the structure
1432 ** structure used by this VFS. mxPathname is the maximum length of
1443 ** structure that SQLite will ever modify. SQLite will only access
1520 ** to hold the [sqlite3_file] structure passed as the third
1522 ** allocate the structure; it should just fill it in. Note that
1545 ** included in the VFS structure for completeness.
1576 int iVersion; /* Structure version number (currently 3) */
1938 ** instance of the [sqlite3_mem_methods] structure. The argument specifies
1941 ** its own private copy of the content of the [sqlite3_mem_methods] structure
1946 ** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods]
1947 ** structure is filled with the currently defined memory allocation routines.)^
2024 ** instance of the [sqlite3_mutex_methods] structure. The argument specifies
2027 ** content of the [sqlite3_mutex_methods] structure before the call to
2036 ** instance of the [sqlite3_mutex_methods] structure. The
2038 ** structure is filled with the currently defined mutex routines.)^
2493 ** Definition: A <b>result table</b> is memory data structure created by the
5486 ** This structure, sometimes called a "virtual table module",
5488 ** This structure consists mostly of methods for the module.
5491 ** instance of this structure and passing a pointer to that instance
5495 ** of this structure must not change while it is registered with
5537 ** The sqlite3_index_info structure and its substructures is used as part
5696 ** following structure to describe cursors that point into the
5703 ** the content of a cursor structure to suit its own needs.
6116 ** An instance of this structure defines the low-level routines
6123 ** creates and populates an instance of this structure to pass
6125 ** Additionally, an instance of this structure can be used as an
6129 ** ^The xMutexInit method defined by this structure is invoked as
6134 ** ^The xMutexEnd method defined by this structure is invoked as
6141 ** ^(The remaining seven methods defined by this structure (xMutexAlloc,
6158 ** by this structure are not required to handle this case, the results
6635 ** its size or internal structure and never deals with the
6665 ** instance of the sqlite3_pcache_methods2 structure.)^
6679 ** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
7532 ** A pointer to a structure of the following type is passed as the first
7576 /* A complete hash table is an instance of the following structure.
7577 ** The internals of this structure are intended to be opaque -- client
7578 ** code should not attempt to access or modify the fields of this structure
7579 ** directly. Change this structure only by using the routines below.
7581 ** accessing this structure are really macros, so we can't really make
7582 ** this structure opaque.
7608 ** structure. All elements are stored on a single doubly-linked list.
7610 ** Again, this structure is intended to be opaque, but it can't really
7885 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
8027 ** An instance of the following structure is used to store the busy-handler
8211 ** Forward declarations of structure
8317 BtCursor *pCursor /* Space to write cursor structure */
8442 ** A single VDBE is an opaque structure named "Vdbe". Only routines
8444 ** of this structure.
8459 ** as an instance of the following structure:
8527 #define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */
8528 #define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */
8529 #define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */
8530 #define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */
8531 #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
8533 #define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */
8539 #define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */
8542 /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
8573 ** of a VdbeOp structure into a negative number so that
8884 ** Each open file is managed by a separate instance of the "Pager" structure.
9062 ** structure.
9500 ** sqlite3_malloc() to obtain space for the file-handle structure.
9592 ** of the following structure. There are normally two of these structures
9599 Btree *pBt; /* The B*Tree structure for this database file */
9606 ** An instance of the following structure stores a database schema.
9673 ** The Lookaside structure holds configuration information about the
9703 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
9711 ** Each database connection is an instance of the following structure.
9885 ** structure. A pointer to this structure is stored in the sqlite.aFunc
9904 ** This structure encapsulates a user-function destructor callback (as
9915 ** is invoked and the FuncDestructor structure freed.
9993 ** instance of the following structure, stored in the sqlite3.aModule
10005 ** of this structure.
10023 ** structure. Conceptually, a collating sequence consists of a name and
10097 ** structure for each database connection (sqlite3*) that uses the shared
10123 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
10138 int nRef; /* Number of pointers to this structure */
10146 ** following structure.
10228 ** Each foreign key constraint is an instance of the following structure.
10242 ** Each REFERENCES clause generates an instance of the following structure
10304 ** An instance of the following structure is passed as the first
10317 ** An instance of the following structure holds information about a
10327 ** This structure holds a record that has already been disassembled
10347 ** instance of the following structure.
10350 ** by the aiColumn[] field of this structure. For example, suppose
10356 ** In the Table structure describing Ex1, nCol==3 because there are
10357 ** three columns in the table. In the Index structure describing
10395 ** using a structure of this type. See documentation at the top of the
10413 ** this structure. Tokens are also used as part of an expression.
10425 ** An instance of this structure contains information needed to generate
10429 ** pointer to this structure. The Expr.iColumn field is the index in
10434 ** original Select structure that describes the SELECT statement. These
10435 ** fields do not need to be freed when deallocating the AggInfo structure.
10485 ** of this structure.
10617 ** flag on an expression structure. This flag is used for VV&A only. The
10674 ** An instance of this structure is used by the parser to record both
10685 ** An instance of this structure can hold a simple list of identifiers,
10722 ** The following structure describes the FROM clause of a SELECT statement.
10726 structure
10762 Index *pIndex; /* Index structure corresponding to zIndex, if any */
10805 ** structure contains a single instance of this structure. This structure
10840 ** virtual table in the FROM clause and the WhereLevel structure is
10865 ** this structure is returned by the first half and passed
10924 ** An instance of the following structure contains all information
10997 ** A structure used to customize the behavior of sqlite3Select(). See
11033 ** At least one instance of the following structure is created for each
11068 ** An SQL parser context. A copy of this structure is passed through
11072 ** The structure is divided into two parts. When the parser and code
11073 ** generate call themselves recursively, the first part of the structure
11084 sqlite3 *db; /* The main database structure */
11130 Parse *pToplevel; /* Parse structure for main program (or NULL) */
11182 ** An instance of the following structure can be declared on a stack and used
11187 Parse *pParse; /* The Parse structure */
11291 ** The following structure contains information used by the sqliteFix...
11320 ** A pointer to this structure is used to communicate information
11331 ** Structure containing global configuration data for the SQLite library.
11333 ** This structure also contains some state information.
12851 ** of the following structure.
12874 ** instance of the following structure.
12877 BtCursor *pCursor; /* The cursor structure of the backend */
12922 ** When a sub-program is executed (OP_Program), a structure of this type
12926 ** these values are copied back to the Vdbe from the VdbeFrame structure,
13070 ** instance of this structure is the first argument to the routines used
13073 ** There is a typedef for this structure in sqlite.h. So all routines,
13074 ** even the public interface to SQLite, can use a pointer to this structure.
13076 ** structure are known.
13078 ** This structure is defined inside of vdbeInt.h because it uses substructures
13104 ** An instance of the virtual machine. This structure contains the complete
13107 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
13108 ** is really a pointer to an instance of this structure.
13593 ** A structure for holding a single date and time.
13793 ** Write the result into the DateTime structure and return 0
14281 ** the resulting time into the DateTime structure p. Return 0
15042 ** sqlite3_mem_methods structure fails to allocate a block of memory
15067 ** structure. If writable static data is unsupported on the target,
15535 ** into a single structure named "mem". This is to keep the
16083 ** into a single structure named "mem3". This is to keep the
16545 /* Store a pointer to the memory block in global structure mem3. */
16736 ** A minimum allocation is an instance of the following structure.
16764 ** into a single structure named "mem5". This is to keep the
17297 ** the default implementation into the sqlite3GlobalConfig structure.
17651 ** Each recursive mutex is an instance of the following structure.
17937 ** Each recursive mutex is an instance of the following structure.
18274 ** Each recursive mutex is an instance of the following structure.
19291 ** ThreadData structure.
19399 #define etTOKEN 12 /* a pointer to a Token structure */
19415 ** by an instance of the following structure
19552 const et_info *infop; /* Pointer to the appropriate info structure */
20359 ** This structure is the current state of the generator.
22251 ** fields of the Hash structure.
22940 typedef struct os2File os2File; /* The file structure */
22945 ** The os2File structure is subclass of sqlite3_file specific for the OS/2
23642 ** in this structure.
23663 ** Structure used internally by this VFS to record the state of an
24832 ** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
25001 ** structure are used to store the file descriptor while waiting for an
25011 ** The unixFile structure is subclass of sqlite3_file specific to the unix
25050 /* In test mode, increase the size of this structure a bit so that
25772 ** A pointer to an instance of the following structure can be used as a
25773 ** unique file ID in VxWorks. Each instance of this structure contains
25775 ** The structure is reclaimed when the number of pointers to it drops to
25933 ** st_dev and st_ino fields of the stat structure that fstat() fills in)
25943 ** The sqlite3_file structure for POSIX is no longer just an integer file
25944 ** descriptor. It is now a structure that holds the integer file
25945 ** descriptor and a pointer to a structure that describes the internal
25946 ** locks on the corresponding inode. There is one locking structure
25948 ** point to the same locking structure. The locking structure keeps
25955 ** structure. The fcntl() system call is only invoked to set a
25956 ** POSIX lock if the internal lock structure transitions between
25968 ** The unixInodeInfo structure keeps a list of file descriptors that need to
25994 ** An instance of the following structure serves as the key used
26007 ** An instance of the following structure is allocated for each open
26012 ** structure contains a pointer to an instance of this object and this
26020 int nRef; /* Number of pointers to this structure */
26146 ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
26803 ** structure to 0.
27211 ** lock states in the sqlite3_file structure, but all locks SHARED or
27387 ** lock states in the sqlite3_file structure, but all locks SHARED or
27498 ** The afpLockingContext structure contains all afp lock specific state
28255 /* The following "ifdef/elif/else/" block has the same structure as
28693 ** in this structure.
28714 ** Structure used internally by this VFS to record the state of an
28753 struct flock f; /* The posix advisory locking structure */
29610 ** Initialize the contents of the unixFile structure pointed to by pId.
29615 sqlite3_file *pId, /* Write to the unixFile structure here */
30260 ** and clear all the structure's references. Specifically,
31007 ** conch file structure and finally the original conch file descriptor is
31497 ** the unix structure properly cleaned up at close time:
32165 ** The winFile structure is a subclass of sqlite3_file* specific to the win32
32224 ** The winMemData structure stores information required by the Win32-specific
32230 u32 magic; /* Magic number to detect structure corruption. */
34397 ** in this structure.
34429 ** Structure used internally by this VFS to record the state of an
34597 ** use FILE_ID_BOTH_DIR_INFO Structure.
35676 /* FILETIME structure is a 64-bit value representing the number of
35851 /* Size of the Bitvec structure in bytes. */
35885 ** A bitmap is an instance of the following structure.
36213 /* Free allocated structure */
36239 ** A complete page cache is an instance of this structure.
36935 ** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of
36936 ** PgHdr1.pCache->szPage bytes is allocated directly before this structure
36984 ** All code in this file should access the global structure above via the
37300 ** (PCache1.apHash structure) that it is currently stored in.
37951 ** following structure) to reduce memory allocation overhead. The
37961 ** A RowSet in an instance of the following structure.
37963 ** A typedef of this structure if found in sqliteInt.h.
38858 ** An instance of the following structure is allocated for each active
40227 ** The first argument is a pointer to the pager structure, the second
41319 ** is actually a pointer to the Pager structure.
41605 ** corresponding bit is set in a bitvec structure (variable pDone in the
42729 Pager **ppPager, /* OUT: Return the Pager structure here */
42811 /* Allocate memory for the Pager structure, PCache object, the
42824 ROUND8(sizeof(*pPager)) + /* Pager structure */
42933 ** Pager structure and close the file.
43575 ** Pager.pInJournal bitvec structure is allocated.
44713 ** Return the VFS structure for the pager.
45458 ** data structure called the wal-index is maintained to expedite the
45791 ** This structure is used to implement an iterator that loops through
45797 ** The internals of this structure are only accessed by:
45890 ** Return a pointer to the WalCkptInfo structure in the wal-index.
45898 ** Return a pointer to the WalIndexHdr structure in the wal-index.
48698 ** structure is appended and initialized to zero. This structure stores
48706 ** Access to all fields of this structure is controlled by the mutex
48763 ** this object for every database file that it has open. This structure
48765 ** see the internals of this structure and only deals with pointers to
48766 ** this structure.
48775 ** All fields in this structure
48800 ** of the Btree structure. At most one of these may open a write transaction,
48817 ** Fields in this structure are accessed under the BtShared.mutex
48868 int nRef; /* Number of references to this structure */
48888 ** An instance of the following structure is used to hold information
48889 ** about a cell. The parseCellPtr() function fills in this structure
48905 ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
48926 ** Fields in this structure are accessed under the BtShared.mutex
49069 ** This structure is passed around through all the sanity checking routines
49316 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
49449 ** of each BtShared structure and so this locking is not necessary.
49477 ** as this module treats each table as a separate structure. To determine
49807 ** on the shared btree structure pBt.
50249 ** Parse a cell content block and fill in the CellInfo structure. There
50260 CellInfo *pInfo /* Fill in this structure */
50328 CellInfo *pInfo /* Fill in this structure */
50698 ** and initialize fields of the MemPage structure accordingly.
50755 BtShared *pBt; /* The main btree structure */
51071 BtShared *pBt = 0; /* Shared part of btree structure */
51329 ** remove the BtShared structure from the sharing list. Return
51404 /* Rollback any active transaction and free the handle structure.
51412 ** structure, return now. The remainder of this procedure cleans
51933 ** on this shared-btree structure and a second write transaction is
52970 ** BtCursor.info structure. If it is not already valid, call
53587 ** into more than one b-tree structure in a corrupt database. */
53604 ** Move the cursor to point to the root page of its b-tree structure.
53611 ** If the b-tree structure is empty, the cursor state is set to
53619 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
53621 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
54071 ** page into more than one b-tree structure. */
54517 /* Now manipulate the actual database free-list structure. There are two
55222 /* Reinitialize page pTo so that the contents of the MemPage structure
55767 ** b-tree structure by one. This is described as the "balance-shallower"
55911 ** This function is called when the root page of a b-tree structure is
56248 ** fails. Internal data structure corruption will result otherwise.
56826 ** page in the B-Tree structure (not including overflow pages).
57659 ** Structure allocated for each backup operation.
57687 ** structure may be accessed via two groups of thread-safe entry points:
57692 ** structure, in that order.
57697 ** associated with the source database BtShared structure will always
57821 ** sqlite3_backup structure.
58211 /* Exit the mutexes and free the backup context structure. */
58369 ** This file contains code use to manipulate "Mem" structure. A "Mem"
58370 ** stores a single value in the VDBE. Mem is an opaque structure visible
58749 ** The MEM structure is already a MEM_Real. Try to also make it a
59029 ** Mem structure. Otherwise, any existing buffer is freed and the
59238 ** Move data out of a btree key or data field and into a Mem structure.
59244 ** The pMem structure is assumed to be uninitialized. Any prior content
59255 Mem *pMem /* OUT: Return data in this Mem structure. */
60092 ** If the input FuncDef structure is ephemeral, then free it. If
60204 ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
60205 ** A copy is made of the KeyInfo structure into memory obtained from
60207 ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
60213 ** to a string or structure that is guaranteed to exist for the lifetime of
60490 ** this routine obtains the mutex associated with each BtShared structure
61108 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
61859 ** and error message from the VDBE into the main database structure. But
62352 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
62353 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
62397 ** UnpackedRecord structure indicated by the fourth argument with the
62404 UnpackedRecord *p /* Populate this structure before returning. */
62710 ** Return a pointer to an sqlite3_value structure containing the value bound
62885 ** structure.
63265 ** Extract the user data from a sqlite3_context structure and return a
63274 ** Extract the user data from a sqlite3_context structure and return a
63449 ** value SQL NULL. Even though the Mem structure contains an element
63454 ** that a Mem structure is located on an 8-byte boundary. To prevent
64221 ** The following code implements the data-structure explaining logic
64314 ** Free the indentation structure
64408 ** field of the sqlite3 structure is set in order to simulate an interrupt.
64531 ** required for this VdbeCursor structure. It is convenient to use a
64533 ** VdbeCursor structure for the following reasons:
65957 ** structure to provide access to the top P1 values as the result
66218 ** Invoke a user function (P4 is a pointer to a Function structure that
66747 ** P4 is a KeyInfo structure that defines collating sequences and sort
66985 ** Interpret the data that cursor P1 points to as a structure built using
67275 ** dynamically allocated space over to the u.an.pDest structure.
67532 /* Create a new savepoint structure. */
67918 ** v-table would have to be ready for the sqlite3_vtab structure itself
67955 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
67956 ** structure, then said structure defines the content and collating
67969 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
67970 ** structure, then said structure defines the content and collating
68071 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
70291 ** structure that specifies the function. Use register
70615 ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
70662 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70884 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70916 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
71670 ** NOTES ON DATA STRUCTURE USED FOR N-WAY MERGES:
71677 ** describes the data structure used to do so. The structure supports
71768 ** A structure to store a single record. All in-memory records are connected
71786 ** argument. All structure fields are set to zero before returning.
72748 ** If the argument p points to a JournalFile structure, and the underlying
73258 ** prevents ExprDelete() from deleting the Expr structure itself,
73295 ** pExpr->pTab Points to the Table structure of X.Y (even if
74672 ** of any expression tree referenced by the structure passed as the
74708 ** Set the Expr.nHeight variable in the structure passed as an
75030 ** Return the number of bytes allocated for the expression structure
75045 ** dupedExprStructSize() Size of only the Expr structure
75052 ** (1) the space required for a copy of the Expr structure only and
75053 ** (2) the EP_xxx flags that indicate what the structure size should be.
75060 ** The size of the structure can be found by masking the return value
75095 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
75147 /* Figure out where to write the new Expr structure. */
75157 /* Set nNewSize to the size allocated for the structure pointed to
75235 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
75236 ** truncated version of the usual Expr structure that will be stored as
75782 ** It's job is to find or create a b-tree structure that may be used
75812 ** needs to know whether or not the structure contains an SQL NULL
75827 ** has_null = <test if data structure contains null>
75831 ** in order to avoid running the <test if data structure contains null>
78280 ** function that is already in the pAggInfo structure
79051 ** The Table structure pParse->pNewTable was extended to include
79168 ** This routine makes a (partial) copy of the Table structure
79172 ** the copy. The copy of the Table structure is deleted by tokenize.c
79473 ** share an instance of the following structure to hold their state
80803 ** Initialize a DbFixer structure. This routine must be called prior
80804 ** to passing the structure to one of the sqliteFixAAAA() routines below.
80831 ** was left unspecified in the original SQL statement. The pFix structure
81225 ** be parsed. Initialize the pParse structure as needed.
81234 ** The TableLock structure is only used by the sqlite3TableLock() and
81316 ** VDBE program and resets the pParse structure for the next
81452 ** Locate the in-memory structure that describes a particular database
81482 ** Locate the in-memory structure that describes a particular database
81519 ** Locate the in-memory structure that describes
81697 ** This routine just deletes the data structure. It does not unlink
81698 ** the table data structure from the hash table. But it does destroy
81729 /* Delete the Table structure itself.
81746 ** table structure with all its indices and foreign keys.
82038 ** then record a pointer to this table in the main database structure
82635 ** The table structure that other action routines have been building
82932 ** The Table structure
82933 ** the columns of the view in the pTable structure. Return the number
83385 ** An FKey structure is created and added to the table currently
83655 ** structure. This is used by sqlite3AddPrimaryKey() to mark the index
83854 ** Allocate the index structure.
83859 ROUND8(sizeof(Index)) + /* Index structure */
83897 ** load the column indices into the Index structure. Report an error
84011 /* Link the new Index structure to its table and to the other
84685 ** the number of errors. Leave any error messages in the pParse structure.
84976 ** Return a dynamicly allocated KeyInfo structure that can be used
84979 ** If successful, a pointer to the new structure is returned. In this case
85159 ** each collation sequence structure.
85320 ** pointer to the FuncDef structure that defines that function, or return
85324 ** structure is created and liked into the "db" structure if a
85373 ** install a new function. Whatever FuncDef structure is returned it will
85413 ** Free all resources held by the schema structure. The void* argument points
85706 sqlite3 *db; /* Main database structure */
85726 ** put in an SrcList structure because some of the subroutines we
86622 ** A structure defining how to do GLOB-style comparisons.
86807 ** This same function (with a different compareInfo structure) computes
87352 ** An instance of the following structure holds the context of a
87423 ** The following structure keeps track of state information for the
87628 ** the first three statements in the compareInfo structure. The
87862 ** sqlite3FkDelete() - Delete an FKey structure.
88329 ** to the FKey structure representing the foreign key constraint on table
88340 ** The second argument is a Trigger structure allocated by the
88341 ** fkActionTrigger() routine. This function deletes the Trigger structure
88344 ** The Trigger structure or any of its sub-components may be allocated from
88563 /* Create a SrcList structure containing a single table (the table
88688 ** It returns a pointer to a Trigger structure containing a trigger
88700 ** then the returned trigger structure is equivalent to:
89016 ** is managed along with the rest of the Index structure. It will be
89023 ** a member of the Index structure for subsequent use.
89026 ** sqliteDeleteIndex() when the Index structure itself is cleaned
89064 ** stored as a member of the Table structure for subsequent use.
89067 ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
89134 ** Locate or create an AutoincInfo structure associated with table pTab
89138 ** There is at most one AutoincInfo structure per table even if the
89140 ** triggers. A new AutoincInfo structure is created if this is the
89142 ** AutoincInfo structure is used.
89404 sqlite3 *db; /* The main database structure */
90998 ** The following structure holds pointers to all of the SQLite API
91002 ** interfaces to the end of this structure only. If you insert new
91003 ** interfaces in the middle of this structure, then older different
91216 ** redirected throught the global sqlite3_api structure.
91220 ** it can get access to the sqlite3_api_routines structure
91519 ** The following structure contains pointers to all SQLite API routines.
91520 ** A pointer to this structure is passed into extensions when they are
91524 ** When adding new APIs, add them to the bottom of this structure
93656 ** Fill the InitData structure with an error message that indicates
93785 ** The master database table has a structure like this
94021 ** bit is set in the flags field of the Db structure. If the database
94520 ** Delete all the content of a Select structure but do not deallocate
94521 ** the select structure itself.
94536 ** Initialize a SelectDest structure.
94548 ** Allocate a new Select structure and return a pointer to that
94549 ** structure.
94603 ** Delete the given Select structure and all of its substructures.
94627 ** a join type, but put an error in the pParse structure.
94817 ** The terms of a FROM clause are contained in the Select.pSrc structure.
95245 ** Given an expression list, generate a KeyInfo structure that records
95249 ** KeyInfo structure is appropriate for initializing a virtual index to
95251 ** then the KeyInfo structure is appropriate for initializing a virtual
95254 ** Space to hold the KeyInfo structure is obtain from malloc. The calling
95255 ** function is responsible for seeing that this structure is eventually
95256 ** freed. Add the KeyInfo structure to the P4 field of an opcode using
95324 ** in sqlite3Select() to assign values to structure member variables that
95524 Table *pTab = 0; /* Table structure column is extracted from */
95875 ** Given a SELECT statement, generate a Table structure that describes
96356 ** Attach the KeyInfo structure to all temporary tables.
97413 /* Delete the transient table structure associated with the
97725 ** then create a transient table structure to describe the subquery.
97961 ** information to the Table structure that represents the result set
97964 ** The Table structure that represents the result set was constructed
98079 ** in the AggInfo structure.
98205 ** contents of the SelectDest structure pointed to by argument pDest
98252 ** This routine does NOT free the Select structure passed in. The
98857 /* If isSimpleCount() returns a pointer to a Table structure, then
98862 ** where the Table structure returned represents table <tbl>.
98885 ** and pKeyInfo to the KeyInfo structure required to navigate the
98890 ** In practice the KeyInfo structure will not be used. It is only
99111 /* End of the structure debug printing code
99141 ** This structure is used to pass data from sqlite3_get_table() through
99156 ** is to fill in the TabResult structure appropriately, allocating new
99389 ** structure is generated based on the information available and stored
99660 ** a trigger step. Return a pointer to a TriggerStep structure.
99783 ** Recursively delete a Trigger structure
99844 ** Return a pointer to the Table structure for the table that a trigger
100109 ** Parse context structure pFrom has just been used to create a sub-vdbe
100544 sqlite3 *db; /* The database structure */
101575 ** pTab is a pointer to a Table structure representing a virtual-table.
101689 ** Since it is a virtual-table, the Table structure contains a pointer
101691 ** structure is associated with a single sqlite3* user of the schema.
101692 ** The reference count of the VTable structure associated with database
101694 ** structure being xDisconnected and free). Any other VTable structures
101963 /* If everything went according to plan, link the new VTable structure
102215 ** the offset of the method to call in the sqlite3_module structure.
102391 ** new FuncDef structure that is marked as ephemeral using the
102575 ** The query generator uses an array of instances of this structure to
102580 ** All WhereTerms are collected into a single WhereClause structure.
102610 ** but they do so indirectly. A single WhereMaskSet structure translates
102660 ** An instance of the following structure holds all information about a
102690 ** a dynamically allocated instance of the following structure.
102699 ** a dynamically allocated instance of the following structure.
102706 ** An instance of the following structure keeps track of a mapping
102713 ** use of the bits in our bitmasks. This structure provides a mapping
102721 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
102801 ** Initialize a preallocated WhereClause structure.
102839 ** Deallocate a WhereClause structure. The WhereClause structure
102912 ** operator specified in the op parameter. The WhereClause structure
103418 ** stored in a WhereClause structure containing within the WhereOrInfo
103635 ** The input to this routine is an WhereTerm structure with only the
103638 ** structure.
104156 /* Argument pIdx must either point to a 'real' named index structure,
104157 ** or an index structure allocated on the stack by bestBtreeIndex() to
104281 ** structure. Used for testing and debugging only. If neither
104674 ** Allocate and populate an sqlite3_index_info structure. It is the
104675 ** responsibility of the caller to eventually release the structure
104709 ** the sqlite3_index_info structure.
104722 /* Allocate the sqlite3_index_info structure
104733 /* Initialize the structure. The sqlite3_index_info structure contains
104787 ** part of the sqlite3_index_info structure is left populated.
104831 ** the sqlite3_index_info structure that is used to communicate with
104835 ** same virtual table. The sqlite3_index_info structure is created
104837 ** invocations. The sqlite3_index_info structure is also used when
104839 ** routine takes care of freeing the sqlite3_index_info structure after
104868 /* If the sqlite3_index_info structure has not been previously
104879 /* At this point, the sqlite3_index_info structure that pIdxInfo points
104887 ** be a pointer to an sqlite3_vtab structure. Otherwise
105145 ** an sqlite3_value structure containing the same value, with affinity
105147 ** caller to eventually release this structure by passing it to
105152 ** create an sqlite3_value structure containing this value, again with
105299 ** in the pParse structure.
105348 ** in the pParse structure.
105836 ** index and its cost in the pCost structure.
107031 ** Free a WhereInfo structure
107061 ** The return value is a pointer to an opaque structure that contains
107185 /* Allocate and initialize the WhereInfo structure that will become the
107187 ** struct, the contents of WhereInfo.a[], the WhereClause structure
107188 ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
107648 /* Record the continuation address in the WhereInfo structure. Then
107817 ** An instance of this structure holds information about the
107826 ** An instance of this structure is used to store the LIKE,
107835 ** An instance of the following structure describes the event of a
107846 ** An instance of this structure holds the ATTACH key and the key type.
108635 /* The following structure represents a single element of the
108657 ** the following structure */
111089 ** The first argument is a pointer to a structure obtained from
111098 ** <li> A pointer to the parser (an opaque structure.)
111916 ** Run the parser on the given SQL string. The parser structure is
112037 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
112038 ** will take responsibility for freeing the Table structure.
113273 ** structure?
114591 /* Allocate the sqlite data structure */
116105 ** Since we're using a segmented structure, with no docid-oriented
116166 ** interface functions. This is essentially the class structure for
116193 ** sqlite3_tokenizer structure representing the specific tokenizer to
116209 ** Structure version. Should always be set to 0 or 1.
116226 ** to point at the newly created tokenizer structure. The generic
116344 /* A complete hash table is an instance of the following structure.
116345 ** The internals of this structure are intended to be opaque -- client
116346 ** code should not attempt to access or modify the fields of this structure
116347 ** directly. Change this structure only by using the routines below.
116349 ** accessing this structure are really macros, so we can't really make
116350 ** this structure opaque.
116365 ** structure. All elements are stored on a single doubly-linked list.
116367 ** Again, this structure is intended to be opaque, but it can't really
116576 ** structure. The xCreate and xConnect methods create an instance
116577 ** of this structure and xDestroy and xDisconnect free that instance.
116578 ** All other methods receive a pointer to the structure as one of their
116645 ** virtual table cursor (an instance of the following structure) using
117158 ** memory associated with the Fts3Table structure and return SQLITE_OK.
117680 sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
117892 /* Allocate and populate the Fts3Table structure. */
117928 /* Fill in the zName and zDb fields of the vtab structure. */
118114 /* Allocate a buffer large enough for an Fts3Cursor structure. If the
118238 ** Even if the data structure on disk is corrupted, this (reading two
121766 ** Free all components of the Fts3Phrase structure that were allocated by
122448 ** structure of type FTSQUERY_PHRASE containing a phrase consisting of this
122452 ** Fts3Expr structure (if any) by passing it to sqlite3_free().
122540 ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE
122544 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
122564 /* The final Fts3Expr data structure, including the Fts3Phrase,
122573 ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase
122574 ** structure, followed by the array of Fts3PhraseToken
122666 ** structure, or set to 0 if the end of the input buffer is reached.
122826 ** The argument is an Fts3Expr structure for a binary operator (any type
122899 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
123066 Fts3Expr **ppExpr /* OUT: Parsed query structure */
123350 ** fields of the Hash structure.
125128 ** An instance of the following data structure is used to build doclists
125152 ** An instance of this structure is used to iterate through the terms on
125154 ** this structure are only manipulated by code in this file, opaque handles
125207 ** An instance of this structure is used to create a segment b-tree in the
125216 SegmentNode *pTree; /* Pointer to interior tree structure */
125589 ** This function also serves to allocate the PendingList structure itself.
125590 ** For example, to create a new PendingList structure containing two
125633 ** Add a docid/column/position entry to a PendingList structure. Non-zero
125634 ** is returned if the structure is sqlite3_realloced as part of adding
125642 PendingList **pp, /* IN/OUT: PendingList structure */
126341 ** of these statements is untrue, then the data structure is corrupt.
127121 /* Allocate the SegmentWriter structure */
128708 ** of the following structure is used to accumulate those values while the
129004 ** The selected snippet parameters are stored in structure *pFragment before
129365 void *pCtx /* Pointer to MatchInfo structure */
129381 void *pCtx /* Pointer to MatchInfo structure */
129471 ** An instance of the following structure is used to store state while
129493 void *pCtx /* Pointer to MatchInfo structure */
130135 ** The data structure for a single virtual r-tree table is stored in three
130144 ** The data for each node of the r-tree structure is stored in the %_node
130175 ** same data-structure is used for all, but the algorithms for insert and
130262 int iDepth; /* Current depth of the r-tree structure */
130266 int nBusy; /* Current number of users of this structure */
130315 ** 2^40 is greater than 2^64, an r-tree structure always has a depth of
130340 ** to the Rtree structure associated with the RtreeCoord.
130368 ** An rtree structure node.
130381 ** Structure to store a deserialized rtree record.
130397 ** An instance of this structure must be supplied as a blob argument to
130411 ** a single instance of the following structure is allocated. It is used
130578 Rtree *pRtree, /* R-tree structure */
130625 ** of the r-tree structure. A height of zero means all data is stored on
130628 ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
130800 ** Deserialize cell iCell of node pNode. Populate the structure pointed
130859 ** zero the structure is deleted.
132532 ** cell, adjust the r-tree data structure if required.
132747 ** Remove the entry with rowid=iDelete from the r-tree structure.
132753 RtreeNode *pRoot; /* Root node of rtree structure */
132917 ** the r-tree structure.
133171 /* Allocate the sqlite3_vtab structure */
133237 ** For a two-dimensional r-tree structure called "rt", to deserialize
133768 ** a UCollator structure previously allocated using ucol_open().
133777 ** a UCollator structure previously allocated using ucol_open().
