/*** 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.***************************************************************************** Main file for the SQLite library.  The routines in this file** implement the programmer interface to the library.  Routines in** other files are for internal use by SQLite and should not be** accessed by users of the library.**** $Id: main.c,v 1.339 2006/03/16 16:19:56 drh Exp $*/#include "sqliteInt.h"#include "os.h"#include <ctype.h>/*** The following constant value is used by the SQLITE_BIGENDIAN and** SQLITE_LITTLEENDIAN macros.*/const int sqlite3one = 1;/*** The version of the library*/const char sqlite3_version[] = SQLITE_VERSION;const char *sqlite3_libversion(void){ return sqlite3_version; }int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }/*** This is the default collating function named "BINARY" which is always** available.*/static int binCollFunc(  void *NotUsed,  int nKey1, const void *pKey1,  int nKey2, const void *pKey2){  int rc, n;  n = nKey1<nKey2 ? nKey1 : nKey2;  rc = memcmp(pKey1, pKey2, n);  if( rc==0 ){    rc = nKey1 - nKey2;  }  return rc;}/*** Another built-in collating sequence: NOCASE. **** This collating sequence is intended to be used for "case independant** comparison". SQLite's knowledge of upper and lower case equivalents** extends only to the 26 characters used in the English language.**** At the moment there is only a UTF-8 implementation.*/static int nocaseCollatingFunc(  void *NotUsed,  int nKey1, const void *pKey1,  int nKey2, const void *pKey2){  int r = sqlite3StrNICmp(      (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);  if( 0==r ){    r = nKey1-nKey2;  }  return r;}/*** Return the ROWID of the most recent insert*/sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){  return db->lastRowid;}/*** Return the number of changes in the most recent call to sqlite3_exec().*/int sqlite3_changes(sqlite3 *db){  return db->nChange;}/*** Return the number of changes since the database handle was opened.*/int sqlite3_total_changes(sqlite3 *db){  return db->nTotalChange;}/*** Close an existing SQLite database*/int sqlite3_close(sqlite3 *db){  HashElem *i;  int j;  if( !db ){    return SQLITE_OK;  }  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }#ifdef SQLITE_SSE  {    extern void sqlite3SseCleanup(sqlite3*);    sqlite3SseCleanup(db);  }#endif   /* If there are any outstanding VMs, return SQLITE_BUSY. */  if( db->pVdbe ){    sqlite3Error(db, SQLITE_BUSY,         "Unable to close due to unfinalised statements");    return SQLITE_BUSY;  }  assert( !sqlite3SafetyCheck(db) );  /* FIX ME: db->magic may be set to SQLITE_MAGIC_CLOSED if the database  ** cannot be opened for some reason. So this routine needs to run in  ** that case. But maybe there should be an extra magic value for the  ** "failed to open" state.  */  if( db->magic!=SQLITE_MAGIC_CLOSED && sqlite3SafetyOn(db) ){    /* printf("DID NOT CLOSE\n"); fflush(stdout); */    return SQLITE_ERROR;  }  for(j=0; j<db->nDb; j++){    struct Db *pDb = &db->aDb[j];    if( pDb->pBt ){      sqlite3BtreeClose(pDb->pBt);      pDb->pBt = 0;      if( j!=1 ){        pDb->pSchema = 0;      }    }  }  sqlite3ResetInternalSchema(db, 0);  assert( db->nDb<=2 );  assert( db->aDb==db->aDbStatic );  for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){    FuncDef *pFunc, *pNext;    for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){      pNext = pFunc->pNext;      sqliteFree(pFunc);    }  }  for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){    CollSeq *pColl = (CollSeq *)sqliteHashData(i);    sqliteFree(pColl);  }  sqlite3HashClear(&db->aCollSeq);  sqlite3HashClear(&db->aFunc);  sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */  if( db->pErr ){    sqlite3ValueFree(db->pErr);  }  db->magic = SQLITE_MAGIC_ERROR;  /* The temp-database schema is allocated differently from the other schema  ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).  ** So it needs to be freed here. Todo: Why not roll the temp schema into  ** the same sqliteMalloc() as the one that allocates the database   ** structure?  */  sqliteFree(db->aDb[1].pSchema);  sqliteFree(db);  sqlite3ReleaseThreadData();  return SQLITE_OK;}/*** Rollback all database files.*/void sqlite3RollbackAll(sqlite3 *db){  int i;  int inTrans = 0;  for(i=0; i<db->nDb; i++){    if( db->aDb[i].pBt ){      if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){        inTrans = 1;      }      sqlite3BtreeRollback(db->aDb[i].pBt);      db->aDb[i].inTrans = 0;    }  }  if( db->flags&SQLITE_InternChanges ){    sqlite3ResetInternalSchema(db, 0);  }  /* If one has been configured, invoke the rollback-hook callback */  if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){    db->xRollbackCallback(db->pRollbackArg);  }}/*** Return a static string that describes the kind of error specified in the** argument.*/const char *sqlite3ErrStr(int rc){  const char *z;  switch( rc ){    case SQLITE_ROW:    case SQLITE_DONE:    case SQLITE_OK:         z = "not an error";                          break;    case SQLITE_ERROR:      z = "SQL logic error or missing database";   break;    case SQLITE_PERM:       z = "access permission denied";              break;    case SQLITE_ABORT:      z = "callback requested query abort";        break;    case SQLITE_BUSY:       z = "database is locked";                    break;    case SQLITE_LOCKED:     z = "database table is locked";              break;    case SQLITE_NOMEM:      z = "out of memory";                         break;    case SQLITE_READONLY:   z = "attempt to write a readonly database";  break;    case SQLITE_INTERRUPT:  z = "interrupted";                           break;    case SQLITE_IOERR:      z = "disk I/O error";                        break;    case SQLITE_CORRUPT:    z = "database disk image is malformed";      break;    case SQLITE_FULL:       z = "database or disk is full";              break;    case SQLITE_CANTOPEN:   z = "unable to open database file";          break;    case SQLITE_PROTOCOL:   z = "database locking protocol failure";     break;    case SQLITE_EMPTY:      z = "table contains no data";                break;    case SQLITE_SCHEMA:     z = "database schema has changed";           break;    case SQLITE_CONSTRAINT: z = "constraint failed";                     break;    case SQLITE_MISMATCH:   z = "datatype mismatch";                     break;    case SQLITE_MISUSE:     z = "library routine called out of sequence";break;    case SQLITE_NOLFS:      z = "kernel lacks large file support";       break;    case SQLITE_AUTH:       z = "authorization denied";                  break;    case SQLITE_FORMAT:     z = "auxiliary database format error";       break;    case SQLITE_RANGE:      z = "bind or column index out of range";     break;    case SQLITE_NOTADB:     z = "file is encrypted or is not a database";break;    default:                z = "unknown error";                         break;  }  return z;}/*** This routine implements a busy callback that sleeps and tries** again until a timeout value is reached.  The timeout value is** an integer number of milliseconds passed in as the first** argument.*/static int sqliteDefaultBusyCallback( void *ptr,               /* Database connection */ int count                /* Number of times table has been busy */){#if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)  static const u8 delays[] =     { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };  static const u8 totals[] =     { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };# define NDELAY (sizeof(delays)/sizeof(delays[0]))  int timeout = ((sqlite3 *)ptr)->busyTimeout;  int delay, prior;  assert( count>=0 );  if( count < NDELAY ){    delay = delays[count];    prior = totals[count];  }else{    delay = delays[NDELAY-1];    prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));  }  if( prior + delay > timeout ){    delay = timeout - prior;    if( delay<=0 ) return 0;  }  sqlite3OsSleep(delay);  return 1;#else  int timeout = ((sqlite3 *)ptr)->busyTimeout;  if( (count+1)*1000 > timeout ){    return 0;  }  sqlite3OsSleep(1000);  return 1;#endif}/*** Invoke the given busy handler.**** This routine is called when an operation failed with a lock.** If this routine returns non-zero, the lock is retried.  If it** returns 0, the operation aborts with an SQLITE_BUSY error.*/int sqlite3InvokeBusyHandler(BusyHandler *p){  int rc;  if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0;  rc = p->xFunc(p->pArg, p->nBusy);  if( rc==0 ){    p->nBusy = -1;  }else{    p->nBusy++;  }  return rc; }/*** This routine sets the busy callback for an Sqlite database to the** given callback function with the given argument.*/int sqlite3_busy_handler(  sqlite3 *db,  int (*xBusy)(void*,int),  void *pArg){  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  db->busyHandler.xFunc = xBusy;  db->busyHandler.pArg = pArg;  db->busyHandler.nBusy = 0;  return SQLITE_OK;}#ifndef SQLITE_OMIT_PROGRESS_CALLBACK/*** This routine sets the progress callback for an Sqlite database to the** given callback function with the given argument. The progress callback will** be invoked every nOps opcodes.*/void sqlite3_progress_handler(  sqlite3 *db,   int nOps,  int (*xProgress)(void*),   void *pArg){  if( !sqlite3SafetyCheck(db) ){    if( nOps>0 ){      db->xProgress = xProgress;      db->nProgressOps = nOps;      db->pProgressArg = pArg;    }else{      db->xProgress = 0;      db->nProgressOps = 0;      db->pProgressArg = 0;    }  }}#endif/*** This routine installs a default busy handler that waits for the** specified number of milliseconds before returning 0.*/int sqlite3_busy_timeout(sqlite3 *db, int ms){  if( ms>0 ){    db->busyTimeout = ms;    sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);  }else{    sqlite3_busy_handler(db, 0, 0);  }  return SQLITE_OK;}/*** Cause any pending operation to stop at its earliest opportunity.*/void sqlite3_interrupt(sqlite3 *db){  if( !sqlite3SafetyCheck(db) ){    db->flags |= SQLITE_Interrupt;  }}/*** Windows systems should call this routine to free memory that** is returned in the in the errmsg parameter of sqlite3_open() when** SQLite is a DLL.  For some reason, it does not work to call free()** directly.**** Note that we need to call free() not sqliteFree() here.*/void sqlite3_free(char *p){ free(p); }/*** This function is exactly the same as sqlite3_create_function(), except** that it is designed to be called by internal code. The difference is** that if a malloc() fails in sqlite3_create_function(), an error code** is returned and the mallocFailed flag cleared. */int sqlite3CreateFunc(  sqlite3 *db,  const char *zFunctionName,  int nArg,  int enc,  void *pUserData,  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),  void (*xStep)(sqlite3_context*,int,sqlite3_value **),  void (*xFinal)(sqlite3_context*)){  FuncDef *p;  int nName;  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  if( zFunctionName==0 ||      (xFunc && (xFinal || xStep)) ||       (!xFunc && (xFinal && !xStep)) ||      (!xFunc && (!xFinal && xStep)) ||