mirror of
https://github.com/php/php-src.git
synced 2025-08-20 01:14:28 +02:00
Update bundled library to version 2.8.2.
Make OnUpdateInt compatible with ZE2. Fix the makefile fragment for non-gnu makes
This commit is contained in:
Wez Furlong
parent
82a1818fde
commit
80e7f7001d
42 changed files with 11143 additions and 7558 deletions
|
|
@ -57,6 +57,37 @@
|
|||
*/
|
||||
#define NULL_DISTINCT_FOR_UNIQUE 1
|
||||
|
||||
/*
|
||||
** The maximum number of attached databases. This must be at least 2
|
||||
** in order to support the main database file (0) and the file used to
|
||||
** hold temporary tables (1). And it must be less than 256 because
|
||||
** an unsigned character is used to stored the database index.
|
||||
*/
|
||||
#define MAX_ATTACHED 10
|
||||
|
||||
/*
|
||||
** The next macro is used to determine where TEMP tables and indices
|
||||
** are stored. Possible values:
|
||||
**
|
||||
** 0 Always use a temporary files
|
||||
** 1 Use a file unless overridden by "PRAGMA temp_store"
|
||||
** 2 Use memory unless overridden by "PRAGMA temp_store"
|
||||
** 3 Always use memory
|
||||
*/
|
||||
#ifndef TEMP_STORE
|
||||
# define TEMP_STORE 1
|
||||
#endif
|
||||
|
||||
/*
|
||||
** When building SQLite for embedded systems where memory is scarce,
|
||||
** you can define one or more of the following macros to omit extra
|
||||
** features of the library and thus keep the size of the library to
|
||||
** a minimum.
|
||||
*/
|
||||
/* #define SQLITE_OMIT_AUTHORIZATION 1 */
|
||||
/* #define SQLITE_OMIT_INMEMORYDB 1 */
|
||||
/* #define SQLITE_OMIT_VACUUM 1 */
|
||||
|
||||
/*
|
||||
** Integers of known sizes. These typedefs might change for architectures
|
||||
** where the sizes very. Preprocessor macros are available so that the
|
||||
|
|
@ -187,6 +218,59 @@ typedef struct Trigger Trigger;
|
|||
typedef struct TriggerStep TriggerStep;
|
||||
typedef struct TriggerStack TriggerStack;
|
||||
typedef struct FKey FKey;
|
||||
typedef struct Db Db;
|
||||
typedef struct AuthContext AuthContext;
|
||||
|
||||
/*
|
||||
** Each database file to be accessed by the system is an instance
|
||||
** of the following structure. There are normally two of these structures
|
||||
** in the sqlite.aDb[] array. aDb[0] is the main database file and
|
||||
** aDb[1] is the database file used to hold temporary tables. Additional
|
||||
** databases may be attached.
|
||||
*/
|
||||
struct Db {
|
||||
char *zName; /* Name of this database */
|
||||
Btree *pBt; /* The B*Tree structure for this database file */
|
||||
int schema_cookie; /* Database schema version number for this file */
|
||||
Hash tblHash; /* All tables indexed by name */
|
||||
Hash idxHash; /* All (named) indices indexed by name */
|
||||
Hash trigHash; /* All triggers indexed by name */
|
||||
Hash aFKey; /* Foreign keys indexed by to-table */
|
||||
u8 inTrans; /* True if a transaction is underway for this backend */
|
||||
u16 flags; /* Flags associated with this database */
|
||||
};
|
||||
|
||||
/*
|
||||
** These macros can be used to test, set, or clear bits in the
|
||||
** Db.flags field.
|
||||
*/
|
||||
#define DbHasProperty(D,I,P) (((D)->aDb[I].flags&(P))==(P))
|
||||
#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].flags&(P))!=0)
|
||||
#define DbSetProperty(D,I,P) (D)->aDb[I].flags|=(P)
|
||||
#define DbClearProperty(D,I,P) (D)->aDb[I].flags&=~(P)
|
||||
|
||||
/*
|
||||
** Allowed values for the DB.flags field.
|
||||
**
|
||||
** The DB_Locked flag is set when the first OP_Transaction or OP_Checkpoint
|
||||
** opcode is emitted for a database. This prevents multiple occurances
|
||||
** of those opcodes for the same database in the same program. Similarly,
|
||||
** the DB_Cookie flag is set when the OP_VerifyCookie opcode is emitted,
|
||||
** and prevents duplicate OP_VerifyCookies from taking up space and slowing
|
||||
** down execution.
|
||||
**
|
||||
** The DB_SchemaLoaded flag is set after the database schema has been
|
||||
** read into internal hash tables.
|
||||
**
|
||||
** DB_UnresetViews means that one or more views have column names that
|
||||
** have been filled out. If the schema changes, these column names might
|
||||
** changes and so the view will need to be reset.
|
||||
*/
|
||||
#define DB_Locked 0x0001 /* OP_Transaction opcode has been emitted */
|
||||
#define DB_Cookie 0x0002 /* OP_VerifyCookie opcode has been emiited */
|
||||
#define DB_SchemaLoaded 0x0004 /* The schema has been loaded */
|
||||
#define DB_UnresetViews 0x0008 /* Some views have defined column names */
|
||||
|
||||
|
||||
/*
|
||||
** Each database is an instance of the following structure.
|
||||
|
|
@ -202,25 +286,27 @@ typedef struct FKey FKey;
|
|||
** file_format==3 Version 2.6.0. Fix empty-string index bug.
|
||||
** file_format==4 Version 2.7.0. Add support for separate numeric and
|
||||
** text datatypes.
|
||||
**
|
||||
** The sqlite.temp_store determines where temporary database files
|
||||
** are stored. If 1, then a file is created to hold those tables. If
|
||||
** 2, then they are held in memory. 0 means use the default value in
|
||||
** the TEMP_STORE macro.
|
||||
*/
|
||||
struct sqlite {
|
||||
Btree *pBe; /* The B*Tree backend */
|
||||
Btree *pBeTemp; /* Backend for session temporary tables */
|
||||
int nDb; /* Number of backends currently in use */
|
||||
Db *aDb; /* All backends */
|
||||
Db aDbStatic[2]; /* Static space for the 2 default backends */
|
||||
int flags; /* Miscellanous flags. See below */
|
||||
u8 file_format; /* What file format version is this database? */
|
||||
u8 safety_level; /* How aggressive at synching data to disk */
|
||||
u8 want_to_close; /* Close after all VDBEs are deallocated */
|
||||
int schema_cookie; /* Magic number that changes with the schema */
|
||||
int next_cookie; /* Value of schema_cookie after commit */
|
||||
int next_cookie; /* Next value of aDb[0].schema_cookie */
|
||||
int cache_size; /* Number of pages to use in the cache */
|
||||
int temp_store; /* 1=file, 2=memory, 0=compile-time default */
|
||||
int nTable; /* Number of tables in the database */
|
||||
void *pBusyArg; /* 1st Argument to the busy callback */
|
||||
int (*xBusyCallback)(void *,const char*,int); /* The busy callback */
|
||||
Hash tblHash; /* All tables indexed by name */
|
||||
Hash idxHash; /* All (named) indices indexed by name */
|
||||
Hash trigHash; /* All triggers indexed by name */
|
||||
Hash aFunc; /* All functions that can be in SQL exprs */
|
||||
Hash aFKey; /* Foreign keys indexed by to-table */
|
||||
int lastRowid; /* ROWID of most recent insert */
|
||||
int priorNewRowid; /* Last randomly generated ROWID */
|
||||
int onError; /* Default conflict algorithm */
|
||||
|
|
@ -232,13 +318,18 @@ struct sqlite {
|
|||
void *pTraceArg; /* Argument to the trace function */
|
||||
#endif
|
||||
#ifndef SQLITE_OMIT_AUTHORIZATION
|
||||
int (*xAuth)(void*,int,const char*,const char*); /* Access Auth function */
|
||||
int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
|
||||
/* Access authorization function */
|
||||
void *pAuthArg; /* 1st argument to the access auth function */
|
||||
#endif
|
||||
};
|
||||
|
||||
/*
|
||||
** Possible values for the sqlite.flags.
|
||||
** Possible values for the sqlite.flags and or Db.flags fields.
|
||||
**
|
||||
** On sqlite.flags, the SQLITE_InTrans value means that we have
|
||||
** executed a BEGIN. On Db.flags, SQLITE_InTrans means a statement
|
||||
** transaction is active on that particular database file.
|
||||
*/
|
||||
#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */
|
||||
#define SQLITE_Initialized 0x00000002 /* True after initialization */
|
||||
|
|
@ -251,10 +342,7 @@ struct sqlite {
|
|||
/* the count using a callback. */
|
||||
#define SQLITE_NullCallback 0x00000080 /* Invoke the callback once if the */
|
||||
/* result set is empty */
|
||||
#define SQLITE_ResultDetails 0x00000100 /* Details added to result set */
|
||||
#define SQLITE_UnresetViews 0x00000200 /* True if one or more views have */
|
||||
/* defined column names */
|
||||
#define SQLITE_ReportTypes 0x00000400 /* Include information on datatypes */
|
||||
#define SQLITE_ReportTypes 0x00000200 /* Include information on datatypes */
|
||||
/* in 4th argument of callback */
|
||||
|
||||
/*
|
||||
|
|
@ -314,26 +402,27 @@ struct Column {
|
|||
** Each SQL table is represented in memory by an instance of the
|
||||
** following structure.
|
||||
**
|
||||
** Expr.zName is the name of the table. The case of the original
|
||||
** Table.zName is the name of the table. The case of the original
|
||||
** CREATE TABLE statement is stored, but case is not significant for
|
||||
** comparisons.
|
||||
**
|
||||
** Expr.nCol is the number of columns in this table. Expr.aCol is a
|
||||
** Table.nCol is the number of columns in this table. Table.aCol is a
|
||||
** pointer to an array of Column structures, one for each column.
|
||||
**
|
||||
** If the table has an INTEGER PRIMARY KEY, then Expr.iPKey is the index of
|
||||
** the column that is that key. Otherwise Expr.iPKey is negative. Note
|
||||
** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
|
||||
** the column that is that key. Otherwise Table.iPKey is negative. Note
|
||||
** that the datatype of the PRIMARY KEY must be INTEGER for this field to
|
||||
** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of
|
||||
** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid
|
||||
** is generated for each row of the table. Expr.hasPrimKey is true if
|
||||
** is generated for each row of the table. Table.hasPrimKey is true if
|
||||
** the table has any PRIMARY KEY, INTEGER or otherwise.
|
||||
**
|
||||
** Expr.tnum is the page number for the root BTree page of the table in the
|
||||
** database file. If Expr.isTemp is true, then this page occurs in the
|
||||
** auxiliary database file, not the main database file. If Expr.isTransient
|
||||
** Table.tnum is the page number for the root BTree page of the table in the
|
||||
** database file. If Table.iDb is the index of the database table backend
|
||||
** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that
|
||||
** holds temporary tables and indices. If Table.isTransient
|
||||
** is true, then the table is stored in a file that is automatically deleted
|
||||
** when the VDBE cursor to the table is closed. In this case Expr.tnum
|
||||
** when the VDBE cursor to the table is closed. In this case Table.tnum
|
||||
** refers VDBE cursor number that holds the table open, not to the root
|
||||
** page number. Transient tables are used to hold the results of a
|
||||
** sub-query that appears instead of a real table name in the FROM clause
|
||||
|
|
@ -348,7 +437,7 @@ struct Table {
|
|||
int tnum; /* Root BTree node for this table (see note above) */
|
||||
Select *pSelect; /* NULL for tables. Points to definition if a view. */
|
||||
u8 readOnly; /* True if this table should not be written by the user */
|
||||
u8 isTemp; /* True if stored in db->pBeTemp instead of db->pBe */
|
||||
u8 iDb; /* Index into sqlite.aDb[] of the backend for this table */
|
||||
u8 isTransient; /* True if automatically deleted when VDBE finishes */
|
||||
u8 hasPrimKey; /* True if there exists a primary key */
|
||||
u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
|
||||
|
|
@ -376,7 +465,7 @@ struct Table {
|
|||
** the from-table is created. The existance of the to-table is not checked
|
||||
** until an attempt is made to insert data into the from-table.
|
||||
**
|
||||
** The sqlite.aFKey hash table stores pointers to to this structure
|
||||
** The sqlite.aFKey hash table stores pointers to this structure
|
||||
** given the name of a to-table. For each to-table, all foreign keys
|
||||
** associated with that table are on a linked list using the FKey.pNextTo
|
||||
** field.
|
||||
|
|
@ -454,6 +543,13 @@ struct FKey {
|
|||
** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
|
||||
** The second column to be indexed (c1) has an index of 0 in
|
||||
** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
|
||||
**
|
||||
** The Index.onError field determines whether or not the indexed columns
|
||||
** must be unique and what to do if they are not. When Index.onError=OE_None,
|
||||
** it means this is not a unique index. Otherwise it is a unique index
|
||||
** and the value of Index.onError indicate the which conflict resolution
|
||||
** algorithm to employ whenever an attempt is made to insert a non-unique
|
||||
** element.
|
||||
*/
|
||||
struct Index {
|
||||
char *zName; /* Name of this index */
|
||||
|
|
@ -461,9 +557,9 @@ struct Index {
|
|||
int *aiColumn; /* Which columns are used by this index. 1st is 0 */
|
||||
Table *pTable; /* The SQL table being indexed */
|
||||
int tnum; /* Page containing root of this index in database file */
|
||||
u8 isUnique; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
|
||||
u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
|
||||
u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */
|
||||
u8 iDb; /* Index in sqlite.aDb[] of where this index is stored */
|
||||
Index *pNext; /* The next index associated with the same table */
|
||||
};
|
||||
|
||||
|
|
@ -514,7 +610,8 @@ struct Token {
|
|||
struct Expr {
|
||||
u8 op; /* Operation performed by this node */
|
||||
u8 dataType; /* Either SQLITE_SO_TEXT or SQLITE_SO_NUM */
|
||||
u16 flags; /* Various flags. See below */
|
||||
u8 iDb; /* Database referenced by this expression */
|
||||
u8 flags; /* Various flags. See below */
|
||||
Expr *pLeft, *pRight; /* Left and right subnodes */
|
||||
ExprList *pList; /* A list of expressions used as function arguments
|
||||
** or in "<expr> IN (<expr-list)" */
|
||||
|
|
@ -589,18 +686,26 @@ struct IdList {
|
|||
** The following structure describes the FROM clause of a SELECT statement.
|
||||
** Each table or subquery in the FROM clause is a separate element of
|
||||
** the SrcList.a[] array.
|
||||
**
|
||||
** With the addition of multiple database support, the following structure
|
||||
** can also be used to describe a particular table such as the table that
|
||||
** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
|
||||
** such a table must be a simple name: ID. But in SQLite, the table can
|
||||
** now be identified by a database name, a dot, then the table name: ID.ID.
|
||||
*/
|
||||
struct SrcList {
|
||||
int nSrc; /* Number of tables or subqueries in the FROM clause */
|
||||
struct SrcList_item {
|
||||
char *zDatabase; /* Name of database holding this table */
|
||||
char *zName; /* Name of the table */
|
||||
char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
|
||||
Table *pTab; /* An SQL table corresponding to zName */
|
||||
Select *pSelect; /* A SELECT statement used in place of a table name */
|
||||
int jointype; /* Type of join between this table and the next */
|
||||
int iCursor; /* The VDBE cursor number used to access this table */
|
||||
Expr *pOn; /* The ON clause of a join */
|
||||
IdList *pUsing; /* The USING clause of a join */
|
||||
} *a; /* One entry for each identifier on the list */
|
||||
} a[1]; /* One entry for each identifier on the list */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -645,7 +750,6 @@ struct WhereInfo {
|
|||
SrcList *pTabList; /* List of tables in the join */
|
||||
int iContinue; /* Jump here to continue with next record */
|
||||
int iBreak; /* Jump here to break out of the loop */
|
||||
int base; /* Index of first Open opcode */
|
||||
int nLevel; /* Number of nested loop */
|
||||
int savedNTab; /* Value of pParse->nTab before WhereBegin() */
|
||||
int peakNTab; /* Value of pParse->nTab after WhereBegin() */
|
||||
|
|
@ -682,7 +786,6 @@ struct Select {
|
|||
Select *pPrior; /* Prior select in a compound select statement */
|
||||
int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */
|
||||
char *zSelect; /* Complete text of the SELECT command */
|
||||
int base; /* Index of VDBE cursor for left-most FROM table */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -731,7 +834,6 @@ struct AggExpr {
|
|||
*/
|
||||
struct Parse {
|
||||
sqlite *db; /* The main database structure */
|
||||
Btree *pBe; /* The database backend */
|
||||
int rc; /* Return code from execution */
|
||||
sqlite_callback xCallback; /* The callback function */
|
||||
void *pArg; /* First argument to the callback function */
|
||||
|
|
@ -748,10 +850,9 @@ struct Parse {
|
|||
u8 nameClash; /* A permanent table name clashes with temp table name */
|
||||
u8 useAgg; /* If true, extract field values from the aggregator
|
||||
** while generating expressions. Normally false */
|
||||
u8 schemaVerified; /* True if an OP_VerifySchema has been coded someplace
|
||||
** other than after an OP_Transaction */
|
||||
u8 isTemp; /* True if parsing temporary tables */
|
||||
u8 iDb; /* Index of database whose schema is being parsed */
|
||||
u8 useCallback; /* True if callbacks should be used to report results */
|
||||
int useDb; /* Restrict references to tables in this database */
|
||||
int newTnum; /* Table number to use when reparsing CREATE TABLEs */
|
||||
int nErr; /* Number of errors seen */
|
||||
int nTab; /* Number of previously allocated VDBE cursors */
|
||||
|
|
@ -759,7 +860,18 @@ struct Parse {
|
|||
int nSet; /* Number of sets used so far */
|
||||
int nAgg; /* Number of aggregate expressions */
|
||||
AggExpr *aAgg; /* An array of aggregate expressions */
|
||||
TriggerStack *trigStack;
|
||||
const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
|
||||
Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */
|
||||
TriggerStack *trigStack; /* Trigger actions being coded */
|
||||
};
|
||||
|
||||
/*
|
||||
** An instance of the following structure can be declared on a stack and used
|
||||
** to save the Parse.zAuthContext value so that it can be restored later.
|
||||
*/
|
||||
struct AuthContext {
|
||||
const char *zAuthContext; /* Put saved Parse.zAuthContext here */
|
||||
Parse *pParse; /* The Parse structure */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -776,24 +888,13 @@ struct Parse {
|
|||
*
|
||||
* The "step_list" member points to the first element of a linked list
|
||||
* containing the SQL statements specified as the trigger program.
|
||||
*
|
||||
* When a trigger is initially created, the "isCommit" member is set to FALSE.
|
||||
* When a transaction is rolled back, any Trigger structures with "isCommit" set
|
||||
* to FALSE are deleted by the logic in sqliteRollbackInternalChanges(). When
|
||||
* a transaction is commited, the "isCommit" member is set to TRUE for any
|
||||
* Trigger structures for which it is FALSE.
|
||||
*
|
||||
* When a trigger is dropped, using the sqliteDropTrigger() interfaced, it is
|
||||
* removed from the trigHash hash table and added to the trigDrop hash table.
|
||||
* If the transaction is rolled back, the trigger is re-added into the trigHash
|
||||
* hash table (and hence the database schema). If the transaction is commited,
|
||||
* then the Trigger structure is deleted permanently.
|
||||
*/
|
||||
struct Trigger {
|
||||
char *name; /* The name of the trigger */
|
||||
char *table; /* The table or view to which the trigger applies */
|
||||
int op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
|
||||
int tr_tm; /* One of TK_BEFORE, TK_AFTER */
|
||||
u8 iDb; /* Database containing this trigger */
|
||||
u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
|
||||
u8 tr_tm; /* One of TK_BEFORE, TK_AFTER */
|
||||
Expr *pWhen; /* The WHEN clause of the expresion (may be NULL) */
|
||||
IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
|
||||
the <column-list> is stored here */
|
||||
|
|
@ -844,6 +945,7 @@ struct Trigger {
|
|||
struct TriggerStep {
|
||||
int op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
|
||||
int orconf; /* OE_Rollback etc. */
|
||||
Trigger *pTrig; /* The trigger that this step is a part of */
|
||||
|
||||
Select *pSelect; /* Valid for SELECT and sometimes
|
||||
INSERT steps (when pExprList == 0) */
|
||||
|
|
@ -889,9 +991,8 @@ struct TriggerStack {
|
|||
int oldIdx; /* Index of vdbe cursor to "old" temp table */
|
||||
int orconf; /* Current orconf policy */
|
||||
int ignoreJump; /* where to jump to for a RAISE(IGNORE) */
|
||||
Trigger *pTrigger;
|
||||
|
||||
TriggerStack *pNext;
|
||||
Trigger *pTrigger; /* The trigger currently being coded */
|
||||
TriggerStack *pNext; /* Next trigger down on the trigger stack */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -907,6 +1008,7 @@ extern int always_code_trigger_setup;
|
|||
int sqliteStrICmp(const char *, const char *);
|
||||
int sqliteStrNICmp(const char *, const char *, int);
|
||||
int sqliteHashNoCase(const char *, int);
|
||||
int sqliteIsNumber(const char*);
|
||||
int sqliteCompare(const char *, const char *);
|
||||
int sqliteSortCompare(const char *, const char *);
|
||||
void sqliteRealToSortable(double r, char *);
|
||||
|
|
@ -929,6 +1031,7 @@ void sqliteRealToSortable(double r, char *);
|
|||
char *sqliteMPrintf(const char *,...);
|
||||
void sqliteSetString(char **, const char *, ...);
|
||||
void sqliteSetNString(char **, ...);
|
||||
void sqliteErrorMsg(Parse*, const char*, ...);
|
||||
void sqliteDequote(char*);
|
||||
int sqliteKeywordCode(const char*, int);
|
||||
int sqliteRunParser(Parse*, const char*, char **);
|
||||
|
|
@ -939,9 +1042,9 @@ Expr *sqliteExprFunction(ExprList*, Token*);
|
|||
void sqliteExprDelete(Expr*);
|
||||
ExprList *sqliteExprListAppend(ExprList*,Expr*,Token*);
|
||||
void sqliteExprListDelete(ExprList*);
|
||||
void sqlitePragma(Parse*,Token*,Token*,int);
|
||||
void sqliteResetInternalSchema(sqlite*);
|
||||
int sqliteInit(sqlite*, char**);
|
||||
void sqlitePragma(Parse*,Token*,Token*,int);
|
||||
void sqliteResetInternalSchema(sqlite*, int);
|
||||
void sqliteBeginParse(Parse*,int);
|
||||
void sqliteRollbackInternalChanges(sqlite*);
|
||||
void sqliteCommitInternalChanges(sqlite*);
|
||||
|
|
@ -958,18 +1061,18 @@ void sqliteAddCollateType(Parse*, int);
|
|||
void sqliteEndTable(Parse*,Token*,Select*);
|
||||
void sqliteCreateView(Parse*,Token*,Token*,Select*,int);
|
||||
int sqliteViewGetColumnNames(Parse*,Table*);
|
||||
void sqliteViewResetAll(sqlite*);
|
||||
void sqliteDropTable(Parse*, Token*, int);
|
||||
void sqliteDeleteTable(sqlite*, Table*);
|
||||
void sqliteInsert(Parse*, Token*, ExprList*, Select*, IdList*, int);
|
||||
void sqliteInsert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
|
||||
IdList *sqliteIdListAppend(IdList*, Token*);
|
||||
int sqliteIdListIndex(IdList*,const char*);
|
||||
SrcList *sqliteSrcListAppend(SrcList*, Token*);
|
||||
SrcList *sqliteSrcListAppend(SrcList*, Token*, Token*);
|
||||
void sqliteSrcListAddAlias(SrcList*, Token*);
|
||||
void sqliteSrcListAssignCursors(Parse*, SrcList*);
|
||||
void sqliteIdListDelete(IdList*);
|
||||
void sqliteSrcListDelete(SrcList*);
|
||||
void sqliteCreateIndex(Parse*, Token*, Token*, IdList*, int, Token*, Token*);
|
||||
void sqliteDropIndex(Parse*, Token*);
|
||||
void sqliteCreateIndex(Parse*,Token*,SrcList*,IdList*,int,int,Token*,Token*);
|
||||
void sqliteDropIndex(Parse*, SrcList*);
|
||||
void sqliteAddKeyType(Vdbe*, ExprList*);
|
||||
void sqliteAddIdxKeyType(Vdbe*, Index*);
|
||||
int sqliteSelect(Parse*, Select*, int, int, Select*, int, int*);
|
||||
|
|
@ -977,19 +1080,20 @@ Select *sqliteSelectNew(ExprList*,SrcList*,Expr*,ExprList*,Expr*,ExprList*,
|
|||
int,int,int);
|
||||
void sqliteSelectDelete(Select*);
|
||||
void sqliteSelectUnbind(Select*);
|
||||
Table *sqliteTableNameToTable(Parse*, const char*);
|
||||
SrcList *sqliteTableTokenToSrcList(Parse*, Token*);
|
||||
void sqliteDeleteFrom(Parse*, Token*, Expr*);
|
||||
void sqliteUpdate(Parse*, Token*, ExprList*, Expr*, int);
|
||||
WhereInfo *sqliteWhereBegin(Parse*, int, SrcList*, Expr*, int, ExprList**);
|
||||
Table *sqliteSrcListLookup(Parse*, SrcList*);
|
||||
int sqliteIsReadOnly(Parse*, Table*, int);
|
||||
void sqliteDeleteFrom(Parse*, SrcList*, Expr*);
|
||||
void sqliteUpdate(Parse*, SrcList*, ExprList*, Expr*, int);
|
||||
WhereInfo *sqliteWhereBegin(Parse*, SrcList*, Expr*, int, ExprList**);
|
||||
void sqliteWhereEnd(WhereInfo*);
|
||||
void sqliteExprCode(Parse*, Expr*);
|
||||
void sqliteExprIfTrue(Parse*, Expr*, int, int);
|
||||
void sqliteExprIfFalse(Parse*, Expr*, int, int);
|
||||
Table *sqliteFindTable(sqlite*,const char*);
|
||||
Index *sqliteFindIndex(sqlite*,const char*);
|
||||
Table *sqliteFindTable(sqlite*,const char*, const char*);
|
||||
Table *sqliteLocateTable(Parse*,const char*, const char*);
|
||||
Index *sqliteFindIndex(sqlite*,const char*, const char*);
|
||||
void sqliteUnlinkAndDeleteIndex(sqlite*,Index*);
|
||||
void sqliteCopy(Parse*, Token*, Token*, Token*, int);
|
||||
void sqliteCopy(Parse*, SrcList*, Token*, Token*, int);
|
||||
void sqliteVacuum(Parse*, Token*);
|
||||
int sqliteGlobCompare(const unsigned char*,const unsigned char*);
|
||||
int sqliteLikeCompare(const unsigned char*,const unsigned char*);
|
||||
|
|
@ -998,11 +1102,13 @@ int sqliteExprCheck(Parse*, Expr*, int, int*);
|
|||
int sqliteExprType(Expr*);
|
||||
int sqliteExprCompare(Expr*, Expr*);
|
||||
int sqliteFuncId(Token*);
|
||||
int sqliteExprResolveIds(Parse*, int, SrcList*, ExprList*, Expr*);
|
||||
int sqliteExprResolveIds(Parse*, SrcList*, ExprList*, Expr*);
|
||||
int sqliteExprAnalyzeAggregates(Parse*, Expr*);
|
||||
Vdbe *sqliteGetVdbe(Parse*);
|
||||
int sqliteRandomByte(void);
|
||||
int sqliteRandomInteger(void);
|
||||
void sqliteRollbackAll(sqlite*);
|
||||
void sqliteCodeVerifySchema(Parse*, int);
|
||||
void sqliteBeginTransaction(Parse*, int);
|
||||
void sqliteCommitTransaction(Parse*);
|
||||
void sqliteRollbackTransaction(Parse*);
|
||||
|
|
@ -1012,7 +1118,7 @@ int sqliteIsRowid(const char*);
|
|||
void sqliteGenerateRowDelete(sqlite*, Vdbe*, Table*, int, int);
|
||||
void sqliteGenerateRowIndexDelete(sqlite*, Vdbe*, Table*, int, char*);
|
||||
void sqliteGenerateConstraintChecks(Parse*,Table*,int,char*,int,int,int,int);
|
||||
void sqliteCompleteInsertion(Parse*, Table*, int, char*, int, int);
|
||||
void sqliteCompleteInsertion(Parse*, Table*, int, char*, int, int, int);
|
||||
void sqliteBeginWriteOperation(Parse*, int, int);
|
||||
void sqliteEndWriteOperation(Parse*);
|
||||
Expr *sqliteExprDup(Expr*);
|
||||
|
|
@ -1027,13 +1133,14 @@ int sqliteSafetyOn(sqlite*);
|
|||
int sqliteSafetyOff(sqlite*);
|
||||
int sqliteSafetyCheck(sqlite*);
|
||||
void sqliteChangeCookie(sqlite*, Vdbe*);
|
||||
void sqliteCreateTrigger(Parse*, Token*, int, int, IdList*, Token*,
|
||||
int, Expr*, TriggerStep*, Token*);
|
||||
void sqliteDropTrigger(Parse*, Token*, int);
|
||||
void sqliteBeginTrigger(Parse*, Token*,int,int,IdList*,SrcList*,int,Expr*,int);
|
||||
void sqliteFinishTrigger(Parse*, TriggerStep*, Token*);
|
||||
void sqliteDropTrigger(Parse*, SrcList*, int);
|
||||
int sqliteTriggersExist(Parse* , Trigger* , int , int , int, ExprList*);
|
||||
int sqliteCodeRowTrigger(Parse*, int, ExprList*, int, Table *, int, int,
|
||||
int, int);
|
||||
void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
|
||||
void sqliteDeleteTriggerStep(TriggerStep*);
|
||||
TriggerStep *sqliteTriggerSelectStep(Select*);
|
||||
TriggerStep *sqliteTriggerInsertStep(Token*, IdList*, ExprList*, Select*, int);
|
||||
TriggerStep *sqliteTriggerUpdateStep(Token*, ExprList*, Expr*, int);
|
||||
|
|
@ -1043,9 +1150,17 @@ int sqliteJoinType(Parse*, Token*, Token*, Token*);
|
|||
void sqliteCreateForeignKey(Parse*, IdList*, Token*, IdList*, int);
|
||||
void sqliteDeferForeignKey(Parse*, int);
|
||||
#ifndef SQLITE_OMIT_AUTHORIZATION
|
||||
void sqliteAuthRead(Parse*,Expr*,SrcList*,int);
|
||||
int sqliteAuthCheck(Parse*,int, const char*, const char*);
|
||||
void sqliteAuthRead(Parse*,Expr*,SrcList*);
|
||||
int sqliteAuthCheck(Parse*,int, const char*, const char*, const char*);
|
||||
void sqliteAuthContextPush(Parse*, AuthContext*, const char*);
|
||||
void sqliteAuthContextPop(AuthContext*);
|
||||
#else
|
||||
# define sqliteAuthRead(a,b,c,d)
|
||||
# define sqliteAuthRead(a,b,c)
|
||||
# define sqliteAuthCheck(a,b,c,d) SQLITE_OK
|
||||
# define sqliteAuthContextPush(a,b,c)
|
||||
# define sqliteAuthContextPop(a)
|
||||
#endif
|
||||
void sqliteAttach(Parse*, Token*, Token*);
|
||||
void sqliteDetach(Parse*, Token*);
|
||||
int sqliteBtreeFactory(const sqlite *db, const char *zFilename,
|
||||
int mode, int nPg, Btree **ppBtree);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue