main.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:48k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2001 September 15
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** Main file for the SQLite library.  The routines in this file
  13. ** implement the programmer interface to the library.  Routines in
  14. ** other files are for internal use by SQLite and should not be
  15. ** accessed by users of the library.
  16. **
  17. ** $Id: main.c,v 1.434 2008/04/16 00:49:12 drh Exp $
  18. */
  19. #include "sqliteInt.h"
  20. #include <ctype.h>
  21. #ifdef SQLITE_ENABLE_FTS3
  22. # include "fts3.h"
  23. #endif
  24. /*
  25. ** The version of the library
  26. */
  27. const char sqlite3_version[] = SQLITE_VERSION;
  28. const char *sqlite3_libversion(void){ return sqlite3_version; }
  29. int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
  30. int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
  31. /*
  32. ** If the following function pointer is not NULL and if
  33. ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
  34. ** I/O active are written using this function.  These messages
  35. ** are intended for debugging activity only.
  36. */
  37. void (*sqlite3IoTrace)(const char*, ...) = 0;
  38. /*
  39. ** If the following global variable points to a string which is the
  40. ** name of a directory, then that directory will be used to store
  41. ** temporary files.
  42. **
  43. ** See also the "PRAGMA temp_store_directory" SQL command.
  44. */
  45. char *sqlite3_temp_directory = 0;
  46. /*
  47. ** Routine needed to support the testcase() macro.
  48. */
  49. #ifdef SQLITE_COVERAGE_TEST
  50. void sqlite3Coverage(int x){
  51.   static int dummy = 0;
  52.   dummy += x;
  53. }
  54. #endif
  55. /*
  56. ** Return true if the buffer z[0..n-1] contains all spaces.
  57. */
  58. static int allSpaces(const char *z, int n){
  59.   while( n>0 && z[n-1]==' ' ){ n--; }
  60.   return n==0;
  61. }
  62. /*
  63. ** This is the default collating function named "BINARY" which is always
  64. ** available.
  65. **
  66. ** If the padFlag argument is not NULL then space padding at the end
  67. ** of strings is ignored.  This implements the RTRIM collation.
  68. */
  69. static int binCollFunc(
  70.   void *padFlag,
  71.   int nKey1, const void *pKey1,
  72.   int nKey2, const void *pKey2
  73. ){
  74.   int rc, n;
  75.   n = nKey1<nKey2 ? nKey1 : nKey2;
  76.   rc = memcmp(pKey1, pKey2, n);
  77.   if( rc==0 ){
  78.     if( padFlag
  79.      && allSpaces(((char*)pKey1)+n, nKey1-n)
  80.      && allSpaces(((char*)pKey2)+n, nKey2-n)
  81.     ){
  82.       /* Leave rc unchanged at 0 */
  83.     }else{
  84.       rc = nKey1 - nKey2;
  85.     }
  86.   }
  87.   return rc;
  88. }
  89. /*
  90. ** Another built-in collating sequence: NOCASE. 
  91. **
  92. ** This collating sequence is intended to be used for "case independant
  93. ** comparison". SQLite's knowledge of upper and lower case equivalents
  94. ** extends only to the 26 characters used in the English language.
  95. **
  96. ** At the moment there is only a UTF-8 implementation.
  97. */
  98. static int nocaseCollatingFunc(
  99.   void *NotUsed,
  100.   int nKey1, const void *pKey1,
  101.   int nKey2, const void *pKey2
  102. ){
  103.   int r = sqlite3StrNICmp(
  104.       (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
  105.   if( 0==r ){
  106.     r = nKey1-nKey2;
  107.   }
  108.   return r;
  109. }
  110. /*
  111. ** Return the ROWID of the most recent insert
  112. */
  113. sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
  114.   return db->lastRowid;
  115. }
  116. /*
  117. ** Return the number of changes in the most recent call to sqlite3_exec().
  118. */
  119. int sqlite3_changes(sqlite3 *db){
  120.   return db->nChange;
  121. }
  122. /*
  123. ** Return the number of changes since the database handle was opened.
  124. */
  125. int sqlite3_total_changes(sqlite3 *db){
  126.   return db->nTotalChange;
  127. }
  128. /*
  129. ** Close an existing SQLite database
  130. */
  131. int sqlite3_close(sqlite3 *db){
  132.   HashElem *i;
  133.   int j;
  134.   if( !db ){
  135.     return SQLITE_OK;
  136.   }
  137.   if( !sqlite3SafetyCheckSickOrOk(db) ){
  138.     return SQLITE_MISUSE;
  139.   }
  140.   sqlite3_mutex_enter(db->mutex);
  141. #ifdef SQLITE_SSE
  142.   {
  143.     extern void sqlite3SseCleanup(sqlite3*);
  144.     sqlite3SseCleanup(db);
  145.   }
  146. #endif 
  147.   sqlite3ResetInternalSchema(db, 0);
  148.   /* If a transaction is open, the ResetInternalSchema() call above
  149.   ** will not have called the xDisconnect() method on any virtual
  150.   ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
  151.   ** call will do so. We need to do this before the check for active
  152.   ** SQL statements below, as the v-table implementation may be storing
  153.   ** some prepared statements internally.
  154.   */
  155.   sqlite3VtabRollback(db);
  156.   /* If there are any outstanding VMs, return SQLITE_BUSY. */
  157.   if( db->pVdbe ){
  158.     sqlite3Error(db, SQLITE_BUSY, 
  159.         "Unable to close due to unfinalised statements");
  160.     sqlite3_mutex_leave(db->mutex);
  161.     return SQLITE_BUSY;
  162.   }
  163.   assert( sqlite3SafetyCheckSickOrOk(db) );
  164.   for(j=0; j<db->nDb; j++){
  165.     struct Db *pDb = &db->aDb[j];
  166.     if( pDb->pBt ){
  167.       sqlite3BtreeClose(pDb->pBt);
  168.       pDb->pBt = 0;
  169.       if( j!=1 ){
  170.         pDb->pSchema = 0;
  171.       }
  172.     }
  173.   }
  174.   sqlite3ResetInternalSchema(db, 0);
  175.   assert( db->nDb<=2 );
  176.   assert( db->aDb==db->aDbStatic );
  177.   for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
  178.     FuncDef *pFunc, *pNext;
  179.     for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
  180.       pNext = pFunc->pNext;
  181.       sqlite3_free(pFunc);
  182.     }
  183.   }
  184.   for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
  185.     CollSeq *pColl = (CollSeq *)sqliteHashData(i);
  186.     /* Invoke any destructors registered for collation sequence user data. */
  187.     for(j=0; j<3; j++){
  188.       if( pColl[j].xDel ){
  189.         pColl[j].xDel(pColl[j].pUser);
  190.       }
  191.     }
  192.     sqlite3_free(pColl);
  193.   }
  194.   sqlite3HashClear(&db->aCollSeq);
  195. #ifndef SQLITE_OMIT_VIRTUALTABLE
  196.   for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
  197.     Module *pMod = (Module *)sqliteHashData(i);
  198.     if( pMod->xDestroy ){
  199.       pMod->xDestroy(pMod->pAux);
  200.     }
  201.     sqlite3_free(pMod);
  202.   }
  203.   sqlite3HashClear(&db->aModule);
  204. #endif
  205.   sqlite3HashClear(&db->aFunc);
  206.   sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
  207.   if( db->pErr ){
  208.     sqlite3ValueFree(db->pErr);
  209.   }
  210.   sqlite3CloseExtensions(db);
  211.   db->magic = SQLITE_MAGIC_ERROR;
  212.   /* The temp-database schema is allocated differently from the other schema
  213.   ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
  214.   ** So it needs to be freed here. Todo: Why not roll the temp schema into
  215.   ** the same sqliteMalloc() as the one that allocates the database 
  216.   ** structure?
  217.   */
  218.   sqlite3_free(db->aDb[1].pSchema);
  219.   sqlite3_mutex_leave(db->mutex);
  220.   db->magic = SQLITE_MAGIC_CLOSED;
  221.   sqlite3_mutex_free(db->mutex);
  222.   sqlite3_free(db);
  223.   return SQLITE_OK;
  224. }
  225. /*
  226. ** Rollback all database files.
  227. */
  228. void sqlite3RollbackAll(sqlite3 *db){
  229.   int i;
  230.   int inTrans = 0;
  231.   assert( sqlite3_mutex_held(db->mutex) );
  232.   sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 1);
  233.   for(i=0; i<db->nDb; i++){
  234.     if( db->aDb[i].pBt ){
  235.       if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
  236.         inTrans = 1;
  237.       }
  238.       sqlite3BtreeRollback(db->aDb[i].pBt);
  239.       db->aDb[i].inTrans = 0;
  240.     }
  241.   }
  242.   sqlite3VtabRollback(db);
  243.   sqlite3FaultBenign(SQLITE_FAULTINJECTOR_MALLOC, 0);
  244.   if( db->flags&SQLITE_InternChanges ){
  245.     sqlite3ExpirePreparedStatements(db);
  246.     sqlite3ResetInternalSchema(db, 0);
  247.   }
  248.   /* If one has been configured, invoke the rollback-hook callback */
  249.   if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
  250.     db->xRollbackCallback(db->pRollbackArg);
  251.   }
  252. }
  253. /*
  254. ** Return a static string that describes the kind of error specified in the
  255. ** argument.
  256. */
  257. const char *sqlite3ErrStr(int rc){
  258.   const char *z;
  259.   switch( rc & 0xff ){
  260.     case SQLITE_ROW:
  261.     case SQLITE_DONE:
  262.     case SQLITE_OK:         z = "not an error";                          break;
  263.     case SQLITE_ERROR:      z = "SQL logic error or missing database";   break;
  264.     case SQLITE_PERM:       z = "access permission denied";              break;
  265.     case SQLITE_ABORT:      z = "callback requested query abort";        break;
  266.     case SQLITE_BUSY:       z = "database is locked";                    break;
  267.     case SQLITE_LOCKED:     z = "database table is locked";              break;
  268.     case SQLITE_NOMEM:      z = "out of memory";                         break;
  269.     case SQLITE_READONLY:   z = "attempt to write a readonly database";  break;
  270.     case SQLITE_INTERRUPT:  z = "interrupted";                           break;
  271.     case SQLITE_IOERR:      z = "disk I/O error";                        break;
  272.     case SQLITE_CORRUPT:    z = "database disk image is malformed";      break;
  273.     case SQLITE_FULL:       z = "database or disk is full";              break;
  274.     case SQLITE_CANTOPEN:   z = "unable to open database file";          break;
  275.     case SQLITE_EMPTY:      z = "table contains no data";                break;
  276.     case SQLITE_SCHEMA:     z = "database schema has changed";           break;
  277.     case SQLITE_TOOBIG:     z = "String or BLOB exceeded size limit";    break;
  278.     case SQLITE_CONSTRAINT: z = "constraint failed";                     break;
  279.     case SQLITE_MISMATCH:   z = "datatype mismatch";                     break;
  280.     case SQLITE_MISUSE:     z = "library routine called out of sequence";break;
  281.     case SQLITE_NOLFS:      z = "kernel lacks large file support";       break;
  282.     case SQLITE_AUTH:       z = "authorization denied";                  break;
  283.     case SQLITE_FORMAT:     z = "auxiliary database format error";       break;
  284.     case SQLITE_RANGE:      z = "bind or column index out of range";     break;
  285.     case SQLITE_NOTADB:     z = "file is encrypted or is not a database";break;
  286.     default:                z = "unknown error";                         break;
  287.   }
  288.   return z;
  289. }
  290. /*
  291. ** This routine implements a busy callback that sleeps and tries
  292. ** again until a timeout value is reached.  The timeout value is
  293. ** an integer number of milliseconds passed in as the first
  294. ** argument.
  295. */
  296. static int sqliteDefaultBusyCallback(
  297.  void *ptr,               /* Database connection */
  298.  int count                /* Number of times table has been busy */
  299. ){
  300. #if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
  301.   static const u8 delays[] =
  302.      { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
  303.   static const u8 totals[] =
  304.      { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
  305. # define NDELAY (sizeof(delays)/sizeof(delays[0]))
  306.   sqlite3 *db = (sqlite3 *)ptr;
  307.   int timeout = db->busyTimeout;
  308.   int delay, prior;
  309.   assert( count>=0 );
  310.   if( count < NDELAY ){
  311.     delay = delays[count];
  312.     prior = totals[count];
  313.   }else{
  314.     delay = delays[NDELAY-1];
  315.     prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
  316.   }
  317.   if( prior + delay > timeout ){
  318.     delay = timeout - prior;
  319.     if( delay<=0 ) return 0;
  320.   }
  321.   sqlite3OsSleep(db->pVfs, delay*1000);
  322.   return 1;
  323. #else
  324.   sqlite3 *db = (sqlite3 *)ptr;
  325.   int timeout = ((sqlite3 *)ptr)->busyTimeout;
  326.   if( (count+1)*1000 > timeout ){
  327.     return 0;
  328.   }
  329.   sqlite3OsSleep(db->pVfs, 1000000);
  330.   return 1;
  331. #endif
  332. }
  333. /*
  334. ** Invoke the given busy handler.
  335. **
  336. ** This routine is called when an operation failed with a lock.
  337. ** If this routine returns non-zero, the lock is retried.  If it
  338. ** returns 0, the operation aborts with an SQLITE_BUSY error.
  339. */
  340. int sqlite3InvokeBusyHandler(BusyHandler *p){
  341.   int rc;
  342.   if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0;
  343.   rc = p->xFunc(p->pArg, p->nBusy);
  344.   if( rc==0 ){
  345.     p->nBusy = -1;
  346.   }else{
  347.     p->nBusy++;
  348.   }
  349.   return rc; 
  350. }
  351. /*
  352. ** This routine sets the busy callback for an Sqlite database to the
  353. ** given callback function with the given argument.
  354. */
  355. int sqlite3_busy_handler(
  356.   sqlite3 *db,
  357.   int (*xBusy)(void*,int),
  358.   void *pArg
  359. ){
  360.   sqlite3_mutex_enter(db->mutex);
  361.   db->busyHandler.xFunc = xBusy;
  362.   db->busyHandler.pArg = pArg;
  363.   db->busyHandler.nBusy = 0;
  364.   sqlite3_mutex_leave(db->mutex);
  365.   return SQLITE_OK;
  366. }
  367. #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  368. /*
  369. ** This routine sets the progress callback for an Sqlite database to the
  370. ** given callback function with the given argument. The progress callback will
  371. ** be invoked every nOps opcodes.
  372. */
  373. void sqlite3_progress_handler(
  374.   sqlite3 *db, 
  375.   int nOps,
  376.   int (*xProgress)(void*), 
  377.   void *pArg
  378. ){
  379.   if( sqlite3SafetyCheckOk(db) ){
  380.     sqlite3_mutex_enter(db->mutex);
  381.     if( nOps>0 ){
  382.       db->xProgress = xProgress;
  383.       db->nProgressOps = nOps;
  384.       db->pProgressArg = pArg;
  385.     }else{
  386.       db->xProgress = 0;
  387.       db->nProgressOps = 0;
  388.       db->pProgressArg = 0;
  389.     }
  390.     sqlite3_mutex_leave(db->mutex);
  391.   }
  392. }
  393. #endif
  394. /*
  395. ** This routine installs a default busy handler that waits for the
  396. ** specified number of milliseconds before returning 0.
  397. */
  398. int sqlite3_busy_timeout(sqlite3 *db, int ms){
  399.   if( ms>0 ){
  400.     db->busyTimeout = ms;
  401.     sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
  402.   }else{
  403.     sqlite3_busy_handler(db, 0, 0);
  404.   }
  405.   return SQLITE_OK;
  406. }
  407. /*
  408. ** Cause any pending operation to stop at its earliest opportunity.
  409. */
  410. void sqlite3_interrupt(sqlite3 *db){
  411.   if( sqlite3SafetyCheckOk(db) ){
  412.     db->u1.isInterrupted = 1;
  413.   }
  414. }
  415. /*
  416. ** This function is exactly the same as sqlite3_create_function(), except
  417. ** that it is designed to be called by internal code. The difference is
  418. ** that if a malloc() fails in sqlite3_create_function(), an error code
  419. ** is returned and the mallocFailed flag cleared. 
  420. */
  421. int sqlite3CreateFunc(
  422.   sqlite3 *db,
  423.   const char *zFunctionName,
  424.   int nArg,
  425.   int enc,
  426.   void *pUserData,
  427.   void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
  428.   void (*xStep)(sqlite3_context*,int,sqlite3_value **),
  429.   void (*xFinal)(sqlite3_context*)
  430. ){
  431.   FuncDef *p;
  432.   int nName;
  433.   assert( sqlite3_mutex_held(db->mutex) );
  434.   if( zFunctionName==0 ||
  435.       (xFunc && (xFinal || xStep)) || 
  436.       (!xFunc && (xFinal && !xStep)) ||
  437.       (!xFunc && (!xFinal && xStep)) ||
  438.       (nArg<-1 || nArg>127) ||
  439.       (255<(nName = strlen(zFunctionName))) ){
  440.     sqlite3Error(db, SQLITE_ERROR, "bad parameters");
  441.     return SQLITE_ERROR;
  442.   }
  443.   
  444. #ifndef SQLITE_OMIT_UTF16
  445.   /* If SQLITE_UTF16 is specified as the encoding type, transform this
  446.   ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
  447.   ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
  448.   **
  449.   ** If SQLITE_ANY is specified, add three versions of the function
  450.   ** to the hash table.
  451.   */
  452.   if( enc==SQLITE_UTF16 ){
  453.     enc = SQLITE_UTF16NATIVE;
  454.   }else if( enc==SQLITE_ANY ){
  455.     int rc;
  456.     rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
  457.          pUserData, xFunc, xStep, xFinal);
  458.     if( rc==SQLITE_OK ){
  459.       rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
  460.           pUserData, xFunc, xStep, xFinal);
  461.     }
  462.     if( rc!=SQLITE_OK ){
  463.       return rc;
  464.     }
  465.     enc = SQLITE_UTF16BE;
  466.   }
  467. #else
  468.   enc = SQLITE_UTF8;
  469. #endif
  470.   
  471.   /* Check if an existing function is being overridden or deleted. If so,
  472.   ** and there are active VMs, then return SQLITE_BUSY. If a function
  473.   ** is being overridden/deleted but there are no active VMs, allow the
  474.   ** operation to continue but invalidate all precompiled statements.
  475.   */
  476.   p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
  477.   if( p && p->iPrefEnc==enc && p->nArg==nArg ){
  478.     if( db->activeVdbeCnt ){
  479.       sqlite3Error(db, SQLITE_BUSY, 
  480.         "Unable to delete/modify user-function due to active statements");
  481.       assert( !db->mallocFailed );
  482.       return SQLITE_BUSY;
  483.     }else{
  484.       sqlite3ExpirePreparedStatements(db);
  485.     }
  486.   }
  487.   p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
  488.   assert(p || db->mallocFailed);
  489.   if( !p ){
  490.     return SQLITE_NOMEM;
  491.   }
  492.   p->flags = 0;
  493.   p->xFunc = xFunc;
  494.   p->xStep = xStep;
  495.   p->xFinalize = xFinal;
  496.   p->pUserData = pUserData;
  497.   p->nArg = nArg;
  498.   return SQLITE_OK;
  499. }
  500. /*
  501. ** Create new user functions.
  502. */
  503. int sqlite3_create_function(
  504.   sqlite3 *db,
  505.   const char *zFunctionName,
  506.   int nArg,
  507.   int enc,
  508.   void *p,
  509.   void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
  510.   void (*xStep)(sqlite3_context*,int,sqlite3_value **),
  511.   void (*xFinal)(sqlite3_context*)
  512. ){
  513.   int rc;
  514.   sqlite3_mutex_enter(db->mutex);
  515.   rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
  516.   rc = sqlite3ApiExit(db, rc);
  517.   sqlite3_mutex_leave(db->mutex);
  518.   return rc;
  519. }
  520. #ifndef SQLITE_OMIT_UTF16
  521. int sqlite3_create_function16(
  522.   sqlite3 *db,
  523.   const void *zFunctionName,
  524.   int nArg,
  525.   int eTextRep,
  526.   void *p,
  527.   void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
  528.   void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  529.   void (*xFinal)(sqlite3_context*)
  530. ){
  531.   int rc;
  532.   char *zFunc8;
  533.   sqlite3_mutex_enter(db->mutex);
  534.   assert( !db->mallocFailed );
  535.   zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
  536.   rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
  537.   sqlite3_free(zFunc8);
  538.   rc = sqlite3ApiExit(db, rc);
  539.   sqlite3_mutex_leave(db->mutex);
  540.   return rc;
  541. }
  542. #endif
  543. /*
  544. ** Declare that a function has been overloaded by a virtual table.
  545. **
  546. ** If the function already exists as a regular global function, then
  547. ** this routine is a no-op.  If the function does not exist, then create
  548. ** a new one that always throws a run-time error.  
  549. **
  550. ** When virtual tables intend to provide an overloaded function, they
  551. ** should call this routine to make sure the global function exists.
  552. ** A global function must exist in order for name resolution to work
  553. ** properly.
  554. */
  555. int sqlite3_overload_function(
  556.   sqlite3 *db,
  557.   const char *zName,
  558.   int nArg
  559. ){
  560.   int nName = strlen(zName);
  561.   int rc;
  562.   sqlite3_mutex_enter(db->mutex);
  563.   if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
  564.     sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
  565.                       0, sqlite3InvalidFunction, 0, 0);
  566.   }
  567.   rc = sqlite3ApiExit(db, SQLITE_OK);
  568.   sqlite3_mutex_leave(db->mutex);
  569.   return rc;
  570. }
  571. #ifndef SQLITE_OMIT_TRACE
  572. /*
  573. ** Register a trace function.  The pArg from the previously registered trace
  574. ** is returned.  
  575. **
  576. ** A NULL trace function means that no tracing is executes.  A non-NULL
  577. ** trace is a pointer to a function that is invoked at the start of each
  578. ** SQL statement.
  579. */
  580. void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
  581.   void *pOld;
  582.   sqlite3_mutex_enter(db->mutex);
  583.   pOld = db->pTraceArg;
  584.   db->xTrace = xTrace;
  585.   db->pTraceArg = pArg;
  586.   sqlite3_mutex_leave(db->mutex);
  587.   return pOld;
  588. }
  589. /*
  590. ** Register a profile function.  The pArg from the previously registered 
  591. ** profile function is returned.  
  592. **
  593. ** A NULL profile function means that no profiling is executes.  A non-NULL
  594. ** profile is a pointer to a function that is invoked at the conclusion of
  595. ** each SQL statement that is run.
  596. */
  597. void *sqlite3_profile(
  598.   sqlite3 *db,
  599.   void (*xProfile)(void*,const char*,sqlite_uint64),
  600.   void *pArg
  601. ){
  602.   void *pOld;
  603.   sqlite3_mutex_enter(db->mutex);
  604.   pOld = db->pProfileArg;
  605.   db->xProfile = xProfile;
  606.   db->pProfileArg = pArg;
  607.   sqlite3_mutex_leave(db->mutex);
  608.   return pOld;
  609. }
  610. #endif /* SQLITE_OMIT_TRACE */
  611. /*** EXPERIMENTAL ***
  612. **
  613. ** Register a function to be invoked when a transaction comments.
  614. ** If the invoked function returns non-zero, then the commit becomes a
  615. ** rollback.
  616. */
  617. void *sqlite3_commit_hook(
  618.   sqlite3 *db,              /* Attach the hook to this database */
  619.   int (*xCallback)(void*),  /* Function to invoke on each commit */
  620.   void *pArg                /* Argument to the function */
  621. ){
  622.   void *pOld;
  623.   sqlite3_mutex_enter(db->mutex);
  624.   pOld = db->pCommitArg;
  625.   db->xCommitCallback = xCallback;
  626.   db->pCommitArg = pArg;
  627.   sqlite3_mutex_leave(db->mutex);
  628.   return pOld;
  629. }
  630. /*
  631. ** Register a callback to be invoked each time a row is updated,
  632. ** inserted or deleted using this database connection.
  633. */
  634. void *sqlite3_update_hook(
  635.   sqlite3 *db,              /* Attach the hook to this database */
  636.   void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
  637.   void *pArg                /* Argument to the function */
  638. ){
  639.   void *pRet;
  640.   sqlite3_mutex_enter(db->mutex);
  641.   pRet = db->pUpdateArg;
  642.   db->xUpdateCallback = xCallback;
  643.   db->pUpdateArg = pArg;
  644.   sqlite3_mutex_leave(db->mutex);
  645.   return pRet;
  646. }
  647. /*
  648. ** Register a callback to be invoked each time a transaction is rolled
  649. ** back by this database connection.
  650. */
  651. void *sqlite3_rollback_hook(
  652.   sqlite3 *db,              /* Attach the hook to this database */
  653.   void (*xCallback)(void*), /* Callback function */
  654.   void *pArg                /* Argument to the function */
  655. ){
  656.   void *pRet;
  657.   sqlite3_mutex_enter(db->mutex);
  658.   pRet = db->pRollbackArg;
  659.   db->xRollbackCallback = xCallback;
  660.   db->pRollbackArg = pArg;
  661.   sqlite3_mutex_leave(db->mutex);
  662.   return pRet;
  663. }
  664. /*
  665. ** This routine is called to create a connection to a database BTree
  666. ** driver.  If zFilename is the name of a file, then that file is
  667. ** opened and used.  If zFilename is the magic name ":memory:" then
  668. ** the database is stored in memory (and is thus forgotten as soon as
  669. ** the connection is closed.)  If zFilename is NULL then the database
  670. ** is a "virtual" database for transient use only and is deleted as
  671. ** soon as the connection is closed.
  672. **
  673. ** A virtual database can be either a disk file (that is automatically
  674. ** deleted when the file is closed) or it an be held entirely in memory,
  675. ** depending on the values of the TEMP_STORE compile-time macro and the
  676. ** db->temp_store variable, according to the following chart:
  677. **
  678. **       TEMP_STORE     db->temp_store     Location of temporary database
  679. **       ----------     --------------     ------------------------------
  680. **           0               any             file
  681. **           1                1              file
  682. **           1                2              memory
  683. **           1                0              file
  684. **           2                1              file
  685. **           2                2              memory
  686. **           2                0              memory
  687. **           3               any             memory
  688. */
  689. int sqlite3BtreeFactory(
  690.   const sqlite3 *db,        /* Main database when opening aux otherwise 0 */
  691.   const char *zFilename,    /* Name of the file containing the BTree database */
  692.   int omitJournal,          /* if TRUE then do not journal this file */
  693.   int nCache,               /* How many pages in the page cache */
  694.   int vfsFlags,             /* Flags passed through to vfsOpen */
  695.   Btree **ppBtree           /* Pointer to new Btree object written here */
  696. ){
  697.   int btFlags = 0;
  698.   int rc;
  699.   
  700.   assert( sqlite3_mutex_held(db->mutex) );
  701.   assert( ppBtree != 0);
  702.   if( omitJournal ){
  703.     btFlags |= BTREE_OMIT_JOURNAL;
  704.   }
  705.   if( db->flags & SQLITE_NoReadlock ){
  706.     btFlags |= BTREE_NO_READLOCK;
  707.   }
  708.   if( zFilename==0 ){
  709. #if TEMP_STORE==0
  710.     /* Do nothing */
  711. #endif
  712. #ifndef SQLITE_OMIT_MEMORYDB
  713. #if TEMP_STORE==1
  714.     if( db->temp_store==2 ) zFilename = ":memory:";
  715. #endif
  716. #if TEMP_STORE==2
  717.     if( db->temp_store!=1 ) zFilename = ":memory:";
  718. #endif
  719. #if TEMP_STORE==3
  720.     zFilename = ":memory:";
  721. #endif
  722. #endif /* SQLITE_OMIT_MEMORYDB */
  723.   }
  724.   if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){
  725.     vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
  726.   }
  727.   rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
  728.   if( rc==SQLITE_OK ){
  729.     sqlite3BtreeSetCacheSize(*ppBtree, nCache);
  730.   }
  731.   return rc;
  732. }
  733. /*
  734. ** Return UTF-8 encoded English language explanation of the most recent
  735. ** error.
  736. */
  737. const char *sqlite3_errmsg(sqlite3 *db){
  738.   const char *z;
  739.   if( !db ){
  740.     return sqlite3ErrStr(SQLITE_NOMEM);
  741.   }
  742.   if( !sqlite3SafetyCheckSickOrOk(db) || db->errCode==SQLITE_MISUSE ){
  743.     return sqlite3ErrStr(SQLITE_MISUSE);
  744.   }
  745.   sqlite3_mutex_enter(db->mutex);
  746.   assert( !db->mallocFailed );
  747.   z = (char*)sqlite3_value_text(db->pErr);
  748.   if( z==0 ){
  749.     z = sqlite3ErrStr(db->errCode);
  750.   }
  751.   sqlite3_mutex_leave(db->mutex);
  752.   return z;
  753. }
  754. #ifndef SQLITE_OMIT_UTF16
  755. /*
  756. ** Return UTF-16 encoded English language explanation of the most recent
  757. ** error.
  758. */
  759. const void *sqlite3_errmsg16(sqlite3 *db){
  760.   /* Because all the characters in the string are in the unicode
  761.   ** range 0x00-0xFF, if we pad the big-endian string with a 
  762.   ** zero byte, we can obtain the little-endian string with
  763.   ** &big_endian[1].
  764.   */
  765.   static const char outOfMemBe[] = {
  766.     0, 'o', 0, 'u', 0, 't', 0, ' ', 
  767.     0, 'o', 0, 'f', 0, ' ', 
  768.     0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
  769.   };
  770.   static const char misuseBe [] = {
  771.     0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ', 
  772.     0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ', 
  773.     0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ', 
  774.     0, 'o', 0, 'u', 0, 't', 0, ' ', 
  775.     0, 'o', 0, 'f', 0, ' ', 
  776.     0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
  777.   };
  778.   const void *z;
  779.   if( !db ){
  780.     return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
  781.   }
  782.   if( !sqlite3SafetyCheckSickOrOk(db) || db->errCode==SQLITE_MISUSE ){
  783.     return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
  784.   }
  785.   sqlite3_mutex_enter(db->mutex);
  786.   assert( !db->mallocFailed );
  787.   z = sqlite3_value_text16(db->pErr);
  788.   if( z==0 ){
  789.     sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
  790.          SQLITE_UTF8, SQLITE_STATIC);
  791.     z = sqlite3_value_text16(db->pErr);
  792.   }
  793.   sqlite3ApiExit(0, 0);
  794.   sqlite3_mutex_leave(db->mutex);
  795.   return z;
  796. }
  797. #endif /* SQLITE_OMIT_UTF16 */
  798. /*
  799. ** Return the most recent error code generated by an SQLite routine. If NULL is
  800. ** passed to this function, we assume a malloc() failed during sqlite3_open().
  801. */
  802. int sqlite3_errcode(sqlite3 *db){
  803.   if( db && !sqlite3SafetyCheckSickOrOk(db) ){
  804.     return SQLITE_MISUSE;
  805.   }
  806.   if( !db || db->mallocFailed ){
  807.     return SQLITE_NOMEM;
  808.   }
  809.   return db->errCode & db->errMask;
  810. }
  811. /*
  812. ** Create a new collating function for database "db".  The name is zName
  813. ** and the encoding is enc.
  814. */
  815. static int createCollation(
  816.   sqlite3* db, 
  817.   const char *zName, 
  818.   int enc, 
  819.   void* pCtx,
  820.   int(*xCompare)(void*,int,const void*,int,const void*),
  821.   void(*xDel)(void*)
  822. ){
  823.   CollSeq *pColl;
  824.   int enc2;
  825.   
  826.   assert( sqlite3_mutex_held(db->mutex) );
  827.   /* If SQLITE_UTF16 is specified as the encoding type, transform this
  828.   ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
  829.   ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
  830.   */
  831.   enc2 = enc & ~SQLITE_UTF16_ALIGNED;
  832.   if( enc2==SQLITE_UTF16 ){
  833.     enc2 = SQLITE_UTF16NATIVE;
  834.   }
  835.   if( (enc2&~3)!=0 ){
  836.     sqlite3Error(db, SQLITE_ERROR, "unknown encoding");
  837.     return SQLITE_ERROR;
  838.   }
  839.   /* Check if this call is removing or replacing an existing collation 
  840.   ** sequence. If so, and there are active VMs, return busy. If there
  841.   ** are no active VMs, invalidate any pre-compiled statements.
  842.   */
  843.   pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0);
  844.   if( pColl && pColl->xCmp ){
  845.     if( db->activeVdbeCnt ){
  846.       sqlite3Error(db, SQLITE_BUSY, 
  847.         "Unable to delete/modify collation sequence due to active statements");
  848.       return SQLITE_BUSY;
  849.     }
  850.     sqlite3ExpirePreparedStatements(db);
  851.     /* If collation sequence pColl was created directly by a call to
  852.     ** sqlite3_create_collation, and not generated by synthCollSeq(),
  853.     ** then any copies made by synthCollSeq() need to be invalidated.
  854.     ** Also, collation destructor - CollSeq.xDel() - function may need
  855.     ** to be called.
  856.     */ 
  857.     if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
  858.       CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, strlen(zName));
  859.       int j;
  860.       for(j=0; j<3; j++){
  861.         CollSeq *p = &aColl[j];
  862.         if( p->enc==pColl->enc ){
  863.           if( p->xDel ){
  864.             p->xDel(p->pUser);
  865.           }
  866.           p->xCmp = 0;
  867.         }
  868.       }
  869.     }
  870.   }
  871.   pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1);
  872.   if( pColl ){
  873.     pColl->xCmp = xCompare;
  874.     pColl->pUser = pCtx;
  875.     pColl->xDel = xDel;
  876.     pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
  877.   }
  878.   sqlite3Error(db, SQLITE_OK, 0);
  879.   return SQLITE_OK;
  880. }
  881. /*
  882. ** This array defines hard upper bounds on limit values.  The
  883. ** initializer must be kept in sync with the SQLITE_LIMIT_*
  884. ** #defines in sqlite3.h.
  885. */
  886. static const int aHardLimit[] = {
  887.   SQLITE_MAX_LENGTH,
  888.   SQLITE_MAX_SQL_LENGTH,
  889.   SQLITE_MAX_COLUMN,
  890.   SQLITE_MAX_EXPR_DEPTH,
  891.   SQLITE_MAX_COMPOUND_SELECT,
  892.   SQLITE_MAX_VDBE_OP,
  893.   SQLITE_MAX_FUNCTION_ARG,
  894.   SQLITE_MAX_ATTACHED,
  895.   SQLITE_MAX_LIKE_PATTERN_LENGTH,
  896.   SQLITE_MAX_VARIABLE_NUMBER,
  897. };
  898. /*
  899. ** Make sure the hard limits are set to reasonable values
  900. */
  901. #if SQLITE_MAX_LENGTH<100
  902. # error SQLITE_MAX_LENGTH must be at least 100
  903. #endif
  904. #if SQLITE_MAX_SQL_LENGTH<100
  905. # error SQLITE_MAX_SQL_LENGTH must be at least 100
  906. #endif
  907. #if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
  908. # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
  909. #endif
  910. #if SQLITE_MAX_COLUMN<1
  911. # error SQLITE_MAX_COLUMN must be at least 1
  912. #endif
  913. #if SQLITE_MAX_EXPR_DEPTH<1
  914. # error SQLITE_MAX_EXPR_DEPTH must be at least 1
  915. #endif
  916. #if SQLITE_MAX_COMPOUND_SELECT<2
  917. # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
  918. #endif
  919. #if SQLITE_MAX_VDBE_OP<40
  920. # error SQLITE_MAX_VDBE_OP must be at least 40
  921. #endif
  922. #if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>255
  923. # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 255
  924. #endif
  925. #if SQLITE_MAX_ATTACH<0 || SQLITE_MAX_ATTACH>30
  926. # error SQLITE_MAX_ATTACH must be between 0 and 30
  927. #endif
  928. #if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
  929. # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
  930. #endif
  931. #if SQLITE_MAX_VARIABLE_NUMBER<1
  932. # error SQLITE_MAX_VARIABLE_NUMBER must be at least 1
  933. #endif
  934. /*
  935. ** Change the value of a limit.  Report the old value.
  936. ** If an invalid limit index is supplied, report -1.
  937. ** Make no changes but still report the old value if the
  938. ** new limit is negative.
  939. **
  940. ** A new lower limit does not shrink existing constructs.
  941. ** It merely prevents new constructs that exceed the limit
  942. ** from forming.
  943. */
  944. int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
  945.   int oldLimit;
  946.   if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
  947.     return -1;
  948.   }
  949.   oldLimit = db->aLimit[limitId];
  950.   if( newLimit>=0 ){
  951.     if( newLimit>aHardLimit[limitId] ){
  952.       newLimit = aHardLimit[limitId];
  953.     }
  954.     db->aLimit[limitId] = newLimit;
  955.   }
  956.   return oldLimit;
  957. }
  958. /*
  959. ** This routine does the work of opening a database on behalf of
  960. ** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"  
  961. ** is UTF-8 encoded.
  962. */
  963. static int openDatabase(
  964.   const char *zFilename, /* Database filename UTF-8 encoded */
  965.   sqlite3 **ppDb,        /* OUT: Returned database handle */
  966.   unsigned flags,        /* Operational flags */
  967.   const char *zVfs       /* Name of the VFS to use */
  968. ){
  969.   sqlite3 *db;
  970.   int rc;
  971.   CollSeq *pColl;
  972.   /* Remove harmful bits from the flags parameter */
  973.   flags &=  ~( SQLITE_OPEN_DELETEONCLOSE |
  974.                SQLITE_OPEN_MAIN_DB |
  975.                SQLITE_OPEN_TEMP_DB | 
  976.                SQLITE_OPEN_TRANSIENT_DB | 
  977.                SQLITE_OPEN_MAIN_JOURNAL | 
  978.                SQLITE_OPEN_TEMP_JOURNAL | 
  979.                SQLITE_OPEN_SUBJOURNAL | 
  980.                SQLITE_OPEN_MASTER_JOURNAL
  981.              );
  982.   /* Allocate the sqlite data structure */
  983.   db = sqlite3MallocZero( sizeof(sqlite3) );
  984.   if( db==0 ) goto opendb_out;
  985.   db->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
  986.   if( db->mutex==0 ){
  987.     sqlite3_free(db);
  988.     db = 0;
  989.     goto opendb_out;
  990.   }
  991.   sqlite3_mutex_enter(db->mutex);
  992.   db->errMask = 0xff;
  993.   db->priorNewRowid = 0;
  994.   db->nDb = 2;
  995.   db->magic = SQLITE_MAGIC_BUSY;
  996.   db->aDb = db->aDbStatic;
  997.   assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
  998.   memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
  999.   db->autoCommit = 1;
  1000.   db->nextAutovac = -1;
  1001.   db->nextPagesize = 0;
  1002.   db->flags |= SQLITE_ShortColNames
  1003. #if SQLITE_DEFAULT_FILE_FORMAT<4
  1004.                  | SQLITE_LegacyFileFmt
  1005. #endif
  1006. #ifdef SQLITE_ENABLE_LOAD_EXTENSION
  1007.                  | SQLITE_LoadExtension
  1008. #endif
  1009.       ;
  1010.   sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);
  1011.   sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
  1012. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1013.   sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
  1014. #endif
  1015.   db->pVfs = sqlite3_vfs_find(zVfs);
  1016.   if( !db->pVfs ){
  1017.     rc = SQLITE_ERROR;
  1018.     db->magic = SQLITE_MAGIC_SICK;
  1019.     sqlite3Error(db, rc, "no such vfs: %s", zVfs);
  1020.     goto opendb_out;
  1021.   }
  1022.   /* Add the default collation sequence BINARY. BINARY works for both UTF-8
  1023.   ** and UTF-16, so add a version for each to avoid any unnecessary
  1024.   ** conversions. The only error that can occur here is a malloc() failure.
  1025.   */
  1026.   createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
  1027.   createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
  1028.   createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
  1029.   createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
  1030.   if( db->mallocFailed ){
  1031.     db->magic = SQLITE_MAGIC_SICK;
  1032.     goto opendb_out;
  1033.   }
  1034.   db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
  1035.   assert( db->pDfltColl!=0 );
  1036.   /* Also add a UTF-8 case-insensitive collation sequence. */
  1037.   createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
  1038.   /* Set flags on the built-in collating sequences */
  1039.   db->pDfltColl->type = SQLITE_COLL_BINARY;
  1040.   pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
  1041.   if( pColl ){
  1042.     pColl->type = SQLITE_COLL_NOCASE;
  1043.   }
  1044.   /* Open the backend database driver */
  1045.   db->openFlags = flags;
  1046.   rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE, 
  1047.                            flags | SQLITE_OPEN_MAIN_DB,
  1048.                            &db->aDb[0].pBt);
  1049.   if( rc!=SQLITE_OK ){
  1050.     sqlite3Error(db, rc, 0);
  1051.     db->magic = SQLITE_MAGIC_SICK;
  1052.     goto opendb_out;
  1053.   }
  1054.   db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
  1055.   db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
  1056.   /* The default safety_level for the main database is 'full'; for the temp
  1057.   ** database it is 'NONE'. This matches the pager layer defaults.  
  1058.   */
  1059.   db->aDb[0].zName = "main";
  1060.   db->aDb[0].safety_level = 3;
  1061. #ifndef SQLITE_OMIT_TEMPDB
  1062.   db->aDb[1].zName = "temp";
  1063.   db->aDb[1].safety_level = 1;
  1064. #endif
  1065.   db->magic = SQLITE_MAGIC_OPEN;
  1066.   if( db->mallocFailed ){
  1067.     goto opendb_out;
  1068.   }
  1069.   /* Register all built-in functions, but do not attempt to read the
  1070.   ** database schema yet. This is delayed until the first time the database
  1071.   ** is accessed.
  1072.   */
  1073.   sqlite3Error(db, SQLITE_OK, 0);
  1074.   sqlite3RegisterBuiltinFunctions(db);
  1075.   /* Load automatic extensions - extensions that have been registered
  1076.   ** using the sqlite3_automatic_extension() API.
  1077.   */
  1078.   (void)sqlite3AutoLoadExtensions(db);
  1079.   if( sqlite3_errcode(db)!=SQLITE_OK ){
  1080.     goto opendb_out;
  1081.   }
  1082. #ifdef SQLITE_ENABLE_FTS1
  1083.   if( !db->mallocFailed ){
  1084.     extern int sqlite3Fts1Init(sqlite3*);
  1085.     rc = sqlite3Fts1Init(db);
  1086.   }
  1087. #endif
  1088. #ifdef SQLITE_ENABLE_FTS2
  1089.   if( !db->mallocFailed && rc==SQLITE_OK ){
  1090.     extern int sqlite3Fts2Init(sqlite3*);
  1091.     rc = sqlite3Fts2Init(db);
  1092.   }
  1093. #endif
  1094. #ifdef SQLITE_ENABLE_FTS3
  1095.   if( !db->mallocFailed && rc==SQLITE_OK ){
  1096.     rc = sqlite3Fts3Init(db);
  1097.   }
  1098. #endif
  1099. #ifdef SQLITE_ENABLE_ICU
  1100.   if( !db->mallocFailed && rc==SQLITE_OK ){
  1101.     extern int sqlite3IcuInit(sqlite3*);
  1102.     rc = sqlite3IcuInit(db);
  1103.   }
  1104. #endif
  1105.   sqlite3Error(db, rc, 0);
  1106.   /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
  1107.   ** mode.  -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
  1108.   ** mode.  Doing nothing at all also makes NORMAL the default.
  1109.   */
  1110. #ifdef SQLITE_DEFAULT_LOCKING_MODE
  1111.   db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
  1112.   sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
  1113.                           SQLITE_DEFAULT_LOCKING_MODE);
  1114. #endif
  1115. opendb_out:
  1116.   if( db ){
  1117.     assert( db->mutex!=0 );
  1118.     sqlite3_mutex_leave(db->mutex);
  1119.   }
  1120.   if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
  1121.     sqlite3_close(db);
  1122.     db = 0;
  1123.   }
  1124.   *ppDb = db;
  1125.   return sqlite3ApiExit(0, rc);
  1126. }
  1127. /*
  1128. ** Open a new database handle.
  1129. */
  1130. int sqlite3_open(
  1131.   const char *zFilename, 
  1132.   sqlite3 **ppDb 
  1133. ){
  1134.   return openDatabase(zFilename, ppDb,
  1135.                       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
  1136. }
  1137. int sqlite3_open_v2(
  1138.   const char *filename,   /* Database filename (UTF-8) */
  1139.   sqlite3 **ppDb,         /* OUT: SQLite db handle */
  1140.   int flags,              /* Flags */
  1141.   const char *zVfs        /* Name of VFS module to use */
  1142. ){
  1143.   return openDatabase(filename, ppDb, flags, zVfs);
  1144. }
  1145. #ifndef SQLITE_OMIT_UTF16
  1146. /*
  1147. ** Open a new database handle.
  1148. */
  1149. int sqlite3_open16(
  1150.   const void *zFilename, 
  1151.   sqlite3 **ppDb
  1152. ){
  1153.   char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */
  1154.   sqlite3_value *pVal;
  1155.   int rc = SQLITE_NOMEM;
  1156.   assert( zFilename );
  1157.   assert( ppDb );
  1158.   *ppDb = 0;
  1159.   pVal = sqlite3ValueNew(0);
  1160.   sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
  1161.   zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
  1162.   if( zFilename8 ){
  1163.     rc = openDatabase(zFilename8, ppDb,
  1164.                       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
  1165.     assert( *ppDb || rc==SQLITE_NOMEM );
  1166.     if( rc==SQLITE_OK ){
  1167.       ENC(*ppDb) = SQLITE_UTF16NATIVE;
  1168.       if( rc!=SQLITE_OK ){
  1169.         sqlite3_close(*ppDb);
  1170.         *ppDb = 0;
  1171.       }
  1172.     }
  1173.   }
  1174.   sqlite3ValueFree(pVal);
  1175.   return sqlite3ApiExit(0, rc);
  1176. }
  1177. #endif /* SQLITE_OMIT_UTF16 */
  1178. /*
  1179. ** Register a new collation sequence with the database handle db.
  1180. */
  1181. int sqlite3_create_collation(
  1182.   sqlite3* db, 
  1183.   const char *zName, 
  1184.   int enc, 
  1185.   void* pCtx,
  1186.   int(*xCompare)(void*,int,const void*,int,const void*)
  1187. ){
  1188.   int rc;
  1189.   sqlite3_mutex_enter(db->mutex);
  1190.   assert( !db->mallocFailed );
  1191.   rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
  1192.   rc = sqlite3ApiExit(db, rc);
  1193.   sqlite3_mutex_leave(db->mutex);
  1194.   return rc;
  1195. }
  1196. /*
  1197. ** Register a new collation sequence with the database handle db.
  1198. */
  1199. int sqlite3_create_collation_v2(
  1200.   sqlite3* db, 
  1201.   const char *zName, 
  1202.   int enc, 
  1203.   void* pCtx,
  1204.   int(*xCompare)(void*,int,const void*,int,const void*),
  1205.   void(*xDel)(void*)
  1206. ){
  1207.   int rc;
  1208.   sqlite3_mutex_enter(db->mutex);
  1209.   assert( !db->mallocFailed );
  1210.   rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
  1211.   rc = sqlite3ApiExit(db, rc);
  1212.   sqlite3_mutex_leave(db->mutex);
  1213.   return rc;
  1214. }
  1215. #ifndef SQLITE_OMIT_UTF16
  1216. /*
  1217. ** Register a new collation sequence with the database handle db.
  1218. */
  1219. int sqlite3_create_collation16(
  1220.   sqlite3* db, 
  1221.   const char *zName, 
  1222.   int enc, 
  1223.   void* pCtx,
  1224.   int(*xCompare)(void*,int,const void*,int,const void*)
  1225. ){
  1226.   int rc = SQLITE_OK;
  1227.   char *zName8;
  1228.   sqlite3_mutex_enter(db->mutex);
  1229.   assert( !db->mallocFailed );
  1230.   zName8 = sqlite3Utf16to8(db, zName, -1);
  1231.   if( zName8 ){
  1232.     rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
  1233.     sqlite3_free(zName8);
  1234.   }
  1235.   rc = sqlite3ApiExit(db, rc);
  1236.   sqlite3_mutex_leave(db->mutex);
  1237.   return rc;
  1238. }
  1239. #endif /* SQLITE_OMIT_UTF16 */
  1240. /*
  1241. ** Register a collation sequence factory callback with the database handle
  1242. ** db. Replace any previously installed collation sequence factory.
  1243. */
  1244. int sqlite3_collation_needed(
  1245.   sqlite3 *db, 
  1246.   void *pCollNeededArg, 
  1247.   void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
  1248. ){
  1249.   sqlite3_mutex_enter(db->mutex);
  1250.   db->xCollNeeded = xCollNeeded;
  1251.   db->xCollNeeded16 = 0;
  1252.   db->pCollNeededArg = pCollNeededArg;
  1253.   sqlite3_mutex_leave(db->mutex);
  1254.   return SQLITE_OK;
  1255. }
  1256. #ifndef SQLITE_OMIT_UTF16
  1257. /*
  1258. ** Register a collation sequence factory callback with the database handle
  1259. ** db. Replace any previously installed collation sequence factory.
  1260. */
  1261. int sqlite3_collation_needed16(
  1262.   sqlite3 *db, 
  1263.   void *pCollNeededArg, 
  1264.   void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
  1265. ){
  1266.   sqlite3_mutex_enter(db->mutex);
  1267.   db->xCollNeeded = 0;
  1268.   db->xCollNeeded16 = xCollNeeded16;
  1269.   db->pCollNeededArg = pCollNeededArg;
  1270.   sqlite3_mutex_leave(db->mutex);
  1271.   return SQLITE_OK;
  1272. }
  1273. #endif /* SQLITE_OMIT_UTF16 */
  1274. #ifndef SQLITE_OMIT_GLOBALRECOVER
  1275. /*
  1276. ** This function is now an anachronism. It used to be used to recover from a
  1277. ** malloc() failure, but SQLite now does this automatically.
  1278. */
  1279. int sqlite3_global_recover(void){
  1280.   return SQLITE_OK;
  1281. }
  1282. #endif
  1283. /*
  1284. ** Test to see whether or not the database connection is in autocommit
  1285. ** mode.  Return TRUE if it is and FALSE if not.  Autocommit mode is on
  1286. ** by default.  Autocommit is disabled by a BEGIN statement and reenabled
  1287. ** by the next COMMIT or ROLLBACK.
  1288. **
  1289. ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
  1290. */
  1291. int sqlite3_get_autocommit(sqlite3 *db){
  1292.   return db->autoCommit;
  1293. }
  1294. #ifdef SQLITE_DEBUG
  1295. /*
  1296. ** The following routine is subtituted for constant SQLITE_CORRUPT in
  1297. ** debugging builds.  This provides a way to set a breakpoint for when
  1298. ** corruption is first detected.
  1299. */
  1300. int sqlite3Corrupt(void){
  1301.   return SQLITE_CORRUPT;
  1302. }
  1303. #endif
  1304. /*
  1305. ** This is a convenience routine that makes sure that all thread-specific
  1306. ** data for this thread has been deallocated.
  1307. **
  1308. ** SQLite no longer uses thread-specific data so this routine is now a
  1309. ** no-op.  It is retained for historical compatibility.
  1310. */
  1311. void sqlite3_thread_cleanup(void){
  1312. }
  1313. /*
  1314. ** Return meta information about a specific column of a database table.
  1315. ** See comment in sqlite3.h (sqlite.h.in) for details.
  1316. */
  1317. #ifdef SQLITE_ENABLE_COLUMN_METADATA
  1318. int sqlite3_table_column_metadata(
  1319.   sqlite3 *db,                /* Connection handle */
  1320.   const char *zDbName,        /* Database name or NULL */
  1321.   const char *zTableName,     /* Table name */
  1322.   const char *zColumnName,    /* Column name */
  1323.   char const **pzDataType,    /* OUTPUT: Declared data type */
  1324.   char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
  1325.   int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
  1326.   int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
  1327.   int *pAutoinc               /* OUTPUT: True if colums is auto-increment */
  1328. ){
  1329.   int rc;
  1330.   char *zErrMsg = 0;
  1331.   Table *pTab = 0;
  1332.   Column *pCol = 0;
  1333.   int iCol;
  1334.   char const *zDataType = 0;
  1335.   char const *zCollSeq = 0;
  1336.   int notnull = 0;
  1337.   int primarykey = 0;
  1338.   int autoinc = 0;
  1339.   /* Ensure the database schema has been loaded */
  1340.   sqlite3_mutex_enter(db->mutex);
  1341.   (void)sqlite3SafetyOn(db);
  1342.   sqlite3BtreeEnterAll(db);
  1343.   rc = sqlite3Init(db, &zErrMsg);
  1344.   sqlite3BtreeLeaveAll(db);
  1345.   if( SQLITE_OK!=rc ){
  1346.     goto error_out;
  1347.   }
  1348.   /* Locate the table in question */
  1349.   pTab = sqlite3FindTable(db, zTableName, zDbName);
  1350.   if( !pTab || pTab->pSelect ){
  1351.     pTab = 0;
  1352.     goto error_out;
  1353.   }
  1354.   /* Find the column for which info is requested */
  1355.   if( sqlite3IsRowid(zColumnName) ){
  1356.     iCol = pTab->iPKey;
  1357.     if( iCol>=0 ){
  1358.       pCol = &pTab->aCol[iCol];
  1359.     }
  1360.   }else{
  1361.     for(iCol=0; iCol<pTab->nCol; iCol++){
  1362.       pCol = &pTab->aCol[iCol];
  1363.       if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
  1364.         break;
  1365.       }
  1366.     }
  1367.     if( iCol==pTab->nCol ){
  1368.       pTab = 0;
  1369.       goto error_out;
  1370.     }
  1371.   }
  1372.   /* The following block stores the meta information that will be returned
  1373.   ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
  1374.   ** and autoinc. At this point there are two possibilities:
  1375.   ** 
  1376.   **     1. The specified column name was rowid", "oid" or "_rowid_" 
  1377.   **        and there is no explicitly declared IPK column. 
  1378.   **
  1379.   **     2. The table is not a view and the column name identified an 
  1380.   **        explicitly declared column. Copy meta information from *pCol.
  1381.   */ 
  1382.   if( pCol ){
  1383.     zDataType = pCol->zType;
  1384.     zCollSeq = pCol->zColl;
  1385.     notnull = (pCol->notNull?1:0);
  1386.     primarykey  = (pCol->isPrimKey?1:0);
  1387.     autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);
  1388.   }else{
  1389.     zDataType = "INTEGER";
  1390.     primarykey = 1;
  1391.   }
  1392.   if( !zCollSeq ){
  1393.     zCollSeq = "BINARY";
  1394.   }
  1395. error_out:
  1396.   (void)sqlite3SafetyOff(db);
  1397.   /* Whether the function call succeeded or failed, set the output parameters
  1398.   ** to whatever their local counterparts contain. If an error did occur,
  1399.   ** this has the effect of zeroing all output parameters.
  1400.   */
  1401.   if( pzDataType ) *pzDataType = zDataType;
  1402.   if( pzCollSeq ) *pzCollSeq = zCollSeq;
  1403.   if( pNotNull ) *pNotNull = notnull;
  1404.   if( pPrimaryKey ) *pPrimaryKey = primarykey;
  1405.   if( pAutoinc ) *pAutoinc = autoinc;
  1406.   if( SQLITE_OK==rc && !pTab ){
  1407.     sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".", 
  1408.         zColumnName, 0);
  1409.     rc = SQLITE_ERROR;
  1410.   }
  1411.   sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
  1412.   sqlite3_free(zErrMsg);
  1413.   rc = sqlite3ApiExit(db, rc);
  1414.   sqlite3_mutex_leave(db->mutex);
  1415.   return rc;
  1416. }
  1417. #endif
  1418. /*
  1419. ** Sleep for a little while.  Return the amount of time slept.
  1420. */
  1421. int sqlite3_sleep(int ms){
  1422.   sqlite3_vfs *pVfs;
  1423.   int rc;
  1424.   pVfs = sqlite3_vfs_find(0);
  1425.   /* This function works in milliseconds, but the underlying OsSleep() 
  1426.   ** API uses microseconds. Hence the 1000's.
  1427.   */
  1428.   rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
  1429.   return rc;
  1430. }
  1431. /*
  1432. ** Enable or disable the extended result codes.
  1433. */
  1434. int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
  1435.   sqlite3_mutex_enter(db->mutex);
  1436.   db->errMask = onoff ? 0xffffffff : 0xff;
  1437.   sqlite3_mutex_leave(db->mutex);
  1438.   return SQLITE_OK;
  1439. }
  1440. /*
  1441. ** Invoke the xFileControl method on a particular database.
  1442. */
  1443. int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
  1444.   int rc = SQLITE_ERROR;
  1445.   int iDb;
  1446.   sqlite3_mutex_enter(db->mutex);
  1447.   if( zDbName==0 ){
  1448.     iDb = 0;
  1449.   }else{
  1450.     for(iDb=0; iDb<db->nDb; iDb++){
  1451.       if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
  1452.     }
  1453.   }
  1454.   if( iDb<db->nDb ){
  1455.     Btree *pBtree = db->aDb[iDb].pBt;
  1456.     if( pBtree ){
  1457.       Pager *pPager;
  1458.       sqlite3_file *fd;
  1459.       sqlite3BtreeEnter(pBtree);
  1460.       pPager = sqlite3BtreePager(pBtree);
  1461.       assert( pPager!=0 );
  1462.       fd = sqlite3PagerFile(pPager);
  1463.       assert( fd!=0 );
  1464.       if( fd->pMethods ){
  1465.         rc = sqlite3OsFileControl(fd, op, pArg);
  1466.       }
  1467.       sqlite3BtreeLeave(pBtree);
  1468.     }
  1469.   }
  1470.   sqlite3_mutex_leave(db->mutex);
  1471.   return rc;   
  1472. }
  1473. /*
  1474. ** Interface to the testing logic.
  1475. */
  1476. int sqlite3_test_control(int op, ...){
  1477.   int rc = 0;
  1478. #ifndef SQLITE_OMIT_BUILTIN_TEST
  1479.   va_list ap;
  1480.   va_start(ap, op);
  1481.   switch( op ){
  1482.     /*
  1483.     ** sqlite3_test_control(FAULT_CONFIG, fault_id, nDelay, nRepeat)
  1484.     **
  1485.     ** Configure a fault injector.  The specific fault injector is
  1486.     ** identified by the fault_id argument.  (ex: SQLITE_FAULTINJECTOR_MALLOC)
  1487.     ** The fault will occur after a delay of nDelay calls.  The fault
  1488.     ** will repeat nRepeat times.
  1489.     */
  1490.     case SQLITE_TESTCTRL_FAULT_CONFIG: {
  1491.       int id = va_arg(ap, int);
  1492.       int nDelay = va_arg(ap, int);
  1493.       int nRepeat = va_arg(ap, int);
  1494.       sqlite3FaultConfig(id, nDelay, nRepeat);
  1495.       break;
  1496.     }
  1497.     /*
  1498.     ** sqlite3_test_control(FAULT_FAILURES, fault_id)
  1499.     **
  1500.     ** Return the number of faults (both hard and benign faults) that have
  1501.     ** occurred since the injector identified by fault_id) was last configured.
  1502.     */
  1503.     case SQLITE_TESTCTRL_FAULT_FAILURES: {
  1504.       int id = va_arg(ap, int);
  1505.       rc = sqlite3FaultFailures(id);
  1506.       break;
  1507.     }
  1508.     /*
  1509.     ** sqlite3_test_control(FAULT_BENIGN_FAILURES, fault_id)
  1510.     **
  1511.     ** Return the number of benign faults that have occurred since the
  1512.     ** injector identified by fault_id was last configured.
  1513.     */
  1514.     case SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES: {
  1515.       int id = va_arg(ap, int);
  1516.       rc = sqlite3FaultBenignFailures(id);
  1517.       break;
  1518.     }
  1519.     /*
  1520.     ** sqlite3_test_control(FAULT_PENDING, fault_id)
  1521.     **
  1522.     ** Return the number of successes that will occur before the next
  1523.     ** scheduled failure on fault injector fault_id.
  1524.     ** If no failures are scheduled, return -1.
  1525.     */
  1526.     case SQLITE_TESTCTRL_FAULT_PENDING: {
  1527.       int id = va_arg(ap, int);
  1528.       rc = sqlite3FaultPending(id);
  1529.       break;
  1530.     }
  1531.     /*
  1532.     ** Save the current state of the PRNG.
  1533.     */
  1534.     case SQLITE_TESTCTRL_PRNG_SAVE: {
  1535.       sqlite3PrngSaveState();
  1536.       break;
  1537.     }
  1538.     /*
  1539.     ** Restore the state of the PRNG to the last state saved using
  1540.     ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
  1541.     ** this verb acts like PRNG_RESET.
  1542.     */
  1543.     case SQLITE_TESTCTRL_PRNG_RESTORE: {
  1544.       sqlite3PrngRestoreState();
  1545.       break;
  1546.     }
  1547.     /*
  1548.     ** Reset the PRNG back to its uninitialized state.  The next call
  1549.     ** to sqlite3_randomness() will reseed the PRNG using a single call
  1550.     ** to the xRandomness method of the default VFS.
  1551.     */
  1552.     case SQLITE_TESTCTRL_PRNG_RESET: {
  1553.       sqlite3PrngResetState();
  1554.       break;
  1555.     }
  1556.     /*
  1557.     **  sqlite3_test_control(BITVEC_TEST, size, program)
  1558.     **
  1559.     ** Run a test against a Bitvec object of size.  The program argument
  1560.     ** is an array of integers that defines the test.  Return -1 on a
  1561.     ** memory allocation error, 0 on success, or non-zero for an error.
  1562.     ** See the sqlite3BitvecBuiltinTest() for additional information.
  1563.     */
  1564.     case SQLITE_TESTCTRL_BITVEC_TEST: {
  1565.       int sz = va_arg(ap, int);
  1566.       int *aProg = va_arg(ap, int*);
  1567.       rc = sqlite3BitvecBuiltinTest(sz, aProg);
  1568.       break;
  1569.     }
  1570.   }
  1571.   va_end(ap);
  1572. #endif /* SQLITE_OMIT_BUILTIN_TEST */
  1573.   return rc;
  1574. }