/*

** 2001 September 15

**

** The author disclaims copyright to this source code.  In place of

** a legal notice, here is a blessing:

**

**    May you do good and not evil.

**    May you find forgiveness for yourself and forgive others.

**    May you share freely, never taking more than you give.

**

*************************************************************************

** Internal interface definitions for SQLite.

**

** @(#) $Id$

*/

#ifndef _SQLITEINT_H_

#define _SQLITEINT_H_

#include "sqliteLimit.h"

#if defined(SQLITE_TCL) || defined(TCLSH)

# include <tcl.h>

#endif

/*

** Many people are failing to set -DNDEBUG=1 when compiling SQLite.

** Setting NDEBUG makes the code smaller and run faster.  So the following

** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1

** option is set.  Thus NDEBUG becomes an opt-in rather than an opt-out

** feature.

*/

#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 

# define NDEBUG 1

#endif

/*

** These #defines should enable >2GB file support on Posix if the

** underlying operating system supports it.  If the OS lacks

** large file support, or if the OS is windows, these should be no-ops.

**

** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch

** on the compiler command line.  This is necessary if you are compiling

** on a recent machine (ex: RedHat 7.2) but you want your code to work

** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2

** without this option, LFS is enable.  But LFS does not exist in the kernel

** in RedHat 6.0, so the code won't work.  Hence, for maximum binary

** portability you should omit LFS.

**

** Similar is true for MacOS.  LFS is only supported on MacOS 9 and later.

*/

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE       1

# ifndef _FILE_OFFSET_BITS

#   define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

#include "sqlite3.h"

#include "hash.h"

#include "parse.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <stddef.h>

#define sqlite3_isnan(X)  ((X)!=(X))

/*

** If compiling for a processor that lacks floating point support,

** substitute integer for floating-point

*/

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite_int64

# define LONGDOUBLE_TYPE sqlite_int64

# ifndef SQLITE_BIG_DBL

#   define SQLITE_BIG_DBL (0x7fffffffffffffff)

# endif

# define SQLITE_OMIT_DATETIME_FUNCS 1

# define SQLITE_OMIT_TRACE 1

# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT

#endif

#ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (1e99)

#endif

/*

** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0

** afterward. Having this macro allows us to cause the C compiler 

** to omit code used by TEMP tables without messy #ifndef statements.

*/

#ifdef SQLITE_OMIT_TEMPDB

#define OMIT_TEMPDB 1

#else

#define OMIT_TEMPDB 0

#endif

/*

** If the following macro is set to 1, then NULL values are considered

** distinct when determining whether or not two entries are the same

** in a UNIQUE index.  This is the way PostgreSQL, Oracle, DB2, MySQL,

** OCELOT, and Firebird all work.  The SQL92 spec explicitly says this

** is the way things are suppose to work.

**

** If the following macro is set to 0, the NULLs are indistinct for

** a UNIQUE index.  In this mode, you can only have a single NULL entry

** for a column declared UNIQUE.  This is the way Informix and SQL Server

** work.

*/

#define NULL_DISTINCT_FOR_UNIQUE 1

/*

** The "file format" number is an integer that is incremented whenever

** the VDBE-level file format changes.  The following macros define the

** the default file format for new databases and the maximum file format

** that the library can read.

*/

#define SQLITE_MAX_FILE_FORMAT 4

#ifndef SQLITE_DEFAULT_FILE_FORMAT

# define SQLITE_DEFAULT_FILE_FORMAT 1

#endif

/*

** Provide a default value for TEMP_STORE in case it is not specified

** on the command-line

*/

#ifndef TEMP_STORE

# define TEMP_STORE 1

#endif

/*

** GCC does not define the offsetof() macro so we'll have to do it

** ourselves.

*/

#ifndef offsetof

#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))

#endif

/*

** Check to see if this machine uses EBCDIC.  (Yes, believe it or

** not, there are still machines out there that use EBCDIC.)

*/

#if 'A' == '\301'

# define SQLITE_EBCDIC 1

#else

# define SQLITE_ASCII 1

#endif

/*

** Integers of known sizes.  These typedefs might change for architectures

** where the sizes very.  Preprocessor macros are available so that the

** types can be conveniently redefined at compile-type.  Like this:

**

**         cc '-DUINTPTR_TYPE=long long int' ...

*/

#ifndef UINT32_TYPE

# define UINT32_TYPE unsigned int

#endif

#ifndef UINT16_TYPE

# define UINT16_TYPE unsigned short int

#endif

#ifndef INT16_TYPE

# define INT16_TYPE short int

#endif

#ifndef UINT8_TYPE

# define UINT8_TYPE unsigned char

#endif

#ifndef INT8_TYPE

# define INT8_TYPE signed char

#endif

#ifndef LONGDOUBLE_TYPE

# define LONGDOUBLE_TYPE long double

#endif

typedef sqlite_int64 i64;          /* 8-byte signed integer */

typedef sqlite_uint64 u64;         /* 8-byte unsigned integer */

typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */

typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */

typedef INT16_TYPE i16;            /* 2-byte signed integer */

typedef UINT8_TYPE u8;             /* 1-byte unsigned integer */

typedef UINT8_TYPE i8;             /* 1-byte signed integer */

/*

** Macros to determine whether the machine is big or little endian,

** evaluated at runtime.

*/

extern const int sqlite3one;

#if defined(i386) || defined(__i386__) || defined(_M_IX86)

# define SQLITE_BIGENDIAN    0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE  SQLITE_UTF16LE

#else

# define SQLITE_BIGENDIAN    (*(char *)(&sqlite3one)==0)

# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#endif

/*

** An instance of the following structure is used to store the busy-handler

** callback for a given sqlite handle. 

**

** The sqlite.busyHandler member of the sqlite struct contains the busy

** callback for the database handle. Each pager opened via the sqlite

** handle is passed a pointer to sqlite.busyHandler. The busy-handler

** callback is currently invoked only from within pager.c.

*/

typedef struct BusyHandler BusyHandler;

struct BusyHandler {

  int (*xFunc)(void *,int);  /* The busy callback */

  void *pArg;                /* First arg to busy callback */

  int nBusy;                 /* Incremented with each busy call */

};

/*

** Defer sourcing vdbe.h and btree.h until after the "u8" and 

** "BusyHandler typedefs.

*/

#include "vdbe.h"

#include "btree.h"

#include "pager.h"

#ifdef SQLITE_MEMDEBUG

/*

** The following global variables are used for testing and debugging

** only.  They only work if SQLITE_MEMDEBUG is defined.

*/

extern int sqlite3_nMalloc;      /* Number of sqliteMalloc() calls */

extern int sqlite3_nFree;        /* Number of sqliteFree() calls */

extern int sqlite3_iMallocFail;  /* Fail sqliteMalloc() after this many calls */

extern int sqlite3_iMallocReset; /* Set iMallocFail to this when it reaches 0 */

extern void *sqlite3_pFirst;         /* Pointer to linked list of allocations */

extern int sqlite3_nMaxAlloc;        /* High water mark of ThreadData.nAlloc */

extern int sqlite3_mallocDisallowed; /* assert() in sqlite3Malloc() if set */

extern int sqlite3_isFail;           /* True if all malloc calls should fail */

extern const char *sqlite3_zFile;    /* Filename to associate debug info with */

extern int sqlite3_iLine;            /* Line number for debug info */

#define ENTER_MALLOC (sqlite3_zFile = __FILE__, sqlite3_iLine = __LINE__)

#define sqliteMalloc(x)          (ENTER_MALLOC, sqlite3Malloc(x,1))

#define sqliteMallocRaw(x)       (ENTER_MALLOC, sqlite3MallocRaw(x,1))

#define sqliteRealloc(x,y)       (ENTER_MALLOC, sqlite3Realloc(x,y))

#define sqliteStrDup(x)          (ENTER_MALLOC, sqlite3StrDup(x))

#define sqliteStrNDup(x,y)       (ENTER_MALLOC, sqlite3StrNDup(x,y))

#define sqliteReallocOrFree(x,y) (ENTER_MALLOC, sqlite3ReallocOrFree(x,y))

#else

#define ENTER_MALLOC 0

#define sqliteMalloc(x)          sqlite3Malloc(x,1)

#define sqliteMallocRaw(x)       sqlite3MallocRaw(x,1)

#define sqliteRealloc(x,y)       sqlite3Realloc(x,y)

#define sqliteStrDup(x)          sqlite3StrDup(x)

#define sqliteStrNDup(x,y)       sqlite3StrNDup(x,y)

#define sqliteReallocOrFree(x,y) sqlite3ReallocOrFree(x,y)

#endif

/* Variable sqlite3_mallocHasFailed is set to true after a malloc() 

** failure occurs. 

**

** The sqlite3MallocFailed() macro returns true if a malloc has failed

** in this thread since the last call to sqlite3ApiExit(), or false 

** otherwise.

*/

extern int sqlite3_mallocHasFailed;

#define sqlite3MallocFailed() (sqlite3_mallocHasFailed && sqlite3OsInMutex(1))

#define sqliteFree(x)          sqlite3FreeX(x)

#define sqliteAllocSize(x)     sqlite3AllocSize(x)

/*

** An instance of this structure might be allocated to store information

** specific to a single thread.

*/

struct ThreadData {

  int dummy;               /* So that this structure is never empty */

#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

  int nSoftHeapLimit;      /* Suggested max mem allocation.  No limit if <0 */

  int nAlloc;              /* Number of bytes currently allocated */

  Pager *pPager;           /* Linked list of all pagers in this thread */

#endif

#ifndef SQLITE_OMIT_SHARED_CACHE

  u8 useSharedData;        /* True if shared pagers and schemas are enabled */

  BtShared *pBtree;        /* Linked list of all currently open BTrees */

#endif

};

/*

** Name of the master database table.  The master database table

** is a special table that holds the names and attributes of all

** user tables and indices.

*/

#define MASTER_NAME       "sqlite_master"

#define TEMP_MASTER_NAME  "sqlite_temp_master"

/*

** The root-page of the master database table.

*/

#define MASTER_ROOT       1

/*

** The name of the schema table.

*/

#define SCHEMA_TABLE(x)  ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

/*

** A convenience macro that returns the number of elements in

** an array.

*/

#define ArraySize(X)    (sizeof(X)/sizeof(X[0]))

/*

** Forward references to structures

*/

typedef struct AggInfo AggInfo;

typedef struct AuthContext AuthContext;

typedef struct CollSeq CollSeq;

typedef struct Column Column;

typedef struct Db Db;

typedef struct Schema Schema;

typedef struct Expr Expr;

typedef struct ExprList ExprList;

typedef struct FKey FKey;

typedef struct FuncDef FuncDef;

typedef struct IdList IdList;

typedef struct Index Index;

typedef struct KeyClass KeyClass;

typedef struct KeyInfo KeyInfo;

typedef struct Module Module;

typedef struct NameContext NameContext;

typedef struct Parse Parse;

typedef struct Select Select;

typedef struct SrcList SrcList;

typedef struct ThreadData ThreadData;

typedef struct Table Table;

typedef struct TableLock TableLock;

typedef struct Token Token;

typedef struct TriggerStack TriggerStack;

typedef struct TriggerStep TriggerStep;

typedef struct Trigger Trigger;

typedef struct WhereInfo WhereInfo;

typedef struct WhereLevel WhereLevel;

#include "os.h"

/*

** 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 */

  u8 inTrans;          /* 0: not writable.  1: Transaction.  2: Checkpoint */

  u8 safety_level;     /* How aggressive at synching data to disk */

  void *pAux;               /* Auxiliary data.  Usually NULL */

  void (*xFreeAux)(void*);  /* Routine to free pAux */

  Schema *pSchema;     /* Pointer to database schema (possibly shared) */

};

/*

** An instance of the following structure stores a database schema.

**

** If there are no virtual tables configured in this schema, the

** Schema.db variable is set to NULL. After the first virtual table

** has been added, it is set to point to the database connection 

** used to create the connection. Once a virtual table has been

** added to the Schema structure and the Schema.db variable populated, 

** only that database connection may use the Schema to prepare 

** statements.

*/

struct Schema {

  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 */

  Table *pSeqTab;      /* The sqlite_sequence table used by AUTOINCREMENT */

  u8 file_format;      /* Schema format version for this file */

  u8 enc;              /* Text encoding used by this database */

  u16 flags;           /* Flags associated with this schema */

  int cache_size;      /* Number of pages to use in the cache */

#ifndef SQLITE_OMIT_VIRTUALTABLE

  sqlite3 *db;         /* "Owner" connection. See comment above */

#endif

};

/*

** These macros can be used to test, set, or clear bits in the 

** Db.flags field.

*/

#define DbHasProperty(D,I,P)     (((D)->aDb[I].pSchema->flags&(P))==(P))

#define DbHasAnyProperty(D,I,P)  (((D)->aDb[I].pSchema->flags&(P))!=0)

#define DbSetProperty(D,I,P)     (D)->aDb[I].pSchema->flags|=(P)

#define DbClearProperty(D,I,P)   (D)->aDb[I].pSchema->flags&=~(P)

/*

** Allowed values for the DB.flags field.

**

** 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_SchemaLoaded    0x0001  /* The schema has been loaded */

#define DB_UnresetViews    0x0002  /* Some views have defined column names */

#define DB_Empty           0x0004  /* The file is empty (length 0 bytes) */

/*

** Each database is an instance of the following structure.

**

** The sqlite.lastRowid records the last insert rowid generated by an

** insert statement.  Inserts on views do not affect its value.  Each

** trigger has its own context, so that lastRowid can be updated inside

** triggers as usual.  The previous value will be restored once the trigger

** exits.  Upon entering a before or instead of trigger, lastRowid is no

** longer (since after version 2.8.12) reset to -1.

**

** The sqlite.nChange does not count changes within triggers and keeps no

** context.  It is reset at start of sqlite3_exec.

** The sqlite.lsChange represents the number of changes made by the last

** insert, update, or delete statement.  It remains constant throughout the

** length of a statement and is then updated by OP_SetCounts.  It keeps a

** context stack just like lastRowid so that the count of changes

** within a trigger is not seen outside the trigger.  Changes to views do not

** affect the value of lsChange.

** The sqlite.csChange keeps track of the number of current changes (since

** the last statement) and is used to update sqlite_lsChange.

**

** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16

** store the most recent error code and, if applicable, string. The

** internal function sqlite3Error() is used to set these variables

** consistently.

*/

struct sqlite3 {

  int nDb;                      /* Number of backends currently in use */

  Db *aDb;                      /* All backends */

  int flags;                    /* Miscellanous flags. See below */

  int errCode;                  /* Most recent error code (SQLITE_*) */

  int errMask;                  /* & result codes with this before returning */

  u8 autoCommit;                /* The auto-commit flag. */

  u8 temp_store;                /* 1: file 2: memory 0: default */

  int nTable;                   /* Number of tables in the database */

  CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */

  i64 lastRowid;                /* ROWID of most recent insert (see above) */

  i64 priorNewRowid;            /* Last randomly generated ROWID */

  int magic;                    /* Magic number for detect library misuse */

  int nChange;                  /* Value returned by sqlite3_changes() */

  int nTotalChange;             /* Value returned by sqlite3_total_changes() */

  struct sqlite3InitInfo {      /* Information used during initialization */

    int iDb;                    /* When back is being initialized */

    int newTnum;                /* Rootpage of table being initialized */

    u8 busy;                    /* TRUE if currently initializing */

  } init;

  int nExtension;               /* Number of loaded extensions */

  void **aExtension;            /* Array of shared libraray handles */

  struct Vdbe *pVdbe;           /* List of active virtual machines */

  int activeVdbeCnt;            /* Number of vdbes currently executing */

  void (*xTrace)(void*,const char*);        /* Trace function */

  void *pTraceArg;                          /* Argument to the trace function */

  void (*xProfile)(void*,const char*,u64);  /* Profiling function */

  void *pProfileArg;                        /* Argument to profile function */

  void *pCommitArg;                 /* Argument to xCommitCallback() */   

  int (*xCommitCallback)(void*);    /* Invoked at every commit. */

  void *pRollbackArg;               /* Argument to xRollbackCallback() */   

  void (*xRollbackCallback)(void*); /* Invoked at every commit. */

  void *pUpdateArg;

  void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);

  void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);

  void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);

  void *pCollNeededArg;

  sqlite3_value *pErr;          /* Most recent error message */

  char *zErrMsg;                /* Most recent error message (UTF-8 encoded) */

  char *zErrMsg16;              /* Most recent error message (UTF-16 encoded) */

  union {

    int isInterrupted;          /* True if sqlite3_interrupt has been called */

    double notUsed1;            /* Spacer */

  } u1;

#ifndef SQLITE_OMIT_AUTHORIZATION

  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

#ifndef SQLITE_OMIT_PROGRESS_CALLBACK

  int (*xProgress)(void *);     /* The progress callback */

  void *pProgressArg;           /* Argument to the progress callback */

  int nProgressOps;             /* Number of opcodes for progress callback */

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

  Hash aModule;                 /* populated by sqlite3_create_module() */

  Table *pVTab;                 /* vtab with active Connect/Create method */

  sqlite3_vtab **aVTrans;       /* Virtual tables with open transactions */

  int nVTrans;                  /* Allocated size of aVTrans */

#endif

  Hash aFunc;                   /* All functions that can be in SQL exprs */

  Hash aCollSeq;                /* All collating sequences */

  BusyHandler busyHandler;      /* Busy callback */

  int busyTimeout;              /* Busy handler timeout, in msec */

  Db aDbStatic[2];              /* Static space for the 2 default backends */

#ifdef SQLITE_SSE

  sqlite3_stmt *pFetch;         /* Used by SSE to fetch stored statements */

#endif

  u8 dfltLockMode;              /* Default locking-mode for attached dbs */

};

/*

** A macro to discover the encoding of a database.

*/

#define ENC(db) ((db)->aDb[0].pSchema->enc)

/*

** 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_InTrans        0x00000008  /* True if in a transaction */

#define SQLITE_InternChanges  0x00000010  /* Uncommitted Hash table changes */

#define SQLITE_FullColNames   0x00000020  /* Show full column names on SELECT */

#define SQLITE_ShortColNames  0x00000040  /* Show short columns names */

#define SQLITE_CountRows      0x00000080  /* Count rows changed by INSERT, */

                                          /*   DELETE, or UPDATE and return */

                                          /*   the count using a callback. */

#define SQLITE_NullCallback   0x00000100  /* Invoke the callback once if the */

                                          /*   result set is empty */

#define SQLITE_SqlTrace       0x00000200  /* Debug print SQL as it executes */

#define SQLITE_VdbeListing    0x00000400  /* Debug listings of VDBE programs */

#define SQLITE_WriteSchema    0x00000800  /* OK to update SQLITE_MASTER */

#define SQLITE_NoReadlock     0x00001000  /* Readlocks are omitted when 

                                          ** accessing read-only databases */

#define SQLITE_IgnoreChecks   0x00002000  /* Do not enforce check constraints */

#define SQLITE_ReadUncommitted 0x00004000 /* For shared-cache mode */

#define SQLITE_LegacyFileFmt  0x00008000  /* Create new databases in format 1 */

#define SQLITE_FullFSync      0x00010000  /* Use full fsync on the backend */

#define SQLITE_LoadExtension  0x00020000  /* Enable load_extension */

#define SQLITE_RecoveryMode   0x00040000  /* Ignore schema errors */

/*

** Possible values for the sqlite.magic field.

** The numbers are obtained at random and have no special meaning, other

** than being distinct from one another.

*/

#define SQLITE_MAGIC_OPEN     0xa029a697  /* Database is open */

#define SQLITE_MAGIC_CLOSED   0x9f3c2d33  /* Database is closed */

#define SQLITE_MAGIC_BUSY     0xf03b7906  /* Database currently in use */

#define SQLITE_MAGIC_ERROR    0xb5357930  /* An SQLITE_MISUSE error occurred */

/*

** Each SQL function is defined by an instance of the following

** structure.  A pointer to this structure is stored in the sqlite.aFunc

** hash table.  When multiple functions have the same name, the hash table

** points to a linked list of these structures.

*/

struct FuncDef {

  i16 nArg;            /* Number of arguments.  -1 means unlimited */

  u8 iPrefEnc;         /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */

  u8 needCollSeq;      /* True if sqlite3GetFuncCollSeq() might be called */

  u8 flags;            /* Some combination of SQLITE_FUNC_* */

  void *pUserData;     /* User data parameter */

  FuncDef *pNext;      /* Next function with same name */

  void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */

  void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */

  void (*xFinalize)(sqlite3_context*);                /* Aggregate finializer */

  char zName[1];       /* SQL name of the function.  MUST BE LAST */

};

/*

** Each SQLite module (virtual table definition) is defined by an

** instance of the following structure, stored in the sqlite3.aModule

** hash table.

*/

struct Module {

  const sqlite3_module *pModule;       /* Callback pointers */

  const char *zName;                   /* Name passed to create_module() */

  void *pAux;                          /* pAux passed to create_module() */

  void (*xDestroy)(void *);            /* Module destructor function */

};

/*

** Possible values for FuncDef.flags

*/

#define SQLITE_FUNC_LIKE   0x01  /* Candidate for the LIKE optimization */

#define SQLITE_FUNC_CASE   0x02  /* Case-sensitive LIKE-type function */

#define SQLITE_FUNC_EPHEM  0x04  /* Ephermeral.  Delete with VDBE */

/*

** information about each column of an SQL table is held in an instance

** of this structure.

*/

struct Column {

  char *zName;     /* Name of this column */

  Expr *pDflt;     /* Default value of this column */

  char *zType;     /* Data type for this column */

  char *zColl;     /* Collating sequence.  If NULL, use the default */

  u8 notNull;      /* True if there is a NOT NULL constraint */

  u8 isPrimKey;    /* True if this column is part of the PRIMARY KEY */

  char affinity;   /* One of the SQLITE_AFF_... values */

#ifndef SQLITE_OMIT_VIRTUALTABLE

  u8 isHidden;     /* True if this column is 'hidden' */

#endif

};

/*

** A "Collating Sequence" is defined by an instance of the following

** structure. Conceptually, a collating sequence consists of a name and

** a comparison routine that defines the order of that sequence.

**

** There may two seperate implementations of the collation function, one

** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that

** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine

** native byte order. When a collation sequence is invoked, SQLite selects

** the version that will require the least expensive encoding

** translations, if any.

**

** The CollSeq.pUser member variable is an extra parameter that passed in

** as the first argument to the UTF-8 comparison function, xCmp.

** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function,

** xCmp16.

**

** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the

** collating sequence is undefined.  Indices built on an undefined

** collating sequence may not be read or written.

*/

struct CollSeq {

  char *zName;          /* Name of the collating sequence, UTF-8 encoded */

  u8 enc;               /* Text encoding handled by xCmp() */

  u8 type;              /* One of the SQLITE_COLL_... values below */

  void *pUser;          /* First argument to xCmp() */

  int (*xCmp)(void*,int, const void*, int, const void*);

  void (*xDel)(void*);  /* Destructor for pUser */

};

/*

** Allowed values of CollSeq flags:

*/

#define SQLITE_COLL_BINARY  1  /* The default memcmp() collating sequence */

#define SQLITE_COLL_NOCASE  2  /* The built-in NOCASE collating sequence */

#define SQLITE_COLL_REVERSE 3  /* The built-in REVERSE collating sequence */

#define SQLITE_COLL_USER    0  /* Any other user-defined collating sequence */

/*

** A sort order can be either ASC or DESC.

*/

#define SQLITE_SO_ASC       0  /* Sort in ascending order */

#define SQLITE_SO_DESC      1  /* Sort in ascending order */

/*

** Column affinity types.

**

** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and

** 't' for SQLITE_AFF_TEXT.  But we can save a little space and improve

** the speed a little by number the values consecutively.  

**

** But rather than start with 0 or 1, we begin with 'a'.  That way,

** when multiple affinity types are concatenated into a string and

** used as the P3 operand, they will be more readable.

**

** Note also that the numeric types are grouped together so that testing

** for a numeric type is a single comparison.

*/

#define SQLITE_AFF_TEXT     'a'

#define SQLITE_AFF_NONE     'b'

#define SQLITE_AFF_NUMERIC  'c'

#define SQLITE_AFF_INTEGER  'd'

#define SQLITE_AFF_REAL     'e'

#define sqlite3IsNumericAffinity(X)  ((X)>=SQLITE_AFF_NUMERIC)

/*

** Each SQL table is represented in memory by an instance of the

** following structure.

**

** 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.

**

** 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 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.  Table.hasPrimKey is true if

** the table has any PRIMARY KEY, INTEGER or otherwise.

**

** 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.isEphem

** 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 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 

** of a SELECT statement.

*/

struct Table {

  char *zName;     /* Name of the table */

  int nCol;        /* Number of columns in this table */

  Column *aCol;    /* Information about each column */

  int iPKey;       /* If not less then 0, use aCol[iPKey] as the primary key */

  Index *pIndex;   /* List of SQL indexes on this table. */

  int tnum;        /* Root BTree node for this table (see note above) */

  Select *pSelect; /* NULL for tables.  Points to definition if a view. */

  int nRef;          /* Number of pointers to this Table */

  Trigger *pTrigger; /* List of SQL triggers on this table */

  FKey *pFKey;       /* Linked list of all foreign keys in this table */

  char *zColAff;     /* String defining the affinity of each column */

#ifndef SQLITE_OMIT_CHECK

  Expr *pCheck;      /* The AND of all CHECK constraints */

#endif

#ifndef SQLITE_OMIT_ALTERTABLE

  int addColOffset;  /* Offset in CREATE TABLE statement to add a new column */

#endif

  u8 readOnly;     /* True if this table should not be written by the user */

  u8 isEphem;      /* True if created using OP_OpenEphermeral */