blob: 59f0a2557701044910764f88132e1329950ad441 [file] [log] [blame]
drh75897232000-05-29 14:26:00 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drh75897232000-05-29 14:26:00 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh75897232000-05-29 14:26:00 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
drh75897232000-05-29 14:26:00 +000010**
11*************************************************************************
12** Internal interface definitions for SQLite.
13**
drh382c0242001-10-06 16:33:02 +000014** @(#) $Id: sqliteInt.h,v 1.57 2001/10/06 16:33:03 drh Exp $
drh75897232000-05-29 14:26:00 +000015*/
16#include "sqlite.h"
drhbeae3192001-09-22 18:12:08 +000017#include "hash.h"
drh75897232000-05-29 14:26:00 +000018#include "vdbe.h"
19#include "parse.h"
drhbe0072d2001-09-13 14:46:09 +000020#include "btree.h"
drh75897232000-05-29 14:26:00 +000021#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24#include <assert.h>
25
drh967e8b72000-06-21 13:59:10 +000026/*
drha1b351a2001-09-14 16:42:12 +000027** The maximum number of in-memory pages to use for the main database
28** table and for temporary tables.
29*/
drhf57b14a2001-09-14 18:54:08 +000030#define MAX_PAGES 100
31#define TEMP_PAGES 25
drha1b351a2001-09-14 16:42:12 +000032
33/*
drh092d0352001-09-15 13:15:12 +000034** Integers of known sizes. These typedefs much change for architectures
35** where the sizes very.
drh41a2b482001-01-20 19:52:49 +000036*/
drh092d0352001-09-15 13:15:12 +000037typedef unsigned int u32; /* 4-byte unsigned integer */
38typedef unsigned short int u16; /* 2-byte unsigned integer */
39typedef unsigned char u8; /* 1-byte unsigned integer */
drh41a2b482001-01-20 19:52:49 +000040
41/*
drh872ff862001-09-15 14:43:39 +000042** The maximum number of bytes of data that can be put into a single
43** row of a single table.
44*/
45#define MAX_BYTES_PER_ROW 65535
46
47/*
drh967e8b72000-06-21 13:59:10 +000048** If memory allocation problems are found, recompile with
49**
50** -DMEMORY_DEBUG=1
51**
52** to enable some sanity checking on malloc() and free(). To
53** check for memory leaks, recompile with
54**
55** -DMEMORY_DEBUG=2
56**
57** and a line of text will be written to standard error for
58** each malloc() and free(). This output can be analyzed
59** by an AWK script to determine if there are any leaks.
60*/
drhdcc581c2000-05-30 13:44:19 +000061#ifdef MEMORY_DEBUG
62# define sqliteMalloc(X) sqliteMalloc_(X,__FILE__,__LINE__)
63# define sqliteFree(X) sqliteFree_(X,__FILE__,__LINE__)
64# define sqliteRealloc(X,Y) sqliteRealloc_(X,Y,__FILE__,__LINE__)
drh6e142f52000-06-08 13:36:40 +000065# define sqliteStrDup(X) sqliteStrDup_(X,__FILE__,__LINE__)
66# define sqliteStrNDup(X,Y) sqliteStrNDup_(X,Y,__FILE__,__LINE__)
drhc3c2fc92000-05-31 22:58:39 +000067 void sqliteStrRealloc(char**);
68#else
69# define sqliteStrRealloc(X)
drhdcc581c2000-05-30 13:44:19 +000070#endif
71
drh75897232000-05-29 14:26:00 +000072/*
drhdaffd0e2001-04-11 14:28:42 +000073** This variable gets set if malloc() ever fails. After it gets set,
74** the SQLite library shuts down permanently.
75*/
76extern int sqlite_malloc_failed;
77
78/*
drh6e142f52000-06-08 13:36:40 +000079** The following global variables are used for testing and debugging
drh8c82b352000-12-10 18:23:50 +000080** only. They only work if MEMORY_DEBUG is defined.
drh6e142f52000-06-08 13:36:40 +000081*/
82#ifdef MEMORY_DEBUG
drh8c82b352000-12-10 18:23:50 +000083extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */
84extern int sqlite_nFree; /* Number of sqliteFree() calls */
85extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */
drh6e142f52000-06-08 13:36:40 +000086#endif
87
88/*
drh967e8b72000-06-21 13:59:10 +000089** The number of entries in the in-memory hash array holding the
drh8c82b352000-12-10 18:23:50 +000090** database schema. (Collision resolution is by chaining, so the
91** table will hold more than this many entries.)
drh75897232000-05-29 14:26:00 +000092*/
93#define N_HASH 51
94
95/*
96** Name of the master database table. The master database table
97** is a special table that holds the names and attributes of all
98** user tables and indices.
99*/
100#define MASTER_NAME "sqlite_master"
101
102/*
103** A convenience macro that returns the number of elements in
104** an array.
105*/
106#define ArraySize(X) (sizeof(X)/sizeof(X[0]))
107
108/*
drh967e8b72000-06-21 13:59:10 +0000109** Integer identifiers for built-in SQL functions.
drhcce7d172000-05-31 15:34:51 +0000110*/
111#define FN_Unknown 0
112#define FN_Count 1
113#define FN_Min 2
114#define FN_Max 3
115#define FN_Sum 4
116#define FN_Avg 5
drh0bdaf622000-06-11 23:50:13 +0000117#define FN_Fcnt 6
drh6ec27332000-08-28 15:51:43 +0000118#define FN_Length 7
119#define FN_Substr 8
drhcce7d172000-05-31 15:34:51 +0000120
121/*
drh75897232000-05-29 14:26:00 +0000122** Forward references to structures
123*/
drh7020f652000-06-03 18:06:52 +0000124typedef struct Column Column;
drh75897232000-05-29 14:26:00 +0000125typedef struct Table Table;
126typedef struct Index Index;
127typedef struct Instruction Instruction;
128typedef struct Expr Expr;
129typedef struct ExprList ExprList;
130typedef struct Parse Parse;
131typedef struct Token Token;
132typedef struct IdList IdList;
133typedef struct WhereInfo WhereInfo;
drh9bb61fe2000-06-05 16:01:39 +0000134typedef struct Select Select;
drh22827922000-06-06 17:27:05 +0000135typedef struct AggExpr AggExpr;
drh75897232000-05-29 14:26:00 +0000136
137/*
138** Each database is an instance of the following structure
139*/
140struct sqlite {
drh5e00f6c2001-09-13 13:46:56 +0000141 Btree *pBe; /* The B*Tree backend */
142 int flags; /* Miscellanous flags. See below */
143 int file_format; /* What file format version is this database? */
drh50e5dad2001-09-15 00:57:28 +0000144 int schema_cookie; /* Magic number that changes with the schema */
145 int next_cookie; /* Value of schema_cookie after commit */
drh5e00f6c2001-09-13 13:46:56 +0000146 int nTable; /* Number of tables in the database */
147 void *pBusyArg; /* 1st Argument to the busy callback */
drh353f57e2000-08-02 12:26:28 +0000148 int (*xBusyCallback)(void *,const char*,int); /* The busy callback */
drhbeae3192001-09-22 18:12:08 +0000149 Hash tblHash; /* All tables indexed by name */
150 Hash idxHash; /* All (named) indices indexed by name */
drh90bfcda2001-09-23 19:46:51 +0000151 struct { /* State of the RC4 random number generator */
152 int isInit; /* True if initialized */
153 int i, j; /* State variables */
154 int s[256]; /* State variables */
155 } prng;
156 int nextRowid; /* Next generated rowID */
drh75897232000-05-29 14:26:00 +0000157};
158
159/*
drh967e8b72000-06-21 13:59:10 +0000160** Possible values for the sqlite.flags.
drh75897232000-05-29 14:26:00 +0000161*/
drh5e00f6c2001-09-13 13:46:56 +0000162#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */
163#define SQLITE_Initialized 0x00000002 /* True after initialization */
164#define SQLITE_Interrupt 0x00000004 /* Cancel current operation */
165#define SQLITE_InTrans 0x00000008 /* True if in a transaction */
166#define SQLITE_InternChanges 0x00000010 /* Uncommitted Hash table changes */
drh382c0242001-10-06 16:33:02 +0000167#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */
drh58b95762000-06-02 01:17:37 +0000168
169/*
drh28037572000-08-02 13:47:41 +0000170** Current file format version
171*/
172#define SQLITE_FileFormat 2
173
174/*
drh967e8b72000-06-21 13:59:10 +0000175** information about each column of an SQL table is held in an instance
drh7020f652000-06-03 18:06:52 +0000176** of this structure.
177*/
178struct Column {
drh967e8b72000-06-21 13:59:10 +0000179 char *zName; /* Name of this column */
180 char *zDflt; /* Default value of this column */
drh382c0242001-10-06 16:33:02 +0000181 char *zType; /* Data type for this column */
drh967e8b72000-06-21 13:59:10 +0000182 int notNull; /* True if there is a NOT NULL constraint */
drh7020f652000-06-03 18:06:52 +0000183};
184
185/*
drh967e8b72000-06-21 13:59:10 +0000186** Each SQL table is represented in memory by
187** an instance of the following structure.
drh75897232000-05-29 14:26:00 +0000188*/
189struct Table {
drh967e8b72000-06-21 13:59:10 +0000190 char *zName; /* Name of the table */
drh967e8b72000-06-21 13:59:10 +0000191 int nCol; /* Number of columns in this table */
192 Column *aCol; /* Information about each column */
drh967e8b72000-06-21 13:59:10 +0000193 Index *pIndex; /* List of SQL indexes on this table. */
drh5e00f6c2001-09-13 13:46:56 +0000194 int tnum; /* Page containing root for this table */
drh717e6402001-09-27 03:22:32 +0000195 u8 readOnly; /* True if this table should not be written by the user */
196 u8 isCommit; /* True if creation of this table has been committed */
197 u8 isDelete; /* True if this table is being deleted */
drh75897232000-05-29 14:26:00 +0000198};
199
200/*
drh66b89c82000-11-28 20:47:17 +0000201** Each SQL index is represented in memory by an
drh75897232000-05-29 14:26:00 +0000202** instance of the following structure.
drh967e8b72000-06-21 13:59:10 +0000203**
204** The columns of the table that are to be indexed are described
205** by the aiColumn[] field of this structure. For example, suppose
206** we have the following table and index:
207**
208** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
209** CREATE INDEX Ex2 ON Ex1(c3,c1);
210**
211** In the Table structure describing Ex1, nCol==3 because there are
212** three columns in the table. In the Index structure describing
213** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
214** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
215** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
216** The second column to be indexed (c1) has an index of 0 in
217** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
drh75897232000-05-29 14:26:00 +0000218*/
219struct Index {
drh967e8b72000-06-21 13:59:10 +0000220 char *zName; /* Name of this index */
drh967e8b72000-06-21 13:59:10 +0000221 int nColumn; /* Number of columns in the table used by this index */
222 int *aiColumn; /* Which columns are used by this index. 1st is 0 */
223 Table *pTable; /* The SQL table being indexed */
drhbe0072d2001-09-13 14:46:09 +0000224 int tnum; /* Page containing root of this index in database file */
drh717e6402001-09-27 03:22:32 +0000225 u8 isUnique; /* True if keys must all be unique */
226 u8 isCommit; /* True if creation of this index has been committed */
227 u8 isDelete; /* True if deletion of this index has not been comitted */
drh967e8b72000-06-21 13:59:10 +0000228 Index *pNext; /* The next index associated with the same table */
drh75897232000-05-29 14:26:00 +0000229};
230
231/*
232** Each token coming out of the lexer is an instance of
233** this structure.
234*/
235struct Token {
drh66b89c82000-11-28 20:47:17 +0000236 char *z; /* Text of the token. Not NULL-terminated! */
drh75897232000-05-29 14:26:00 +0000237 int n; /* Number of characters in this token */
238};
239
240/*
241** Each node of an expression in the parse tree is an instance
242** of this structure
243*/
244struct Expr {
245 int op; /* Operation performed by this node */
246 Expr *pLeft, *pRight; /* Left and right subnodes */
247 ExprList *pList; /* A list of expressions used as a function argument */
248 Token token; /* An operand token */
drhe1b6a5b2000-07-29 13:06:59 +0000249 Token span; /* Complete text of the expression */
drh967e8b72000-06-21 13:59:10 +0000250 int iTable, iColumn; /* When op==TK_COLUMN, then this expr node means the
251 ** iColumn-th field of the iTable-th table. When
252 ** op==TK_FUNCTION, iColumn holds the function id */
253 int iAgg; /* When op==TK_COLUMN and pParse->useAgg==TRUE, pull
254 ** result from the iAgg-th element of the aggregator */
drh19a775c2000-06-05 18:54:46 +0000255 Select *pSelect; /* When the expression is a sub-select */
drh75897232000-05-29 14:26:00 +0000256};
257
258/*
259** A list of expressions. Each expression may optionally have a
260** name. An expr/name combination can be used in several ways, such
261** as the list of "expr AS ID" fields following a "SELECT" or in the
262** list of "ID = expr" items in an UPDATE. A list of expressions can
263** also be used as the argument to a function, in which case the azName
264** field is not used.
265*/
266struct ExprList {
267 int nExpr; /* Number of expressions on the list */
268 struct {
269 Expr *pExpr; /* The list of expressions */
270 char *zName; /* Token associated with this expression */
drhd8bc7082000-06-07 23:51:50 +0000271 char sortOrder; /* 1 for DESC or 0 for ASC */
272 char isAgg; /* True if this is an aggregate like count(*) */
273 char done; /* A flag to indicate when processing is finished */
drh75897232000-05-29 14:26:00 +0000274 } *a; /* One entry for each expression */
275};
276
277/*
278** A list of identifiers.
279*/
280struct IdList {
281 int nId; /* Number of identifiers on the list */
282 struct {
283 char *zName; /* Text of the identifier. */
284 char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
drh967e8b72000-06-21 13:59:10 +0000285 int idx; /* Index in some Table.aCol[] of a column named zName */
drhdaffd0e2001-04-11 14:28:42 +0000286 Table *pTab; /* An SQL table corresponding to zName */
287 Select *pSelect; /* A SELECT statement used in place of a table name */
drh75897232000-05-29 14:26:00 +0000288 } *a; /* One entry for each identifier on the list */
289};
290
291/*
292** The WHERE clause processing routine has two halves. The
293** first part does the start of the WHERE loop and the second
294** half does the tail of the WHERE loop. An instance of
295** this structure is returned by the first half and passed
296** into the second half to give some continuity.
297*/
298struct WhereInfo {
299 Parse *pParse;
drh19a775c2000-06-05 18:54:46 +0000300 IdList *pTabList; /* List of tables in the join */
301 int iContinue; /* Jump here to continue with next record */
302 int iBreak; /* Jump here to break out of the loop */
303 int base; /* Index of first Open opcode */
304 Index *aIdx[32]; /* Indices used for each table */
drh75897232000-05-29 14:26:00 +0000305};
306
307/*
drh9bb61fe2000-06-05 16:01:39 +0000308** An instance of the following structure contains all information
309** needed to generate code for a single SELECT statement.
310*/
311struct Select {
312 int isDistinct; /* True if the DISTINCT keyword is present */
313 ExprList *pEList; /* The fields of the result */
314 IdList *pSrc; /* The FROM clause */
315 Expr *pWhere; /* The WHERE clause */
316 ExprList *pGroupBy; /* The GROUP BY clause */
317 Expr *pHaving; /* The HAVING clause */
318 ExprList *pOrderBy; /* The ORDER BY clause */
drh82c3d632000-06-06 21:56:07 +0000319 int op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
drh967e8b72000-06-21 13:59:10 +0000320 Select *pPrior; /* Prior select in a compound select statement */
drh9bb61fe2000-06-05 16:01:39 +0000321};
322
323/*
drhfef52082000-06-06 01:50:43 +0000324** The results of a select can be distributed in several ways.
325*/
326#define SRT_Callback 1 /* Invoke a callback with each row of result */
327#define SRT_Mem 2 /* Store result in a memory cell */
drh82c3d632000-06-06 21:56:07 +0000328#define SRT_Set 3 /* Store result as unique keys in a table */
329#define SRT_Union 5 /* Store result as keys in a table */
330#define SRT_Except 6 /* Remove result from a UNION table */
drh5974a302000-06-07 14:42:26 +0000331#define SRT_Table 7 /* Store result as data with a unique key */
drhfef52082000-06-06 01:50:43 +0000332
333/*
drh22827922000-06-06 17:27:05 +0000334** When a SELECT uses aggregate functions (like "count(*)" or "avg(f1)")
335** we have to do some additional analysis of expressions. An instance
336** of the following structure holds information about a single subexpression
337** somewhere in the SELECT statement. An array of these structures holds
338** all the information we need to generate code for aggregate
339** expressions.
340**
341** Note that when analyzing a SELECT containing aggregates, both
342** non-aggregate field variables and aggregate functions are stored
343** in the AggExpr array of the Parser structure.
344**
345** The pExpr field points to an expression that is part of either the
346** field list, the GROUP BY clause, the HAVING clause or the ORDER BY
347** clause. The expression will be freed when those clauses are cleaned
348** up. Do not try to delete the expression attached to AggExpr.pExpr.
349**
350** If AggExpr.pExpr==0, that means the expression is "count(*)".
351*/
352struct AggExpr {
353 int isAgg; /* if TRUE contains an aggregate function */
354 Expr *pExpr; /* The expression */
355};
356
357/*
drh75897232000-05-29 14:26:00 +0000358** An SQL parser context
359*/
360struct Parse {
361 sqlite *db; /* The main database structure */
drh5e00f6c2001-09-13 13:46:56 +0000362 Btree *pBe; /* The database backend */
drh4c504392000-10-16 22:06:40 +0000363 int rc; /* Return code from execution */
drh75897232000-05-29 14:26:00 +0000364 sqlite_callback xCallback; /* The callback function */
365 void *pArg; /* First argument to the callback function */
366 char *zErrMsg; /* An error message */
367 Token sErrToken; /* The token at which the error occurred */
368 Token sFirstToken; /* The first token parsed */
369 Token sLastToken; /* The last token parsed */
370 Table *pNewTable; /* A table being constructed by CREATE TABLE */
371 Vdbe *pVdbe; /* An engine for executing database bytecode */
drhd8bc7082000-06-07 23:51:50 +0000372 int colNamesSet; /* TRUE after OP_ColumnCount has been issued to pVdbe */
drh75897232000-05-29 14:26:00 +0000373 int explain; /* True if the EXPLAIN flag is found on the query */
374 int initFlag; /* True if reparsing CREATE TABLEs */
drhd78eeee2001-09-13 16:18:53 +0000375 int newTnum; /* Table number to use when reparsing CREATE TABLEs */
drhe3c41372001-09-17 20:25:58 +0000376 int newKnum; /* Primary key number when reparsing CREATE TABLEs */
drh75897232000-05-29 14:26:00 +0000377 int nErr; /* Number of errors seen */
drh19a775c2000-06-05 18:54:46 +0000378 int nTab; /* Number of previously allocated cursors */
379 int nMem; /* Number of memory cells used so far */
drhfef52082000-06-06 01:50:43 +0000380 int nSet; /* Number of sets used so far */
drh22827922000-06-06 17:27:05 +0000381 int nAgg; /* Number of aggregate expressions */
382 AggExpr *aAgg; /* An array of aggregate expressions */
383 int iAggCount; /* Index of the count(*) aggregate in aAgg[] */
384 int useAgg; /* If true, extract field values from the aggregator
385 ** while generating expressions. Normally false */
drh50e5dad2001-09-15 00:57:28 +0000386 int schemaVerified; /* True if an OP_VerifySchema has been coded someplace
387 ** other than after an OP_Transaction */
drh75897232000-05-29 14:26:00 +0000388};
389
390/*
391** Internal function prototypes
392*/
393int sqliteStrICmp(const char *, const char *);
394int sqliteStrNICmp(const char *, const char *, int);
395int sqliteHashNoCase(const char *, int);
396int sqliteCompare(const char *, const char *);
397int sqliteSortCompare(const char *, const char *);
drhdcc581c2000-05-30 13:44:19 +0000398#ifdef MEMORY_DEBUG
399 void *sqliteMalloc_(int,char*,int);
400 void sqliteFree_(void*,char*,int);
401 void *sqliteRealloc_(void*,int,char*,int);
drh6e142f52000-06-08 13:36:40 +0000402 char *sqliteStrDup_(const char*,char*,int);
403 char *sqliteStrNDup_(const char*, int,char*,int);
drhdcc581c2000-05-30 13:44:19 +0000404#else
405 void *sqliteMalloc(int);
406 void sqliteFree(void*);
407 void *sqliteRealloc(void*,int);
drh6e142f52000-06-08 13:36:40 +0000408 char *sqliteStrDup(const char*);
409 char *sqliteStrNDup(const char*, int);
drhdcc581c2000-05-30 13:44:19 +0000410#endif
drh75897232000-05-29 14:26:00 +0000411int sqliteGetToken(const char*, int *);
412void sqliteSetString(char **, const char *, ...);
413void sqliteSetNString(char **, ...);
drh982cef72000-05-30 16:27:03 +0000414void sqliteDequote(char*);
drh75897232000-05-29 14:26:00 +0000415int sqliteRunParser(Parse*, char*, char **);
416void sqliteExec(Parse*);
417Expr *sqliteExpr(int, Expr*, Expr*, Token*);
drhe1b6a5b2000-07-29 13:06:59 +0000418void sqliteExprSpan(Expr*,Token*,Token*);
drh75897232000-05-29 14:26:00 +0000419Expr *sqliteExprFunction(ExprList*, Token*);
420void sqliteExprDelete(Expr*);
421ExprList *sqliteExprListAppend(ExprList*,Expr*,Token*);
422void sqliteExprListDelete(ExprList*);
drhf57b14a2001-09-14 18:54:08 +0000423void sqlitePragma(Parse*,Token*,Token*,int);
drh5e00f6c2001-09-13 13:46:56 +0000424void sqliteCommitInternalChanges(sqlite*);
425void sqliteRollbackInternalChanges(sqlite*);
drh75897232000-05-29 14:26:00 +0000426void sqliteStartTable(Parse*,Token*,Token*);
427void sqliteAddColumn(Parse*,Token*);
drh382c0242001-10-06 16:33:02 +0000428void sqliteAddNotNull(Parse*);
429void sqliteAddColumnType(Parse*,Token*,Token*);
drh7020f652000-06-03 18:06:52 +0000430void sqliteAddDefaultValue(Parse*,Token*,int);
drh75897232000-05-29 14:26:00 +0000431void sqliteEndTable(Parse*,Token*);
432void sqliteDropTable(Parse*, Token*);
433void sqliteDeleteTable(sqlite*, Table*);
drh5974a302000-06-07 14:42:26 +0000434void sqliteInsert(Parse*, Token*, ExprList*, Select*, IdList*);
drh75897232000-05-29 14:26:00 +0000435IdList *sqliteIdListAppend(IdList*, Token*);
436void sqliteIdListAddAlias(IdList*, Token*);
437void sqliteIdListDelete(IdList*);
drh717e6402001-09-27 03:22:32 +0000438void sqliteCreateIndex(Parse*, Token*, Token*, IdList*, int, Token*, Token*);
drh75897232000-05-29 14:26:00 +0000439void sqliteDropIndex(Parse*, Token*);
drh19a775c2000-06-05 18:54:46 +0000440int sqliteSelect(Parse*, Select*, int, int);
drh9bb61fe2000-06-05 16:01:39 +0000441Select *sqliteSelectNew(ExprList*,IdList*,Expr*,ExprList*,Expr*,ExprList*,int);
442void sqliteSelectDelete(Select*);
drh75897232000-05-29 14:26:00 +0000443void sqliteDeleteFrom(Parse*, Token*, Expr*);
444void sqliteUpdate(Parse*, Token*, ExprList*, Expr*);
445WhereInfo *sqliteWhereBegin(Parse*, IdList*, Expr*, int);
446void sqliteWhereEnd(WhereInfo*);
447void sqliteExprCode(Parse*, Expr*);
448void sqliteExprIfTrue(Parse*, Expr*, int);
449void sqliteExprIfFalse(Parse*, Expr*, int);
450Table *sqliteFindTable(sqlite*,char*);
drhadbca9c2001-09-27 15:11:53 +0000451Index *sqliteFindIndex(sqlite*,char*);
drh982cef72000-05-30 16:27:03 +0000452void sqliteCopy(Parse*, Token*, Token*, Token*);
drhdce2cbe2000-05-31 02:27:49 +0000453void sqliteVacuum(Parse*, Token*);
drhe17a7e32001-04-04 21:10:18 +0000454int sqliteGlobCompare(const unsigned char*,const unsigned char*);
drhdce2cbe2000-05-31 02:27:49 +0000455int sqliteLikeCompare(const unsigned char*,const unsigned char*);
drhcce7d172000-05-31 15:34:51 +0000456char *sqliteTableNameFromToken(Token*);
457int sqliteExprCheck(Parse*, Expr*, int, int*);
drhd8bc7082000-06-07 23:51:50 +0000458int sqliteExprCompare(Expr*, Expr*);
drhcce7d172000-05-31 15:34:51 +0000459int sqliteFuncId(Token*);
drhbed86902000-06-02 13:27:59 +0000460int sqliteExprResolveIds(Parse*, IdList*, Expr*);
drh4794b982000-06-06 13:54:14 +0000461void sqliteExprResolveInSelect(Parse*, Expr*);
drh22827922000-06-06 17:27:05 +0000462int sqliteExprAnalyzeAggregates(Parse*, Expr*);
drhd8bc7082000-06-07 23:51:50 +0000463void sqliteParseInfoReset(Parse*);
464Vdbe *sqliteGetVdbe(Parse*);
drh90bfcda2001-09-23 19:46:51 +0000465int sqliteRandomByte(sqlite*);
466int sqliteRandomInteger(sqlite*);
drhc4a3c772001-04-04 11:48:57 +0000467void sqliteBeginTransaction(Parse*);
468void sqliteCommitTransaction(Parse*);
469void sqliteRollbackTransaction(Parse*);
drhd1bf3512001-04-07 15:24:33 +0000470char *sqlite_mprintf(const char *, ...);