Lines Matching refs:STRUCTURE
290 ** presents to client programs. If a C-function, structure, datatype,
510 ** the opaque structure named "sqlite3". It is useful to think of an sqlite3
975 ** point to a structure that may contain arguments or space in which to
1345 ** A pointer to the opaque sqlite3_api_routines structure is passed as
1347 ** structure must be typedefed in order to work around compiler warnings
1362 ** object when the iVersion value is increased. Note that the structure
1368 ** structure used by this VFS. mxPathname is the maximum length of
1379 ** structure that SQLite will ever modify. SQLite will only access
1456 ** to hold the [sqlite3_file] structure passed as the third
1458 ** allocate the structure; it should just fill it in. Note that
1481 ** included in the VFS structure for completeness.
1512 int iVersion; /* Structure version number (currently 3) */
1877 ** a pointer to an instance of the [sqlite3_mem_methods] structure.
1881 ** its own private copy of the content of the [sqlite3_mem_methods] structure
1886 ** is a pointer to an instance of the [sqlite3_mem_methods] structure.
1888 ** structure is filled with the currently defined memory allocation routines.)^
1984 ** pointer to an instance of the [sqlite3_mutex_methods] structure.
1987 ** the content of the [sqlite3_mutex_methods] structure before the call to
1996 ** is a pointer to an instance of the [sqlite3_mutex_methods] structure. The
1998 ** structure is filled with the currently defined mutex routines.)^
2624 ** Definition: A <b>result table</b> is memory data structure created by the
6113 ** This structure, sometimes called a "virtual table module",
6115 ** This structure consists mostly of methods for the module.
6118 ** instance of this structure and passing a pointer to that instance
6122 ** of this structure must not change while it is registered with
6164 ** The sqlite3_index_info structure and its substructures is used as part
6244 ** structure for SQLite [version 3.8.2] ([dateof:3.8.2]).
6381 ** following structure to describe cursors that point into the
6388 ** the content of a cursor structure to suit its own needs.
6835 ** An instance of this structure defines the low-level routines
6842 ** creates and populates an instance of this structure to pass
6844 ** Additionally, an instance of this structure can be used as an
6848 ** ^The xMutexInit method defined by this structure is invoked as
6853 ** ^The xMutexEnd method defined by this structure is invoked as
6860 ** ^(The remaining seven methods defined by this structure (xMutexAlloc,
6877 ** by this structure are not required to handle this case, the results
7417 ** its size or internal structure and never deals with the
7447 ** instance of the sqlite3_pcache_methods2 structure.)^
7461 ** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
8828 ** A pointer to a structure of the following type is passed as the first
8855 ** A pointer to a structure of the following type is passed as the
8859 ** Note that the first 5 fields of this structure are identical to
8860 ** sqlite3_rtree_geometry. This structure is a subclass of
10411 ** The Fts5PhraseIter structure is defined above. Applications should not
10412 ** modify this structure directly - it should only be used as shown above
10503 ** following structure. All structure methods must be defined, setting
10505 ** behaviour. The structure methods are expected to function as follows:
11350 /* A complete hash table is an instance of the following structure.
11351 ** The internals of this structure are intended to be opaque -- client
11352 ** code should not attempt to access or modify the fields of this structure
11353 ** directly. Change this structure only by using the routines below.
11355 ** accessing this structure are really macros, so we can't really make
11356 ** this structure opaque.
11382 ** structure. All elements are stored on a single doubly-linked list.
11384 ** Again, this structure is intended to be opaque, but it can't really
11718 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
12020 ** An instance of the following structure is used to store the busy-handler
12221 ** Forward declarations of structure
12415 BtCursor *pCursor /* Space to write cursor structure */
12583 ** A single VDBE is an opaque structure named "Vdbe". Only routines
12585 ** of this structure.
12599 ** as an instance of the following structure:
12673 #define P4_COLLSEQ (-3) /* P4 is a pointer to a CollSeq structure */
12674 #define P4_FUNCDEF (-4) /* P4 is a pointer to a FuncDef structure */
12675 #define P4_KEYINFO (-5) /* P4 is a pointer to a KeyInfo structure */
12677 #define P4_MEM (-7) /* P4 is a pointer to a Mem* structure */
12679 #define P4_VTAB (-8) /* P4 is a pointer to an sqlite3_vtab structure */
12684 #define P4_SUBPROGRAM (-13) /* P4 is a pointer to a SubProgram structure */
12686 #define P4_TABLE (-15) /* P4 is a pointer to a Table structure */
12716 ** of a VdbeOp structure into a negative number so that
13125 ** Each open file is managed by a separate instance of the "Pager" structure.
13356 ** structure.
13788 ** sqlite3_malloc() to obtain space for the file-handle structure.
13906 ** of the following structure. There are normally two of these structures
13913 Btree *pBt; /* The B*Tree structure for this database file */
13920 ** An instance of the following structure stores a database schema.
13987 ** The Lookaside structure holds configuration information about the
14018 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
14075 ** Each database connection is an instance of the following structure.
14301 ** structure. For global built-in functions (ex: substr(), max(), count())
14302 ** a pointer to this structure is held in the sqlite3BuiltinFunctions object.
14304 ** structure is held in the db->aHash hash table.
14324 ** This structure encapsulates a user-function destructor callback (as
14335 ** is invoked and the FuncDestructor structure freed.
14455 ** instance of the following structure, stored in the sqlite3.aModule
14468 ** of this structure.
14488 ** structure. Conceptually, a collating sequence consists of a name and
14558 ** structure for each database connection (sqlite3*) that uses the shared
14584 ** corresponding sqlite3 structure. They are then deleted/xDisconnected
14599 int nRef; /* Number of pointers to this structure */
14607 ** by an instance of the following structure.
14697 structure.
14715 ** Each REFERENCES clause generates an instance of the following structure
14782 ** An instance of the following structure is passed as the first
14829 ** get and equal results when comparing this structure to a b-tree record.
14849 ** instance of the following structure.
14852 ** by the aiColumn[] field of this structure. For example, suppose
14858 ** In the Table structure describing Ex1, nCol==3 because there are
14859 ** three columns in the table. In the Index structure describing
14876 ** of this structure may be created. In this case the Index.tnum variable is
14936 ** using a structure of this type. See documentation at the top of the
14949 ** this structure. Tokens are also used as part of an expression.
14961 ** An instance of this structure contains information needed to generate
14965 ** pointer to this structure. The Expr.iColumn field is the index in
14970 ** original Select structure that describes the SELECT statement. These
14971 ** fields do not need to be freed when deallocating the AggInfo structure.
15022 ** of this structure.
15233 ** An instance of this structure is used by the parser to record both
15244 ** An instance of this structure can hold a simple list of identifiers,
15292 ** The following structure describes the FROM clause of a SELECT statement.
15296 ** With the addition of multiple database support, the following structure
15343 Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */
15442 ** An instance of the following structure contains all information
15632 ** At least one instance of the following structure is created for each
15677 ** An SQL parser context. A copy of this structure is passed through
15681 ** The structure is divided into two parts. When the parser and code
15682 ** generate call themselves recursively, the first part of the structure
15693 sqlite3 *db; /* The main database structure */
15736 Parse *pToplevel; /* Parse structure for main program (or NULL) */
15818 ** An instance of the following structure can be declared on a stack and used
15823 Parse *pParse; /* The Parse structure */
15947 ** The following structure contains information used by the sqliteFix...
15985 ** A pointer to this structure is used to communicate information
15996 ** Structure containing global configuration data for the SQLite library.
15998 ** This structure also contains some state information.
16114 ** An instance of this structure represents a set of one or more CTEs
16318 ** An instance of the following structure holds information about SQL
17952 ** of the following structure.
18036 ** static element declared in the structure. nField total array slots for
18048 ** When a sub-program is executed (OP_Program), a structure of this type
18052 ** these values are copied back to the Vdbe from the VdbeFrame structure,
18194 ** of this structure. All such structures associated with a single VM
18208 ** instance of this structure is the first argument to the routines used
18211 ** There is a typedef for this structure in sqlite.h. So all routines,
18212 ** even the public interface to SQLite, can use a pointer to this structure.
18214 ** structure are known.
18216 ** This structure is defined inside of vdbeInt.h because it uses substructures
18248 ** An instance of the virtual machine. This structure contains the complete
18251 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
18252 ** is really a pointer to an instance of this structure.
18331 ** Structure used to store the context required by the
18865 ** A structure for holding a single date and time.
19098 ** Write the result into the DateTime structure and return 0
19666 ** the resulting time into the DateTime structure p. Return 0
20484 ** sqlite3_mem_methods structure fails to allocate a block of memory
20510 ** structure. If writable static data is unsupported on the target,
20993 ** into a single structure named "mem". This is to keep the
21542 ** into a single structure named "mem3". This is to keep the
22004 /* Store a pointer to the memory block in global structure mem3. */
22196 ** A minimum allocation is an instance of the following structure.
22224 ** into a single structure named "mem5". This is to keep the
22753 ** the default implementation into the sqlite3GlobalConfig structure.
23144 ** Each recursive mutex is an instance of the following structure.
23820 ** Each recursive mutex is an instance of the following structure.
24922 ** ThreadData structure.
25058 #define etTOKEN 11 /* a pointer to a Token structure */
25075 ** by an instance of the following structure
25222 const et_info *infop; /* Pointer to the appropriate info structure */
26689 ** This structure is the current state of the generator.
26928 void *pArg /* IN: Pointer to the SQLiteThread structure */
29202 ** fields of the Hash structure.
29664 ** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
29829 ** structure are used to store the file descriptor while waiting for an
29839 ** The unixFile structure is subclass of sqlite3_file specific to the unix
29891 /* In test mode, increase the size of this structure a bit so that
30672 ** A pointer to an instance of the following structure can be used as a
30673 ** unique file ID in VxWorks. Each instance of this structure contains
30675 ** The structure is reclaimed when the number of pointers to it drops to
30833 ** st_dev and st_ino fields of the stat structure that fstat() fills in)
30843 ** The sqlite3_file structure for POSIX is no longer just an integer file
30844 ** descriptor. It is now a structure that holds the integer file
30845 ** descriptor and a pointer to a structure that describes the internal
30846 ** locks on the corresponding inode. There is one locking structure
30848 ** point to the same locking structure. The locking structure keeps
30855 ** structure. The fcntl() system call is only invoked to set a
30856 ** POSIX lock if the internal lock structure transitions between
30868 ** The unixInodeInfo structure keeps a list of file descriptors that need to
30894 ** An instance of the following structure serves as the key used
30914 ** An instance of the following structure is allocated for each open
30919 ** structure contains a pointer to an instance of this object and this
30927 int nRef; /* Number of pointers to this structure */
31060 ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
31771 ** structure to 0.
32172 ** lock states in the sqlite3_file structure, but all locks SHARED or
32346 ** lock states in the sqlite3_file structure, but all locks SHARED or
32456 ** The afpLockingContext structure contains all afp lock specific state
33262 /* The following "ifdef/elif/else/" block has the same structure as
33872 ** in this structure.
33893 ** Structure used internally by this VFS to record the state of an
33933 struct flock f; /* The posix advisory locking structure */
35063 ** Initialize the contents of the unixFile structure pointed to by pId.
35068 sqlite3_file *pId, /* Write to the unixFile structure here */
35732 ** and clear all the structure's references. Specifically,
36555 ** conch file structure and finally the original conch file descriptor is
37048 ** the unix structure properly cleaned up at close time:
37919 ** The winFile structure is a subclass of sqlite3_file* specific to the win32
37954 ** The winVfsAppData structure is used for the pAppData member for all of the
38093 ** The winMemData structure stores information required by the Win32-specific
38099 u32 magic1; /* Magic number to detect structure corruption. */
38104 u32 magic2; /* Magic number to detect structure corruption. */
41318 ** in this structure.
41350 ** Structure used internally by this VFS to record the state of an
41512 ** use FILE_ID_BOTH_DIR_INFO Structure.
43428 /* FILETIME structure is a 64-bit value representing the number of
43703 /* Size of the Bitvec structure in bytes. */
43738 ** A bitmap is an instance of the following structure.
44068 /* Free allocated structure */
44095 ** A complete page cache is an instance of this structure. Every
44370 ** structure in the pager.
45052 ** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of
45053 ** PgHdr1.pCache->szPage bytes is allocated directly before this structure
45172 ** All code in this file should access the global structure above via the
45543 ** (PCache1.apHash structure) that it is currently stored in.
46314 ** following structure) to reduce memory allocation overhead. The
46324 ** A RowSet in an instance of the following structure.
46326 ** A typedef of this structure if found in sqliteInt.h.
47306 ** An instance of the following structure is allocated for each active
48754 ** The first argument is a pointer to the pager structure, the second
49907 ** is actually a pointer to the Pager structure.
50203 ** corresponding bit is set in a bitvec structure (variable pDone in the
51491 Pager **ppPager, /* OUT: Return the Pager structure here */
51568 /* Allocate memory for the Pager structure, PCache object, the
51581 ROUND8(sizeof(*pPager)) + /* Pager structure */
51709 /* If an error occurred above, free the Pager structure and close the file.
52504 ** Pager.pInJournal bitvec structure is allocated.
53700 ** Return the VFS structure for the pager.
54524 ** data structure called the wal-index is maintained to expedite the
54880 ** This structure is used to implement an iterator that loops through
54886 ** The internals of this structure are only accessed by:
54979 ** Return a pointer to the WalCkptInfo structure in the wal-index.
54987 ** Return a pointer to the WalIndexHdr structure in the wal-index.
58231 ** Access to all fields of this structure is controlled by the mutex
58287 ** this object for every database file that it has open. This structure
58289 ** see the internals of this structure and only deals with pointers to
58290 ** this structure.
58299 ** All fields in this structure are accessed under sqlite3.mutex.
58326 ** of the Btree structure. At most one of these may open a write transaction,
58343 ** Fields in this structure are accessed under the BtShared.mutex
58398 int nRef; /* Number of references to this structure */
58418 ** An instance of the following structure is used to hold information
58419 ** about a cell. The parseCellPtr() function fills in this structure
58431 ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
58452 ** Fields in this structure are accessed under the BtShared.mutex
58617 ** This structure is passed around through all the sanity checking routines
58890 ** db->aDb[iDb].pSchema structure. The mutexes required for schema
59062 ** of each BtShared structure and so this locking is not necessary.
59090 ** as this module treats each table as a separate structure. To determine
59428 ** on the shared btree structure pBt.
59434 ** on the shared btree structure pBt.
59990 ** structure.
59995 CellInfo *pInfo /* Fill in this structure */
60027 ** Parse a cell content block and fill in the CellInfo structure.
60040 CellInfo *pInfo /* Fill in this structure */
60057 CellInfo *pInfo /* Fill in this structure */
60125 CellInfo *pInfo /* Fill in this structure */
60162 CellInfo *pInfo /* Fill in this structure */
60672 ** and initialize fields of the MemPage structure accordingly.
60753 BtShared *pBt; /* The main btree structure */
61158 BtShared *pBt = 0; /* Shared part of btree structure */
61438 ** remove the BtShared structure from the sharing list. Return
61537 /* Rollback any active transaction and free the handle structure.
61545 ** structure, return now. The remainder of this procedure cleans
62191 ** on this shared-btree structure and a second write transaction is
63266 ** BtCursor.info structure. If it is not already valid, call
63847 ** Move the cursor to point to the root page of its b-tree structure.
63854 ** If the b-tree structure is empty, the cursor state is set to
63862 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
63864 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
64425 ** page into more than one b-tree structure. */
64965 /* Now manipulate the actual database free-list structure. There are two
65987 /* Reinitialize page pTo so that the contents of the MemPage structure
66724 ** b-tree structure by one. This is described as the "balance-shallower"
66793 ** This function is called when the root page of a b-tree structure is
67189 ** fails. Internal data structure corruption will result otherwise.
67852 ** page in the B-Tree structure (not including overflow pages).
68837 ** Structure allocated for each backup operation.
68865 ** structure may be accessed via two groups of thread-safe entry points:
68870 ** structure, in that order.
68875 ** associated with the source database BtShared structure will always
69017 ** structure. */
69454 /* Exit the mutexes and free the backup context structure. */
69634 ** This file contains code use to manipulate "Mem" structure. A "Mem"
69635 ** stores a single value in the VDBE. Mem is an opaque structure visible
70124 ** The MEM structure is already a MEM_Real. Try to also make it a
70463 ** Mem structure. Otherwise, any existing buffer is freed and the
70557 ** Move data out of a btree key or data field and into a Mem structure.
70575 Mem *pMem /* OUT: Return data in this Mem structure. */
70596 Mem *pMem /* OUT: Return data in this Mem structure. */
70713 ** already been allocated, allocate the UnpackedRecord structure that
72141 ** If the input FuncDef structure is ephemeral, then free it. If
72273 ** to a string or structure that is guaranteed to exist for the lifetime of
72756 ** this routine obtains the mutex associated with each BtShared structure
73410 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
74205 ** and error message from the VDBE into the main database structure. But
74838 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
74839 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
74867 ** UnpackedRecord structure indicated by the fourth argument with the
74874 UnpackedRecord *p /* Populate this structure before returning. */
75863 ** Return a pointer to an sqlite3_value structure containing the value bound
75922 ** structure itself, using sqlite3DbFree().
76175 ** structure.
76706 ** Extract the user data from a sqlite3_context structure and return a
76715 ** Extract the user data from a sqlite3_context structure and return a
76919 /* Even though the Mem structure contains an element
76924 ** that a Mem structure is located on an 8-byte boundary. To prevent
77647 ** Allocate and populate an UnpackedRecord structure based on the serialized
77648 ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
78151 ** field of the sqlite3 structure is set in order to simulate an interrupt.
78290 ** required for this VdbeCursor structure. It is convenient to use a
78292 ** VdbeCursor structure for the following reasons:
79499 ** structure to provide access to the r(P1)..r(P1+P2-1) values as
80350 structure that defines collating sequences and sort
80622 ** Interpret the data that cursor P1 points to as a structure built using
81160 /* Create a new savepoint structure. */
81458 ** v-table would have to be ready for the sqlite3_vtab structure itself
81566 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
81567 ** structure, then said structure defines the content and collating
81595 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
81596 ** structure, then said structure defines the content and collating
81722 ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
82556 ** Parameter P4 may point to a Table structure, or may be NULL. If it is
82582 Table *pTab; /* Table structure - used by update and pre-update hooks */
84345 ** structure that specifies the function. Register P3 is the
84710 ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
84774 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
84970 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
85002 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
86124 ** Essentially, this structure contains all those fields of the VdbeSorter
86125 ** structure for which each thread requires a separate instance. For example,
86161 ** Main sorter structure. A single instance of this is allocated for each
86235 ** the contents of the aFile[0] and aFile[1] variables within this structure,
86319 ** argument. All structure fields are set to zero before returning.
87177 ** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or
88455 /* Assuming no errors have occurred, set up a merger structure to
88655 ** be allocated for each FileChunk structure.
88669 ** This structure is a subclass of sqlite3_file. Each open memory-journal
88993 ** If the argument p points to a MemJournal structure that is not an
89275 ** prevents ExprDelete() from deleting the Expr structure itself,
89349 ** pExpr->pTab Points to the Table structure of X.Y (even if
91349 ** of any expression tree referenced by the structure passed as the
91385 structure passed as an
91786 ** Return the number of bytes allocated for the expression structure
91801 ** dupedExprStructSize() Size of only the Expr structure
91808 ** (1) the space required for a copy of the Expr structure only and
91809 ** (2) the EP_xxx flags that indicate what the structure size should be.
91816 ** The size of the structure can be found by masking the return value
91854 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
91907 /* Figure out where to write the new Expr structure. */
91918 /* Set nNewSize to the size allocated for the structure pointed to
92030 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
92031 ** truncated version of the usual Expr structure that will be stored as
95470 ** An instance of the following structure is used by the tree walker
95525 ** An instance of the following structure is used by the tree walker
95701 ** function that is already in the pAggInfo structure
96469 ** The Table structure pParse->pNewTable was extended to include
96600 ** This routine makes a (partial) copy of the Table structure
96604 ** the copy. The copy of the Table structure is deleted by tokenize.c
96952 ** share an instance of the following structure to hold their state
97049 ** Reclaim all memory of a Stat4Accum structure.
99027 ** Initialize a DbFixer structure. This routine must be called prior
99028 ** to passing the structure to one of the sqliteFixAAAA() routines below.
99052 ** was left unspecified in the original SQL statement. The pFix structure
99483 ** The TableLock structure is only used by the sqlite3TableLock() and
99580 ** VDBE program and resets the pParse structure for the next
99741 ** Locate the in-memory structure that describes a particular database
99784 ** Locate the in-memory structure that describes a particular database
99863 ** Locate the in-memory structure that describes
99942 ** db->aDb[] structure to a smaller size, if possible.
100043 ** This routine just deletes the data structure. It does not unlink
100044 ** the table data structure from the hash table. But it does destroy
100083 /* Delete the Table structure itself.
100108 ** table structure with all its indices and foreign keys.
100401 ** then record a pointer to this table in the main database structure
101271 ** The table structure that other action routines have been building
101597 ** The Table structure pTable is really a VIEW. Fill in the names of
101598 ** the columns of the view in the pTable structure. Return the number
102072 ** An FKey structure is created and added to the table currently
102316 nByte = ROUND8(sizeof(Index)) + /* Index structure */
102559 ** Allocate the index structure.
102762 /* Link the new Index structure to its table and to the other
103474 ** the number of errors. Leave any error messages in the pParse structure.
103801 ** Return a KeyInfo structure that is appropriate for the given Index.
103850 ** not, store an error in the Parse structure. */
104052 ** each collation sequence structure.
104233 ** pointer to the FuncDef structure that defines that function, or return
104237 ** structure is created and liked into the "db" structure if a
104285 ** install a new function. Whatever FuncDef structure is returned it will
104332 ** Free all resources held by the schema structure. The void* argument points
104613 sqlite3 *db; /* Main database structure */
104648 ** put in an SrcList structure because some of the subroutines we
105862 ** A structure defining how to do GLOB-style comparisons.
106096 ** This same function (with a different compareInfo structure) computes
106742 ** An instance of the following structure holds the context of a
106813 ** The following structure keeps track of state information for the
107020 ** the first three statements in the compareInfo structure. The
107287 ** sqlite3FkDelete() - Delete an FKey structure.
107822 ** to the FKey structure representing the foreign key constraint on table
107832 ** The second argument is a Trigger structure allocated by the
107833 ** fkActionTrigger() routine. This function deletes the Trigger structure
107836 ** The Trigger structure or any of its sub-components may be allocated from
108167 /* Create a SrcList structure containing the child table. We need the
108295 ** It returns a pointer to a Trigger structure containing a trigger
108307 ** then the returned trigger structure is equivalent to:
108640 ** is managed along with the rest of the Index structure. It will be
108647 ** a member of the Index structure for subsequent use.
108650 ** sqliteDeleteIndex() when the Index structure itself is cleaned
108772 ** Locate or create an AutoincInfo structure associated with table pTab
108778 ** There is at most one AutoincInfo structure per table even if the
108780 ** triggers. A new AutoincInfo structure is created if this is the
108782 ** AutoincInfo structure is used.
109056 sqlite3 *db; /* The main database structure */
111025 ** The following structure holds pointers to all of the SQLite API
111029 ** interfaces to the end of this structure only. If you insert new
111030 ** interfaces in the middle of this structure, then older different
111303 ** redirected through the global sqlite3_api structure.
111307 structure
111667 ** The following structure contains pointers to all SQLite API routines.
111668 ** A pointer to this structure is passed into extensions when they are
111672 ** When adding new APIs, add them to the bottom of this structure
115414 ** Fill the InitData structure with an error message that indicates
115747 ** bit is set in the flags field of the Db structure. If the database
116314 ** Delete all the content of a Select structure. Deallocate the structure
116336 ** Initialize a SelectDest structure.
116348 ** Allocate a new Select structure and return a pointer to that
116349 ** structure.
116420 ** Delete the given Select structure and all of its substructures.
116449 ** a join type, but put an error in the pParse structure.
116645 ** The terms of a FROM clause are contained in the Select.pSrc structure.
117334 ** Given an expression list, generate a KeyInfo structure that records
117338 ** KeyInfo structure is appropriate for initializing a virtual index to
117340 ** then the KeyInfo structure is appropriate for initializing a virtual
117343 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
117344 ** function is responsible for seeing that this structure is eventually
117410 ** in sqlite3Select() to assign values to structure member variables that
117649 Table *pTab = 0; /* Table structure column is extracted from */
118038 ** Given a SELECT statement, generate a Table structure that describes
118191 ** structure suitable for implementing the ORDER BY.
118193 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
118194 ** function is responsible for ensuring that this structure is eventually
118779 ** Attach the KeyInfo structure to all temporary tables.
119854 /* Delete the transient table structure associated with the
120117 ** Based on the contents of the AggInfo structure indicated by the first
120559 ** then create a transient table structure to describe the subquery.
120847 ** information to the Table structure that represents the result set
120850 ** The Table structure that represents the result set was constructed
120977 ** in the AggInfo structure.
121102 ** The results are returned according to the SelectDest structure.
121109 ** This routine does NOT free the Select structure passed in. The
121807 /* If isSimpleCount() returns a pointer to a Table structure, then
121812 ** where the Table structure returned represents table <tbl>.
121836 ** In practice the KeyInfo structure will not be used. It is only
121958 /* The SELECT has been coded. If there is an error in the Parse structure,
122008 ** This structure is used to pass data from sqlite3_get_table() through
122023 ** is to fill in the TabResult structure appropriately, allocating new
122260 ** structure is generated based on the information available and stored
122528 ** a trigger step. Return a pointer to a TriggerStep structure.
122647 ** Recursively delete a Trigger structure
122706 ** Return a pointer to the Table structure for the table that a trigger
122954 ** Parse context structure pFrom has just been used to create a sub-vdbe
123394 sqlite3 *db; /* The database structure */
124666 ** pTab is a pointer to a Table structure representing a virtual-table.
124805 ** Since it is a virtual-table, the Table structure contains a pointer
124807 ** structure is associated with a single sqlite3* user of the schema.
124808 ** The reference count of the VTable structure associated with database
124810 ** structure being xDisconnected and free). Any other VTable structures
125100 /* If everything went according to plan, link the new VTable structure
125381 ** the offset of the method to call in the sqlite3_module structure.
125560 ** new FuncDef structure that is marked as ephemeral using the
125805 ** This file contains structure and macro definitions for the query
125989 ** The query generator uses an array of instances of this structure to
125994 ** All WhereTerms are collected into a single WhereClause structure.
126024 ** but they do so indirectly. A single WhereMaskSet structure translates
126098 ** An instance of the following structure holds all information about a
126125 ** a dynamically allocated instance of the following structure.
126134 ** a dynamically allocated instance of the following structure.
126141 ** An instance of the following structure keeps track of a mapping
126148 ** use of the bits in our bitmasks. This structure provides a mapping
126156 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
126201 ** this structure is returned by the first half and passed
127078 ** structure.
128917 ** stored in a WhereClause structure containing within the WhereOrInfo
129269 structure with only the
129272 ** structure.
129679 ** operator specified in the op parameter. The WhereClause structure
129706 ** Initialize a preallocated WhereClause structure.
129720 ** Deallocate a WhereClause structure. The WhereClause structure
130391 ** structure. Used for testing and debugging only. If neither
130667 ** Allocate and populate an sqlite3_index_info structure. It is the
130668 ** responsibility of the caller to eventually release the structure
130707 ** the sqlite3_index_info structure.
130721 /* Allocate the sqlite3_index_info structure
130731 /* Initialize the structure. The sqlite3_index_info structure contains
130805 ** part of the sqlite3_index_info structure is left populated.
131404 ** in the pParse structure.
131468 ** in the pParse structure.
131685 ** Free a WhereInfo structure
132864 /* Initialize the output fields of the sqlite3_index_info structure */
134119 ** The return value is a pointer to an opaque structure that contains
134269 /* Allocate and initialize the WhereInfo structure that will become the
134271 ** struct, the contents of WhereInfo.a[], the WhereClause structure
134272 ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
134894 ** An instance of this structure holds information about the
134903 ** An instance of the following structure describes the event of a
135805 /* The following structure represents a single element of the
135831 ** the following structure */
138438 ** The first argument is a pointer to a structure obtained from
138447 ** <li> A pointer to the parser (an opaque structure.)
139373 ** Run the parser on the given SQL string. The parser structure is
139498 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
139499 ** will take responsibility for freeing the Table structure.
140320 ** sqlite3_mem_methods structure. The argument specifies alternative
140329 ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
141127 ** structure?
142771 /* Allocate the sqlite data structure */
144619 ** Since we're using a segmented structure, with no docid-oriented
144688 ** interface functions. This is essentially the class structure for
144716 ** sqlite3_tokenizer structure representing the specific tokenizer to
144732 ** Structure version. Should always be set to 0 or 1.
144749 ** to point at the newly created tokenizer structure. The generic
144867 /* A complete hash table is an instance of the following structure.
144868 ** The internals of this structure are intended to be opaque -- client
144869 ** code should not attempt to access or modify the fields of this structure
144870 ** directly. Change this structure only by using the routines below.
144872 ** accessing this structure are really macros, so we can't really make
144873 ** this structure opaque.
144888 ** structure. All elements are stored on a single doubly-linked list.
144890 ** Again, this structure is intended to be opaque, but it can't really
145122 ** structure. The xCreate and xConnect methods create an instance
145123 ** of this structure and xDestroy and xDisconnect free that instance.
145124 ** All other methods receive a pointer to the structure as one of their
145207 ** virtual table cursor (an instance of the following structure) using
145813 ** memory associated with the Fts3Table structure and return SQLITE_OK.
146360 sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
146590 /* Allocate and populate the Fts3Table structure. */
146630 /* Fill in the zName and zDb fields of the vtab structure. */
146918 /* Allocate a buffer large enough for an Fts3Cursor structure. If the
147063 ** Even if the data structure on disk is corrupted, this (reading two
151149 ** Free all components of the Fts3Phrase structure that were allocated by
151918 ** structure of type FTSQUERY_PHRASE containing a phrase consisting of this
151922 ** Fts3Expr structure (if any) by passing it to sqlite3_free().
152018 ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE
152022 ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
152042 /* The final Fts3Expr data structure, including the Fts3Phrase,
152051 ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase
152052 ** structure, followed by the array of Fts3PhraseToken
152138 ** structure, or set to 0 if the end of the input buffer is reached.
152292 ** The argument is an Fts3Expr structure for a binary operator (any type
152365 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
152719 Fts3Expr **ppExpr /* OUT: Parsed query structure */
152782 Fts3Expr **ppExpr, /* OUT: Parsed query structure */
153113 ** fields of the Hash structure.
154921 ** Virtual table structure.
154930 ** Virtual table cursor structure.
155424 ** An instance of the following data structure is used to build doclists
155448 ** An instance of this structure is used to iterate through the terms on
155450 ** this structure are only manipulated by code in this file, opaque handles
155504 ** An instance of this structure is used to create a segment b-tree in the
155513 SegmentNode *pTree; /* Pointer to interior tree structure */
155959 ** This function also serves to allocate the PendingList structure itself.
155960 ** For example, to create a new PendingList structure containing two
156003 ** Add a docid/column/position entry to a PendingList structure. Non-zero
156004 ** is returned if the structure is sqlite3_realloced as part of adding
156012 PendingList **pp, /* IN/OUT: PendingList structure */
156731 ** of these statements is untrue, then the data structure is corrupt.
157546 /* Allocate the SegmentWriter structure */
158950 ** An instance of the following structure is used as a dynamic buffer
158962 ** This structure is used to build up buffers containing segment b-tree
159036 ** NULL to indicate EOF. Otherwise, populate the NodeReader structure output
161109 ** An instance of this structure is used to manage a pair of buffers, each
161124 ** of the following structure is used to accumulate those values while the
161514 ** The selected snippet parameters are stored in structure *pFragment before
161947 void *pCtx /* Pointer to MatchInfo structure */
161963 void *pCtx /* Pointer to MatchInfo structure */
162064 ** An instance of the following structure is used to store state while
162086 void *pCtx /* Pointer to MatchInfo structure */
163097 ** structure for the unicode tokenizer.
163503 ** The data structure for a single virtual r-tree table is stored in three
163512 ** The data for each node of the r-tree structure is stored in the %_node
163607 int iDepth; /* Current depth of the r-tree structure */
163610 u32 nBusy; /* Current number of users of this structure */
163662 ** When doing a search of an r-tree, instances of the following structure
163695 ** 2^40 is greater than 2^64, an r-tree structure always has a depth of
163743 ** variable pRtree points to the Rtree structure associated with the
163781 ** An rtree structure node.
163834 ** An instance of this structure (in the form of a BLOB) is returned by
164105 Rtree *pRtree, /* R-tree structure */
164168 ** of the r-tree structure. A height of zero means all data is stored on
164171 ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
164340 ** Deserialize cell iCell of node pNode. Populate the structure pointed
164406 ** zero the structure is deleted.
166144 ** cell, adjust the r-tree data structure if required.
166357 ** Remove the entry with rowid=iDelete from the r-tree structure.
166363 RtreeNode *pRoot; /* Root node of rtree structure */
166617 ** the r-tree structure.
166943 /* Allocate the sqlite3_vtab structure */
167012 ** an r-tree node. For a two-dimensional r-tree structure called "rt", to
167669 ** a UCollator structure previously allocated using ucol_open().
167678 ** a UCollator structure previously allocated using ucol_open().
168850 ** A structure to store values read from the rbu_state table in memory.
169035 ** An rbu VFS is implemented using an instance of this structure.
169046 ** the following structure.
169568 ** Initialize the iterator structure passed as the second argument.
173490 ** root-node of the b-tree structure to each page. The value of the
174201 ** Session handle structure.
174218 ** Instances of this structure are used to build strings or binary records.
174246 ** Structure for changeset iterators.
174271 ** The data associated with each hash-table entry is a structure containing
174411 ** this structure stored in a SessionTable.aChange[] hash table.
174559 ** order to use this macro, the entire data structure must be represented
174561 ** for a data structure represented as three such integers, the macro may
176297 SessionChange *pChange /* Change structure */
176621 /* Allocate and initialize the iterator structure. */
177116 ** It sets *ppValue to point to an sqlite3_value structure containing the
177144 ** It sets *ppValue to point to an sqlite3_value structure containing the
177180 ** If successful, *ppValue is set to point to an sqlite3_value structure
177456 ** structure like this:
177525 ** Assuming a table structure like this:
177621 ** key. Assuming the following table structure:
178381 SessionTable *pTab, /* Table structure */
181406 ** The Fts5PhraseIter structure is defined above. Applications should not
181407 ** modify this structure directly - it should only be used as shown above
181498 ** following structure. All structure methods must be defined, setting
181500 ** behaviour. The structure methods are expected to function as follows:
181886 ** An instance of the following structure encodes all information that can
182848 /* The following structure represents a single element of the
182874 ** the following structure */
183673 ** The first argument is a pointer to a structure obtained from
183682 ** <li> A pointer to the parser (an opaque structure.)
184365 ** of the following structure is allocated and populated.
184687 ** Free any buffer allocated by pBuf. Zero the structure before returning.
185993 ** An instance of the following structure represents a single search term
188679 ** structure.
188690 int nData; /* Total bytes of data (incl. structure) */
189194 ** * extra fields in the "structure record" record the state of ongoing
189222 ** 1. Structure Records:
189224 ** The set of segments that make up an index - the index structure - are
189365 ** Rowids for the averages and structure records in the %_data table.
189368 #define FTS5_STRUCTURE_ROWID 10 /* The structure record */
189464 Fts5Structure *pStruct; /* Current db structure (or NULL) */
189478 ** The contents of the "structure" record for each index are represented
189495 int nSegment; /* Total segments in this structure */
189621 ** Argument is a pointer to an Fts5Data structure that contains a
189632 ** Argument is a pointer to an Fts5Data structure that contains a leaf
189669 Fts5Structure *pStruct; /* Database structure for this iterator */
189991 ** Deserialize and return the structure record currently stored in serialized
189995 ** are over-allocated by one slot. This allows the structure contents
190003 const u8 *pData, /* Buffer containing serialized structure */
190014 Fts5Structure *pRet = 0; /* Structure object to return */
190021 ** structure record. */
190025 sizeof(Fts5Structure) + /* Main structure */
190083 sizeof(Fts5Structure) + /* Main structure */
190176 ** Read, deserialize and return the structure record.
190233 ** Return the total number of segments in index structure pStruct. This
190263 ** Serialize and store the "structure" record.
190328 ** Return a copy of index structure pStruct. Except, promote as many
190359 ** A new segment has just been written to level iLvl of index structure
190372 ** If one or more segments are promoted, the structure object is updated
190378 Fts5Structure *pStruct /* Index structure */
192507 ** The new object will be used to iterate through data in structure pStruct.
192517 Fts5Structure *pStruct, /* Structure of specific index */
192702 ** Allocate a new segment-id for the structure pStruct. The new segment
193481 Fts5Structure **ppStruct, /* IN/OUT: Current structure of index */
193540 Fts5Structure **ppStruct, /* IN/OUT: Current structure of index */
193561 Fts5Structure **ppStruct /* IN/OUT: Current structure of index */
193610 ** segment on disk. Also update the corresponding structure record.
193621 /* Obtain a reference to the index structure and allocate a new segment-id
193785 /* Figure out if this structure requires optimization. A structure does
193821 ** segment in the data structure. */
194311 ** function populates it with the initial structure objects for each index,
194661 ** Set the 32-bit cookie value stored at the start of all structure
195105 Fts5Structure *pStruct; /* Index structure */
195114 /* Load the FTS index structure */
195218 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{structure}");
195263 Fts5Structure *p = 0; /* Decoded structure object */
195708 ** structure is used to record the current transaction state. This information
196008 sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
196631 ** structure. Otherwise, if no such function exists, return NULL.
198950 /* Reinitialize the %_data table. This call creates the initial structure
201617 sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
