/*** 2005 May 25**** 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.***************************************************************************** This file contains the implementation of the sqlite3_prepare()** interface, and routines that contribute to loading the database schema** from disk.**** $Id: prepare.c,v 1.33 2006/03/13 15:06:07 drh Exp $*/#include "sqliteInt.h"#include "os.h"#include <ctype.h>/*** Fill the InitData structure with an error message that indicates** that the database is corrupt.*/static void corruptSchema(InitData *pData, const char *zExtra){  if( !sqlite3MallocFailed() ){    sqlite3SetString(pData->pzErrMsg, "malformed database schema",       zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);  }}/*** This is the callback routine for the code that initializes the** database.  See sqlite3Init() below for additional information.** This routine is also called from the OP_ParseSchema opcode of the VDBE.**** Each callback contains the following information:****     argv[0] = name of thing being created**     argv[1] = root page number for table or index.  NULL for trigger or view.**     argv[2] = SQL text for the CREATE statement.**     argv[3] = "1" for temporary files, "0" for main database, "2" or more**               for auxiliary database files.***/int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){  InitData *pData = (InitData*)pInit;  sqlite3 *db = pData->db;  int iDb;  if( sqlite3MallocFailed() ){    return SQLITE_NOMEM;  }  assert( argc==4 );  if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */  if( argv[1]==0 || argv[3]==0 ){    corruptSchema(pData, 0);    return 1;  }  iDb = atoi(argv[3]);  assert( iDb>=0 && iDb<db->nDb );  if( argv[2] && argv[2][0] ){    /* Call the parser to process a CREATE TABLE, INDEX or VIEW.    ** But because db->init.busy is set to 1, no VDBE code is generated    ** or executed.  All the parser does is build the internal data    ** structures that describe the table, index, or view.    */    char *zErr;    int rc;    assert( db->init.busy );    db->init.iDb = iDb;    db->init.newTnum = atoi(argv[1]);    rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);    db->init.iDb = 0;    assert( rc!=SQLITE_OK || zErr==0 );    if( SQLITE_OK!=rc ){      if( rc==SQLITE_NOMEM ){        sqlite3FailedMalloc();      }else{        corruptSchema(pData, zErr);      }      sqlite3_free(zErr);      return rc;    }  }else{    /* If the SQL column is blank it means this is an index that    ** was created to be the PRIMARY KEY or to fulfill a UNIQUE    ** constraint for a CREATE TABLE.  The index should have already    ** been created when we processed the CREATE TABLE.  All we have    ** to do here is record the root page number for that index.    */    Index *pIndex;    pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);    if( pIndex==0 || pIndex->tnum!=0 ){      /* This can occur if there exists an index on a TEMP table which      ** has the same name as another index on a permanent index.  Since      ** the permanent table is hidden by the TEMP table, we can also      ** safely ignore the index on the permanent table.      */      /* Do Nothing */;    }else{      pIndex->tnum = atoi(argv[1]);    }  }  return 0;}/*** Attempt to read the database schema and initialize internal** data structures for a single database file.  The index of the** database file is given by iDb.  iDb==0 is used for the main** database.  iDb==1 should never be used.  iDb>=2 is used for** auxiliary databases.  Return one of the SQLITE_ error codes to** indicate success or failure.*/static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){  int rc;  BtCursor *curMain;  int size;  Table *pTab;  Db *pDb;  char const *azArg[5];  char zDbNum[30];  int meta[10];  InitData initData;  char const *zMasterSchema;  char const *zMasterName = SCHEMA_TABLE(iDb);  /*  ** The master database table has a structure like this  */  static const char master_schema[] =      "CREATE TABLE sqlite_master(\n"     "  type text,\n"     "  name text,\n"     "  tbl_name text,\n"     "  rootpage integer,\n"     "  sql text\n"     ")"  ;#ifndef SQLITE_OMIT_TEMPDB  static const char temp_master_schema[] =      "CREATE TEMP TABLE sqlite_temp_master(\n"     "  type text,\n"     "  name text,\n"     "  tbl_name text,\n"     "  rootpage integer,\n"     "  sql text\n"     ")"  ;#else  #define temp_master_schema 0#endif  assert( iDb>=0 && iDb<db->nDb );  assert( db->aDb[iDb].pSchema );  /* zMasterSchema and zInitScript are set to point at the master schema  ** and initialisation script appropriate for the database being  ** initialised. zMasterName is the name of the master table.  */  if( !OMIT_TEMPDB && iDb==1 ){    zMasterSchema = temp_master_schema;  }else{    zMasterSchema = master_schema;  }  zMasterName = SCHEMA_TABLE(iDb);  /* Construct the schema tables.  */  sqlite3SafetyOff(db);  azArg[0] = zMasterName;  azArg[1] = "1";  azArg[2] = zMasterSchema;  sprintf(zDbNum, "%d", iDb);  azArg[3] = zDbNum;  azArg[4] = 0;  initData.db = db;  initData.pzErrMsg = pzErrMsg;  rc = sqlite3InitCallback(&initData, 4, (char **)azArg, 0);  if( rc!=SQLITE_OK ){    sqlite3SafetyOn(db);    return rc;  }  pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);  if( pTab ){    pTab->readOnly = 1;  }  sqlite3SafetyOn(db);  /* Create a cursor to hold the database open  */  pDb = &db->aDb[iDb];  if( pDb->pBt==0 ){    if( !OMIT_TEMPDB && iDb==1 ){      DbSetProperty(db, 1, DB_SchemaLoaded);    }    return SQLITE_OK;  }  rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain);  if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){    sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);    return rc;  }  /* Get the database meta information.  **  ** Meta values are as follows:  **    meta[0]   Schema cookie.  Changes with each schema change.  **    meta[1]   File format of schema layer.  **    meta[2]   Size of the page cache.  **    meta[3]   Use freelist if 0.  Autovacuum if greater than zero.  **    meta[4]   Db text encoding. 1:UTF-8 3:UTF-16 LE 4:UTF-16 BE  **    meta[5]   The user cookie. Used by the application.  **    meta[6]     **    meta[7]  **    meta[8]  **    meta[9]  **  ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to  ** the possible values of meta[4].  */  if( rc==SQLITE_OK ){    int i;    for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){      rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);    }    if( rc ){      sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);      sqlite3BtreeCloseCursor(curMain);      return rc;    }  }else{    memset(meta, 0, sizeof(meta));  }  pDb->pSchema->schema_cookie = meta[0];  /* If opening a non-empty database, check the text encoding. For the  ** main database, set sqlite3.enc to the encoding of the main database.  ** For an attached db, it is an error if the encoding is not the same  ** as sqlite3.enc.  */  if( meta[4] ){  /* text encoding */    if( iDb==0 ){      /* If opening the main database, set ENC(db). */      ENC(db) = (u8)meta[4];      db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);    }else{      /* If opening an attached database, the encoding much match ENC(db) */      if( meta[4]!=ENC(db) ){        sqlite3BtreeCloseCursor(curMain);        sqlite3SetString(pzErrMsg, "attached databases must use the same"            " text encoding as main database", (char*)0);        return SQLITE_ERROR;      }    }  }else{    DbSetProperty(db, iDb, DB_Empty);  }  pDb->pSchema->enc = ENC(db);  size = meta[2];  if( size==0 ){ size = MAX_PAGES; }  pDb->pSchema->cache_size = size;  sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);  /*  ** file_format==1    Version 3.0.0.  ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN  ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults  ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants  */  pDb->pSchema->file_format = meta[1];  if( pDb->pSchema->file_format==0 ){    pDb->pSchema->file_format = 1;  }  if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){    sqlite3BtreeCloseCursor(curMain);    sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);    return SQLITE_ERROR;  }  /* Read the schema information out of the schema tables  */  assert( db->init.busy );  if( rc==SQLITE_EMPTY ){    /* For an empty database, there is nothing to read */    rc = SQLITE_OK;  }else{    char *zSql;