/*

** 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: sqliteInt.h,v 1.529 2006/09/23 20:36:02 drh Exp $

*/

#ifndef _SQLITEINT_H_

#define _SQLITEINT_H_

#include <e32def.h>

/*

** Extra interface definitions for those who need them

*/

#ifdef SQLITE_EXTRA

# include "sqliteExtra.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 <libc/stddef.h>

/*

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

#endif

#ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (1e99)

#endif

/*

** The maximum number of in-memory pages to use for the main database

** table and for temporary tables. Internally, the MAX_PAGES and 

** TEMP_PAGES macros are used. To override the default values at

** compilation time, the SQLITE_DEFAULT_CACHE_SIZE and 

** SQLITE_DEFAULT_TEMP_CACHE_SIZE macros should be set.

*/

#ifdef SQLITE_DEFAULT_CACHE_SIZE

# define MAX_PAGES SQLITE_DEFAULT_CACHE_SIZE

#else

# define MAX_PAGES   2000

#endif

#ifdef SQLITE_DEFAULT_TEMP_CACHE_SIZE

# define TEMP_PAGES SQLITE_DEFAULT_TEMP_CACHE_SIZE

#else

# define TEMP_PAGES   500

#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 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 32 because

** we use a bitmask of databases with a u32 in places (for example

** the Parse.cookieMask field).

*/

#define MAX_ATTACHED 10

/*

** The maximum value of a ?nnn wildcard that the parser will accept.

*/

#define SQLITE_MAX_VARIABLE_NUMBER 999

/*

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

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

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

/*

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

#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;

/*

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

*/

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

};

/*

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

#define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

/*

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

  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

};

/*

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