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
25008 ** structure are used to store the file descriptor while waiting for an
25018 ** The unixFile structure is subclass of sqlite3_file specific to the unix
25057 /* In test mode, increase the size of this structure a bit so that
25790 ** A pointer to an instance of the following structure can be used as a
25791 ** unique file ID in VxWorks. Each instance of this structure contains
25793 ** The structure is reclaimed when the number of pointers to it drops to
25951 ** st_dev and st_ino fields of the stat structure that fstat() fills in)
25961 ** The sqlite3_file structure for POSIX is no longer just an integer file
25962 ** descriptor. It is now a structure that holds the integer file
25963 ** descriptor and a pointer to a structure that describes the internal
25964 ** locks on the corresponding inode. There is one locking structure
25966 ** point to the same locking structure. The locking structure keeps
25973 ** structure. The fcntl() system call is only invoked to set a
25974 ** POSIX lock if the internal lock structure transitions between
25986 ** The unixInodeInfo structure keeps a list of file descriptors that need to
26012 ** An instance of the following structure serves as the key used
26025 ** An instance of the following structure is allocated for each open
26030 ** structure contains a pointer to an instance of this object and this
26038 int nRef; /* Number of pointers to this structure */
26164 ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
26821 ** structure to 0.
27229 ** lock states in the sqlite3_file structure, but all locks SHARED or
27405 ** lock states in the sqlite3_file structure, but all locks SHARED or
27516 ** The afpLockingContext structure contains all afp lock specific state
28273 /* The following "ifdef/elif/else/" block has the same structure as
28713 ** in this structure.
28734 ** Structure used internally by this VFS to record the state of an
28773 struct flock f; /* The posix advisory locking structure */
29638 ** Initialize the contents of the unixFile structure pointed to by pId.
29643 sqlite3_file *pId, /* Write to the unixFile structure here */
30288 ** and clear all the structure's references. Specifically,
31035 ** conch file structure and finally the original conch file descriptor is
31525 ** the unix structure properly cleaned up at close time:
32193 ** The winFile structure is a subclass of sqlite3_file* specific to the win32
32252 ** The winMemData structure stores information required by the Win32-specific
32258 u32 magic; /* Magic number to detect structure corruption. */
34425 ** in this structure.
34457 ** Structure used internally by this VFS to record the state of an
34625 ** use FILE_ID_BOTH_DIR_INFO Structure.
35704 /* FILETIME structure is a 64-bit value representing the number of
35879 /* Size of the Bitvec structure in bytes. */
35913 ** A bitmap is an instance of the following structure.
36241 /* Free allocated structure */
36267 ** A complete page cache is an instance of this structure.
36963 ** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of
36964 ** PgHdr1.pCache->szPage bytes is allocated directly before this structure
37012 ** All code in this file should access the global structure above via the
37328 ** (PCache1.apHash structure) that it is currently stored in.
37979 ** following structure) to reduce memory allocation overhead. The
37989 ** A RowSet in an instance of the following structure.
37991 ** A typedef of this structure if found in sqliteInt.h.
38886 ** An instance of the following structure is allocated for each active
40255 ** The first argument is a pointer to the pager structure, the second
41347 ** is actually a pointer to the Pager structure.
41633 ** corresponding bit is set in a bitvec structure (variable pDone in the
42757 Pager **ppPager, /* OUT: Return the Pager structure here */
42839 /* Allocate memory for the Pager structure, PCache object, the
42852 ROUND8(sizeof(*pPager)) + /* Pager structure */
42961 ** Pager structure and close the file.
43603 ** Pager.pInJournal bitvec structure is allocated.
44741 ** Return the VFS structure for the pager.
45486 ** data structure called the wal-index is maintained to expedite the
45819 ** This structure is used to implement an iterator that loops through
45825 ** The internals of this structure are only accessed by:
45918 ** Return a pointer to the WalCkptInfo structure in the wal-index.
45926 ** Return a pointer to the WalIndexHdr structure in the wal-index.
48726 ** structure is appended and initialized to zero. This structure stores
48734 ** Access to all fields of this structure is controlled by the mutex
48791 ** this object for every database file that it has open. This structure
48793 ** see the internals of this structure and only deals with pointers to
48794 ** this structure.
48803 ** All fields in this structure are accessed under sqlite3.mutex.
48828 ** of the Btree structure. At most one of these may open a write transaction,
48845 ** Fields in this structure are accessed under the BtShared.mutex
48896 int nRef; /* Number of references to this structure */
48916 ** An instance of the following structure is used to hold information
48917 ** about a cell. The parseCellPtr() function fills in this structure
48933 ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
48954 ** Fields in this structure are accessed under the BtShared.mutex
49097 ** This structure is passed around through all the sanity checking routines
49344 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
49477 ** of each BtShared structure and so this locking is not necessary.
49505 ** as this module treats each table as a separate structure. To determine
49835 ** on the shared btree structure pBt.
50277 ** Parse a cell content block and fill in the CellInfo structure. There
50288 CellInfo *pInfo /* Fill in this structure */
50356 CellInfo *pInfo /* Fill in this structure */
50726 ** and initialize fields of the MemPage structure accordingly.
50783 BtShared *pBt; /* The main btree structure */
51099 BtShared *pBt = 0; /* Shared part of btree structure */
51357 ** remove the BtShared structure from the sharing list. Return
51432 /* Rollback any active transaction and free the handle structure.
51440 ** structure, return now. The remainder of this procedure cleans
51961 ** on this shared-btree structure and a second write transaction is
52998 ** BtCursor.info structure. If it is not already valid, call
53615 ** into more than one b-tree structure in a corrupt database. */
53632 ** Move the cursor to point to the root page of its b-tree structure.
53639 ** If the b-tree structure is empty, the cursor state is set to
53647 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
53649 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
54099 ** page into more than one b-tree structure. */
54545 /* Now manipulate the actual database free-list structure. There are two
55250 /* Reinitialize page pTo so that the contents of the MemPage structure
55795 ** b-tree structure by one. This is described as the "balance-shallower"
55939 ** This function is called when the root page of a b-tree structure is
56276 ** fails. Internal data structure corruption will result otherwise.
56854 ** page in the B-Tree structure (not including overflow pages).
57687 ** Structure allocated for each backup operation.
57715 ** structure may be accessed via two groups of thread-safe entry points:
57720 ** structure, in that order.
57725 ** associated with the source database BtShared structure will always
57849 ** sqlite3_backup structure.
58239 /* Exit the mutexes and free the backup context structure. */
58397 ** This file contains code use to manipulate "Mem" structure. A "Mem"
58398 ** stores a single value in the VDBE. Mem is an opaque structure visible
58777 ** The MEM structure is already a MEM_Real. Try to also make it a
59057 ** Mem structure. Otherwise, any existing buffer is freed and the
59266 ** Move data out of a btree key or data field and into a Mem structure.
59272 ** The pMem structure is assumed to be uninitialized. Any prior content
59283 Mem *pMem /* OUT: Return data in this Mem structure. */
60120 ** If the input FuncDef structure is ephemeral, then free it. If
60232 ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
60233 ** A copy is made of the KeyInfo structure into memory obtained from
60235 ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
60241 ** to a string or structure that is guaranteed to exist for the lifetime of
60518 ** this routine obtains the mutex associated with each BtShared structure
61136 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
61887 ** and error message from the VDBE into the main database structure. But
62380 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
62381 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
62425 ** UnpackedRecord structure indicated by the fourth argument with the
62432 UnpackedRecord *p /* Populate this structure before returning. */
62738 ** Return a pointer to an sqlite3_value structure containing the value bound
62913 ** structure.
63293 ** Extract the user data from a sqlite3_context structure and return a
63302 ** Extract the user data from a sqlite3_context structure and return a
63477 ** value SQL NULL. Even though the Mem structure contains an element
63482 ** that a Mem structure is located on an 8-byte boundary. To prevent
64249 ** The following code implements the data-structure explaining logic
64342 ** Free the indentation structure
64436 ** field of the sqlite3 structure is set in order to simulate an interrupt.
64559 ** required for this VdbeCursor structure. It is convenient to use a
64561 ** VdbeCursor structure for the following reasons:
65985 ** structure to provide access to the top P1 values as the result
66246 ** Invoke a user function (P4 is a pointer to a Function structure that
66775 ** P4 is a KeyInfo structure that defines collating sequences and sort
67013 ** Interpret the data that cursor P1 points to as a structure built using
67303 ** dynamically allocated space over to the u.an.pDest structure.
67560 /* Create a new savepoint structure. */
67946 ** v-table would have to be ready for the sqlite3_vtab structure itself
67983 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
67984 ** structure, then said structure defines the content and collating
67997 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
67998 ** structure, then said structure defines the content and collating
68099 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
70319 ** structure that specifies the function. Use register
70643 ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
70690 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70912 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70944 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
71698 ** NOTES ON DATA STRUCTURE USED FOR N-WAY MERGES:
71705 structure used to do so. The structure supports
71796 ** A structure to store a single record. All in-memory records are connected
71814 ** argument. All structure fields are set to zero before returning.
72784 ** If the argument p points to a JournalFile structure, and the underlying
73294 ** prevents ExprDelete() from deleting the Expr structure itself,
73331 ** pExpr->pTab Points to the Table structure of X.Y (even if
74708 ** of any expression tree referenced by the structure passed as the
74744 ** Set the Expr.nHeight variable in the structure passed as an
75066 ** Return the number of bytes allocated for the expression structure
75081 ** dupedExprStructSize() Size of only the Expr structure
75088 ** (1) the space required for a copy of the Expr structure only and
75089 ** (2) the EP_xxx flags that indicate what the structure size should be.
75096 ** The size of the structure can be found by masking the return value
75131 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
75183 /* Figure out where to write the new Expr structure. */
75193 /* Set nNewSize to the size allocated for the structure pointed to
75271 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
75272 ** truncated version of the usual Expr structure that will be stored as
75818 ** It's job is to find or create a b-tree structure that may be used
75848 ** needs to know whether or not the structure contains an SQL NULL
75863 ** has_null = <test if data structure contains null>
75867 ** in order to avoid running the <test if data structure contains null>
78316 ** function that is already in the pAggInfo structure
79087 ** The Table structure pParse->pNewTable was extended to include
79204 ** This routine makes a (partial) copy of the Table structure
79208 ** the copy. The copy of the Table structure is deleted by tokenize.c
79509 ** share an instance of the following structure to hold their state
80839 ** Initialize a DbFixer structure. This routine must be called prior
80840 ** to passing the structure to one of the sqliteFixAAAA() routines below.
80867 ** was left unspecified in the original SQL statement. The pFix structure
81261 ** be parsed. Initialize the pParse structure as needed.
81270 ** The TableLock structure is only used by the sqlite3TableLock() and
81352 ** VDBE program and resets the pParse structure for the next
81488 ** Locate the in-memory structure that describes a particular database
81518 ** Locate the in-memory structure that describes a particular database
81555 ** Locate the in-memory structure that describes
81733 ** This routine just deletes the data structure. It does not unlink
81734 ** the table data structure from the hash table. But it does destroy
81765 /* Delete the Table structure itself.
81782 ** table structure with all its indices and foreign keys.
82074 ** then record a pointer to this table in the main database structure
82671 ** The table structure that other action routines have been building
82968 ** The Table structure pTable is really a VIEW. Fill in the names of
82969 ** the columns of the view in the pTable structure. Return the number
83421 ** An FKey structure is created and added to the table currently
83691 ** structure. This is used by sqlite3AddPrimaryKey() to mark the index
83890 ** Allocate the index structure.
83895 ROUND8(sizeof(Index)) + /* Index structure */
83933 ** load the column indices into the Index structure. Report an error
84047 /* Link the new Index structure to its table and to the other
84721 ** the number of errors. Leave any error messages in the pParse structure.
85012 ** Return a dynamicly allocated KeyInfo structure that can be used
85015 ** If successful, a pointer to the new structure is returned. In this case
85195 ** each collation sequence structure.
85356 ** pointer to the FuncDef structure that defines that function, or return
85360 ** structure is created and liked into the "db" structure if a
85409 ** install a new function. Whatever FuncDef structure is returned it will
85449 ** Free all resources held by the schema structure. The void* argument points
85742 sqlite3 *db; /* Main database structure */
85762 ** put in an SrcList structure because some of the subroutines we
86658 ** A structure defining how to do GLOB-style comparisons.
86843 ** This same function (with a different compareInfo structure) computes
87388 ** An instance of the following structure holds the context of a
87459 ** The following structure keeps track of state information for the
87664 ** the first three statements in the compareInfo structure. The
87898 ** sqlite3FkDelete() - Delete an FKey structure.
88365 ** to the FKey structure representing the foreign key constraint on table
88376 ** The second argument is a Trigger structure allocated by the
88377 ** fkActionTrigger() routine. This function deletes the Trigger structure
88380 ** The Trigger structure or any of its sub-components may be allocated from
88599 /* Create a SrcList structure containing a single table (the table
88724 ** It returns a pointer to a Trigger structure containing a trigger
88736 ** then the returned trigger structure is equivalent to:
89052 structure. It will be
89059 ** a member of the Index structure for subsequent use.
89062 ** sqliteDeleteIndex() when the Index structure itself is cleaned
89100 ** stored as a member of the Table structure for subsequent use.
89103 ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
89170 ** Locate or create an AutoincInfo structure associated with table pTab
89174 ** There is at most one AutoincInfo structure per table even if the
89176 ** triggers. A new AutoincInfo structure is created if this is the
89178 ** AutoincInfo structure is used.
89440 sqlite3 *db; /* The main database structure */
91034 ** The following structure holds pointers to all of the SQLite API
91038 ** interfaces to the end of this structure only. If you insert new
91039 ** interfaces in the middle of this structure, then older different
91252 ** redirected throught the global sqlite3_api structure.
91256 ** it can get access to the sqlite3_api_routines structure
91555 ** The following structure contains pointers to all SQLite API routines.
91556 ** A pointer to this structure is passed into extensions when they are
91560 ** When adding new APIs, add them to the bottom of this structure
93692 ** Fill the InitData structure with an error message that indicates
93821 ** The master database table has a structure like this
94057 ** bit is set in the flags field of the Db structure. If the database
94556 ** Delete all the content of a Select structure but do not deallocate
94557 ** the select structure itself.
94572 ** Initialize a SelectDest structure.
94584 ** Allocate a new Select structure and return a pointer to that
94585 ** structure.
94639 ** Delete the given Select structure and all of its substructures.
94663 ** a join type, but put an error in the pParse structure.
94853 ** The terms of a FROM clause are contained in the Select.pSrc structure.
95281 ** Given an expression list, generate a KeyInfo structure that records
95285 ** KeyInfo structure is appropriate for initializing a virtual index to
95287 ** then the KeyInfo structure is appropriate for initializing a virtual
95290 ** Space to hold the KeyInfo structure is obtain from malloc. The calling
95291 ** function is responsible for seeing that this structure is eventually
95292 ** freed. Add the KeyInfo structure to the P4 field of an opcode using
95360 ** in sqlite3Select() to assign values to structure member variables that
95560 Table *pTab = 0; /* Table structure column is extracted from */
95911 ** Given a SELECT statement, generate a Table structure that describes
96392 ** Attach the KeyInfo structure to all temporary tables.
97449 /* Delete the transient table structure associated with the
97761 ** then create a transient table structure to describe the subquery.
97997 ** information to the Table structure that represents the result set
98000 ** The Table structure that represents the result set was constructed
98115 ** in the AggInfo structure.
98241 ** contents of the SelectDest structure pointed to by argument pDest
98288 ** This routine does NOT free the Select structure passed in. The
98893 /* If isSimpleCount() returns a pointer to a Table structure, then
98898 ** where the Table structure returned represents table <tbl>.
98921 ** and pKeyInfo to the KeyInfo structure required to navigate the
98926 ** In practice the KeyInfo structure will not be used. It is only
99147 /* End of the structure debug printing code
99177 ** This structure is used to pass data from sqlite3_get_table() through
99192 ** is to fill in the TabResult structure appropriately, allocating new
99425 ** structure is generated based on the information available and stored
99696 ** a trigger step. Return a pointer to a TriggerStep structure.
99819 ** Recursively delete a Trigger structure
99880 ** Return a pointer to the Table structure for the table that a trigger
100145 ** Parse context structure pFrom has just been used to create a sub-vdbe
100580 sqlite3 *db; /* The database structure */
101611 ** pTab is a pointer to a Table structure representing a virtual-table.
101725 ** Since it is a virtual-table, the Table structure contains a pointer
101727 ** structure is associated with a single sqlite3* user of the schema.
101728 ** The reference count of the VTable structure associated with database
101730 ** structure being xDisconnected and free). Any other VTable structures
101999 /* If everything went according to plan, link the new VTable structure
102251 ** the offset of the method to call in the sqlite3_module structure.
102427 ** new FuncDef structure that is marked as ephemeral using the
102611 ** The query generator uses an array of instances of this structure to
102616 ** All WhereTerms are collected into a single WhereClause structure.
102646 ** but they do so indirectly. A single WhereMaskSet structure translates
102696 ** An instance of the following structure holds all information about a
102726 ** a dynamically allocated instance of the following structure.
102735 ** a dynamically allocated instance of the following structure.
102742 ** An instance of the following structure keeps track of a mapping
102749 ** use of the bits in our bitmasks. This structure provides a mapping
102757 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
102837 ** Initialize a preallocated WhereClause structure.
102875 ** Deallocate a WhereClause structure. The WhereClause structure
102948 ** operator specified in the op parameter. The WhereClause structure
103454 ** stored in a WhereClause structure containing within the WhereOrInfo
103671 ** The input to this routine is an WhereTerm structure with only the
103674 ** structure.
104192 /* Argument pIdx must either point to a 'real' named index structure,
104193 ** or an index structure allocated on the stack by bestBtreeIndex() to
104317 ** structure. Used for testing and debugging only. If neither
104710 ** Allocate and populate an sqlite3_index_info structure. It is the
104711 ** responsibility of the caller to eventually release the structure
104745 ** the sqlite3_index_info structure.
104758 /* Allocate the sqlite3_index_info structure
104769 /* Initialize the structure. The sqlite3_index_info structure contains
104823 ** part of the sqlite3_index_info structure is left populated.
104867 ** the sqlite3_index_info structure that is used to communicate with
104871 ** same virtual table. The sqlite3_index_info structure is created
104873 ** invocations. The sqlite3_index_info structure is also used when
104875 ** routine takes care of freeing the sqlite3_index_info structure after
104904 /* If the sqlite3_index_info structure has not been previously
104915 /* At this point, the sqlite3_index_info structure that pIdxInfo points
104923 ** be a pointer to an sqlite3_vtab structure. Otherwise
105181 ** an sqlite3_value structure containing the same value, with affinity
105183 ** caller to eventually release this structure by passing it to
105188 ** create an sqlite3_value structure containing this value, again with
105335 ** in the pParse structure.
105384 ** in the pParse structure.
105872 ** index and its cost in the pCost structure.
107067 ** Free a WhereInfo structure
107097 ** The return value is a pointer to an opaque structure that contains
107221 /* Allocate and initialize the WhereInfo structure that will become the
107223 ** struct, the contents of WhereInfo.a[], the WhereClause structure
107224 ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
107684 /* Record the continuation address in the WhereInfo structure. Then
107853 ** An instance of this structure holds information about the
107862 ** An instance of this structure is used to store the LIKE,
107871 ** An instance of the following structure describes the event of a
107882 ** An instance of this structure holds the ATTACH key and the key type.
108671 /* The following structure represents a single element of the
108693 ** the following structure */
111125 ** The first argument is a pointer to a structure obtained from
111134 ** <li> A pointer to the parser (an opaque structure.)
111952 ** Run the parser on the given SQL string. The parser structure is
112073 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
112074 ** will take responsibility for freeing the Table structure.
113309 ** structure?
114627 /* Allocate the sqlite data structure */
116141 ** Since we're using a segmented structure, with no docid-oriented
116202 ** interface functions. This is essentially the class structure for
116229 ** sqlite3_tokenizer structure representing the specific tokenizer to
116245 ** Structure version. Should always be set to 0 or 1.
116262 ** to point at the newly created tokenizer structure. The generic
116380 /* A complete hash table is an instance of the following structure.
116381 ** The internals of this structure are intended to be opaque -- client
116382 ** code should not attempt to access or modify the fields of this structure
116383 ** directly. Change this structure only by using the routines below.
116385 ** accessing this structure are really macros, so we can't really make
116386 ** this structure opaque.
116401 ** structure. All elements are stored on a single doubly-linked list.
116403 ** Again, this structure is intended to be opaque, but it can't really
116612 ** structure. The xCreate and xConnect methods create an instance
116613 ** of this structure and xDestroy and xDisconnect free that instance.
116614 ** All other methods receive a pointer to the structure as one of their
116681 ** virtual table cursor (an instance of the following structure) using
117194 ** memory associated with the Fts3Table structure and return SQLITE_OK.
117716 sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
117928 /* Allocate and populate the Fts3Table structure. */
117964 /* Fill in the zName and zDb fields of the vtab structure. */
118150 /* Allocate a buffer large enough for an Fts3Cursor structure. If the
118274 ** Even if the data structure on disk is corrupted, this (reading two
121814 ** Free all components of the Fts3Phrase structure that were allocated by
122496 ** structure of type FTSQUERY_PHRASE containing a phrase consisting of this
122500 ** Fts3Expr structure (if any) by passing it to sqlite3_free().
122588 ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE
122592 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
122612 /* The final Fts3Expr data structure, including the Fts3Phrase,
122621 ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase
122622 ** structure, followed by the array of Fts3PhraseToken
122714 ** structure, or set to 0 if the end of the input buffer is reached.
122874 ** The argument is an Fts3Expr structure for a binary operator (any type
122947 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
123114 Fts3Expr **ppExpr /* OUT: Parsed query structure */
123398 ** fields of the Hash structure.
125176 ** An instance of the following data structure is used to build doclists
125200 ** An instance of this structure is used to iterate through the terms on
125202 ** this structure are only manipulated by code in this file, opaque handles
125255 ** An instance of this structure is used to create a segment b-tree in the
125264 SegmentNode *pTree; /* Pointer to interior tree structure */
125637 ** This function also serves to allocate the PendingList structure itself.
125638 ** For example, to create a new PendingList structure containing two
125681 ** Add a docid/column/position entry to a PendingList structure. Non-zero
125682 ** is returned if the structure is sqlite3_realloced as part of adding
125690 PendingList **pp, /* IN/OUT: PendingList structure */
126389 ** of these statements is untrue, then the data structure is corrupt.
127169 /* Allocate the SegmentWriter structure */
128756 ** of the following structure is used to accumulate those values while the
129052 ** The selected snippet parameters are stored in structure *pFragment before
129413 void *pCtx /* Pointer to MatchInfo structure */
129429 void *pCtx /* Pointer to MatchInfo structure */
129519 ** An instance of the following structure is used to store state while
129541 void *pCtx /* Pointer to MatchInfo structure */
130183 ** The data structure for a single virtual r-tree table is stored in three
130192 ** The data for each node of the r-tree structure is stored in the %_node
130223 ** same data-structure is used for all, but the algorithms for insert and
130310 int iDepth; /* Current depth of the r-tree structure */
130314 int nBusy; /* Current number of users of this structure */
130363 ** 2^40 is greater than 2^64, an r-tree structure always has a depth of
130388 ** to the Rtree structure associated with the RtreeCoord.
130416 ** An rtree structure node.
130429 ** Structure to store a deserialized rtree record.
130445 ** An instance of this structure must be supplied as a blob argument to
130459 ** a single instance of the following structure is allocated. It is used
130626 Rtree *pRtree, /* R-tree structure */
130673 ** of the r-tree structure. A height of zero means all data is stored on
130676 ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
130848 ** Deserialize cell iCell of node pNode. Populate the structure pointed
130907 ** zero the structure is deleted.
132580 ** cell, adjust the r-tree data structure if required.
132795 ** Remove the entry with rowid=iDelete from the r-tree structure.
132801 RtreeNode *pRoot; /* Root node of rtree structure */
132965 ** the r-tree structure.
133219 /* Allocate the sqlite3_vtab structure */
133285 ** For a two-dimensional r-tree structure called "rt", to deserialize
133816 ** a UCollator structure previously allocated using ucol_open().
133825 ** a UCollator structure previously allocated using ucol_open().
