[sql] Import SQLite 3.17.0.

third_party/sqlite/src/src/test_multiplex.c

 /*
 ** 2010 October 28
 **
 ** 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.
 **
@@ skipping 50 matching lines @@
 /* 
 ** These should be defined to be the same as the values in 
 ** sqliteInt.h.  They are defined separately here so that
 ** the multiplex VFS shim can be built as a loadable 
 ** module.
 */
 #define UNUSED_PARAMETER(x) (void)(x)
 #define MAX_PAGE_SIZE       0x10000
 #define DEFAULT_SECTOR_SIZE 0x1000
 
-/*
-** For a build without mutexes, no-op the mutex calls.
-*/
-#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
-#define sqlite3_mutex_alloc(X)    ((sqlite3_mutex*)8)
-#define sqlite3_mutex_free(X)
-#define sqlite3_mutex_enter(X)
-#define sqlite3_mutex_try(X)      SQLITE_OK
-#define sqlite3_mutex_leave(X)
-#define sqlite3_mutex_held(X)     ((void)(X),1)
-#define sqlite3_mutex_notheld(X)  ((void)(X),1)
-#endif /* SQLITE_THREADSAFE==0 */
-
 /* Maximum chunk number */
 #define MX_CHUNK_NUMBER 299
 
 /* First chunk for rollback journal files */
 #define SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET 400
 #define SQLITE_MULTIPLEX_WAL_8_3_OFFSET 700
 
 
 /************************ Shim Definitions ******************************/
 
@@ skipping 38 matching lines @@
     sqlite3_file *p;                  /* Handle for the chunk */
     char *z;                          /* Name of this chunk */
   } *aReal;                        /* list of all chunks */
   int nReal;                       /* Number of chunks */
   char *zName;                     /* Base filename of this group */
   int nName;                       /* Length of base filename */
   int flags;                       /* Flags used for original opening */
   unsigned int szChunk;            /* Chunk size used for this group */
   unsigned char bEnabled;          /* TRUE to use Multiplex VFS for this file */
   unsigned char bTruncate;         /* TRUE to enable truncation of databases */
-  multiplexGroup *pNext, *pPrev;   /* Doubly linked list of all group objects */
 };
 
 /*
 ** An instance of the following object represents each open connection
 ** to a file that is multiplex'ed.  This object is a 
 ** subclass of sqlite3_file.  The sqlite3_file object for the underlying
 ** VFS is appended to this structure.
 */
 struct multiplexConn {
   sqlite3_file base;              /* Base class - must be first */
@@ skipping 27 matching lines @@
   ** has to create a wrapper sqlite3_file of the same version.  Hence
   ** there are two I/O method structures, one for version 1 and the other
   ** for version 2.
   */
   sqlite3_io_methods sIoMethodsV1;
   sqlite3_io_methods sIoMethodsV2;
 
   /* True when this shim has been initialized.
   */
   int isInitialized;
-
-  /* For run-time access any of the other global data structures in this
-  ** shim, the following mutex must be held. In practice, all this mutex
-  ** protects is add/remove operations to/from the linked list of group objects
-  ** starting at pGroups below. More specifically, it protects the value of
-  ** pGroups itself, and the pNext/pPrev fields of each multiplexGroup
-  ** structure.  */
-  sqlite3_mutex *pMutex;
-
-  /* List of multiplexGroup objects.
-  */
-  multiplexGroup *pGroups;
 } gMultiplex;
 
 /************************* Utility Routines *********************************/
 /*
-** Acquire and release the mutex used to serialize access to the
-** list of multiplexGroups.
-*/
-static void multiplexEnter(void){ sqlite3_mutex_enter(gMultiplex.pMutex); }
-static void multiplexLeave(void){ sqlite3_mutex_leave(gMultiplex.pMutex); }
-
-/*
 ** Compute a string length that is limited to what can be stored in
 ** lower 30 bits of a 32-bit signed integer.
 **
 ** The value returned will never be negative.  Nor will it ever be greater
 ** than the actual length of the string.  For very long strings (greater
 ** than 1GiB) the value returned might be less than the true string length.
 */
 static int multiplexStrlen30(const char *z){
   const char *z2 = z;
   if( z==0 ) return 0;
@@ skipping 289 matching lines @@
   int sz = 0;
   char *zToFree = 0;
 
   UNUSED_PARAMETER(pVfs);
   memset(pConn, 0, pVfs->szOsFile);
   assert( zName || (flags & SQLITE_OPEN_DELETEONCLOSE) );
 
   /* We need to create a group structure and manage
   ** access to this group of files.
   */
-  multiplexEnter();
   pMultiplexOpen = (multiplexConn*)pConn;
 
   if( rc==SQLITE_OK ){
     /* allocate space for group */
     nName = zName ? multiplexStrlen30(zName) : 0;
     sz = sizeof(multiplexGroup)                             /* multiplexGroup */
        + nName + 1;                                         /* zName */
     pGroup = sqlite3_malloc64( sz );
     if( pGroup==0 ){
       rc = SQLITE_NOMEM;
     }
   }
 
   if( rc==SQLITE_OK ){
     const char *zUri = (flags & SQLITE_OPEN_URI) ? zName : 0;
     /* assign pointers to extra space allocated */
     memset(pGroup, 0, sz);
     pMultiplexOpen->pGroup = pGroup;
     pGroup->bEnabled = (unsigned char)-1;
-    pGroup->bTruncate = sqlite3_uri_boolean(zUri, "truncate", 
+    pGroup->bTruncate = (unsigned char)sqlite3_uri_boolean(zUri, "truncate", 
                                    (flags & SQLITE_OPEN_MAIN_DB)==0);
     pGroup->szChunk = (int)sqlite3_uri_int64(zUri, "chunksize",
                                         SQLITE_MULTIPLEX_CHUNK_SIZE);
     pGroup->szChunk = (pGroup->szChunk+0xffff)&~0xffff;
     if( zName ){
       char *p = (char *)&pGroup[1];
       pGroup->zName = p;
       memcpy(pGroup->zName, zName, nName+1);
       pGroup->nName = nName;
     }
@@ skipping 66 matching lines @@
         }
       }
     }
 
     if( rc==SQLITE_OK ){
       if( pSubOpen->pMethods->iVersion==1 ){
         pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV1;
       }else{
         pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV2;
       }
-      /* place this group at the head of our list */
-      pGroup->pNext = gMultiplex.pGroups;
-      if( gMultiplex.pGroups ) gMultiplex.pGroups->pPrev = pGroup;
-      gMultiplex.pGroups = pGroup;
     }else{
       multiplexFreeComponents(pGroup);
       sqlite3_free(pGroup);
     }
   }
-  multiplexLeave();
   sqlite3_free(zToFree);
   return rc;
 }
 
 /*
 ** This is the xDelete method used for the "multiplex" VFS.
 ** It attempts to delete the filename specified.
 */
 static int multiplexDelete(
   sqlite3_vfs *pVfs,         /* The multiplex VFS */
@@ skipping 61 matching lines @@
 static int multiplexRandomness(sqlite3_vfs *a, int b, char *c){
   return gMultiplex.pOrigVfs->xRandomness(gMultiplex.pOrigVfs, b, c);
 }
 static int multiplexSleep(sqlite3_vfs *a, int b){
   return gMultiplex.pOrigVfs->xSleep(gMultiplex.pOrigVfs, b);
 }
 static int multiplexCurrentTime(sqlite3_vfs *a, double *b){
   return gMultiplex.pOrigVfs->xCurrentTime(gMultiplex.pOrigVfs, b);
 }
 static int multiplexGetLastError(sqlite3_vfs *a, int b, char *c){
-  return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c);
+  if( gMultiplex.pOrigVfs->xGetLastError ){
+    return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c);
+  }else{
+    return 0;
+  }
 }
 static int multiplexCurrentTimeInt64(sqlite3_vfs *a, sqlite3_int64 *b){
   return gMultiplex.pOrigVfs->xCurrentTimeInt64(gMultiplex.pOrigVfs, b);
 }
 
 /************************ I/O Method Wrappers *******************************/
 
 /* xClose requests get passed through to the original VFS.
 ** We loop over all open chunk handles and close them.
 ** The group structure for this file is unlinked from 
 ** our list of groups and freed.
 */
 static int multiplexClose(sqlite3_file *pConn){
   multiplexConn *p = (multiplexConn*)pConn;
   multiplexGroup *pGroup = p->pGroup;
   int rc = SQLITE_OK;
-  multiplexEnter();
   multiplexFreeComponents(pGroup);
-  /* remove from linked list */
-  if( pGroup->pNext ) pGroup->pNext->pPrev = pGroup->pPrev;
-  if( pGroup->pPrev ){
-    pGroup->pPrev->pNext = pGroup->pNext;
-  }else{
-    gMultiplex.pGroups = pGroup->pNext;
-  }
   sqlite3_free(pGroup);
-  multiplexLeave();
   return rc;
 }
 
 /* Pass xRead requests thru to the original VFS after
 ** determining the correct chunk to operate on.
 ** Break up reads across chunk boundaries.
 */
 static int multiplexRead(
   sqlite3_file *pConn,
   void *pBuf,
@@ skipping 76 matching lines @@
 }
 
 /* Pass xTruncate requests thru to the original VFS after
 ** determining the correct chunk to operate on.  Delete any
 ** chunks above the truncate mark.
 */
 static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){
   multiplexConn *p = (multiplexConn*)pConn;
   multiplexGroup *pGroup = p->pGroup;
   int rc = SQLITE_OK;
-  multiplexEnter();
   if( !pGroup->bEnabled ){
     sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
     if( pSubOpen==0 ){
       rc = SQLITE_IOERR_TRUNCATE;
     }else{
       rc = pSubOpen->pMethods->xTruncate(pSubOpen, size);
     }
   }else{
     int i;
     int iBaseGroup = (int)(size / pGroup->szChunk);
@@ skipping 11 matching lines @@
       }
     }
     if( rc==SQLITE_OK ){
       pSubOpen = multiplexSubOpen(pGroup, iBaseGroup, &rc, 0, 0);
       if( pSubOpen ){
         rc = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->szChunk);
       }
     }
     if( rc ) rc = SQLITE_IOERR_TRUNCATE;
   }
-  multiplexLeave();
   return rc;
 }
 
 /* Pass xSync requests through to the original VFS without change
 */
 static int multiplexSync(sqlite3_file *pConn, int flags){
   multiplexConn *p = (multiplexConn*)pConn;
   multiplexGroup *pGroup = p->pGroup;
   int rc = SQLITE_OK;
   int i;
-  multiplexEnter();
   for(i=0; i<pGroup->nReal; i++){
     sqlite3_file *pSubOpen = pGroup->aReal[i].p;
     if( pSubOpen ){
       int rc2 = pSubOpen->pMethods->xSync(pSubOpen, flags);
       if( rc2!=SQLITE_OK ) rc = rc2;
     }
   }
-  multiplexLeave();
   return rc;
 }
 
 /* Pass xFileSize requests through to the original VFS.
 ** Aggregate the size of all the chunks before returning.
 */
 static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
   multiplexConn *p = (multiplexConn*)pConn;
   multiplexGroup *pGroup = p->pGroup;
   int rc = SQLITE_OK;
   int i;
-  multiplexEnter();
   if( !pGroup->bEnabled ){
     sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
     if( pSubOpen==0 ){
       rc = SQLITE_IOERR_FSTAT;
     }else{
       rc = pSubOpen->pMethods->xFileSize(pSubOpen, pSize);
     }
   }else{
     *pSize = 0;
     for(i=0; rc==SQLITE_OK; i++){
       sqlite3_int64 sz = multiplexSubSize(pGroup, i, &rc);
       if( sz==0 ) break;
       *pSize = i*(sqlite3_int64)pGroup->szChunk + sz;
     }
   }
-  multiplexLeave();
   return rc;
 }
 
 /* Pass xLock requests through to the original VFS unchanged.
 */
 static int multiplexLock(sqlite3_file *pConn, int lock){
   multiplexConn *p = (multiplexConn*)pConn;
   int rc;
   sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
   if( pSubOpen ){
@@ skipping 33 matching lines @@
   multiplexConn *p = (multiplexConn*)pConn;
   multiplexGroup *pGroup = p->pGroup;
   int rc = SQLITE_ERROR;
   sqlite3_file *pSubOpen;
 
   if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
   switch( op ){
     case MULTIPLEX_CTRL_ENABLE:
       if( pArg ) {
         int bEnabled = *(int *)pArg;
-        pGroup->bEnabled = bEnabled;
+        pGroup->bEnabled = (unsigned char)bEnabled;
         rc = SQLITE_OK;
       }
       break;
     case MULTIPLEX_CTRL_SET_CHUNK_SIZE:
       if( pArg ) {
         unsigned int szChunk = *(unsigned*)pArg;
         if( szChunk<1 ){
           rc = SQLITE_MISUSE;
         }else{
           /* Round up to nearest multiple of MAX_PAGE_SIZE. */
@@ skipping 152 matching lines @@
 **
 ** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once
 ** during start-up.
 */
 int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
   sqlite3_vfs *pOrigVfs;
   if( gMultiplex.isInitialized ) return SQLITE_MISUSE;
   pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
   if( pOrigVfs==0 ) return SQLITE_ERROR;
   assert( pOrigVfs!=&gMultiplex.sThisVfs );
-  gMultiplex.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
-  if( !gMultiplex.pMutex ){
-    return SQLITE_NOMEM;
-  }
-  gMultiplex.pGroups = NULL;
   gMultiplex.isInitialized = 1;
   gMultiplex.pOrigVfs = pOrigVfs;
   gMultiplex.sThisVfs = *pOrigVfs;
   gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);
   gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;
   gMultiplex.sThisVfs.xOpen = multiplexOpen;
   gMultiplex.sThisVfs.xDelete = multiplexDelete;
   gMultiplex.sThisVfs.xAccess = multiplexAccess;
   gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname;
   gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen;
@@ skipping 21 matching lines @@
   gMultiplex.sIoMethodsV1.xDeviceCharacteristics =
                                             multiplexDeviceCharacteristics;
   gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1;
   gMultiplex.sIoMethodsV2.iVersion = 2;
   gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap;
   gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock;
   gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;
   gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;
   sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);
 
-  sqlite3_auto_extension((void*)multiplexFuncInit);
+  sqlite3_auto_extension((void(*)(void))multiplexFuncInit);
 
   return SQLITE_OK;
 }
 
 /*
 ** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
 **
 ** All SQLite database connections must be closed before calling this
 ** routine.
 **
 ** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once while
 ** shutting down in order to free all remaining multiplex groups.
 */
 int sqlite3_multiplex_shutdown(int eForce){
   int rc = SQLITE_OK;
   if( gMultiplex.isInitialized==0 ) return SQLITE_MISUSE;
-  if( gMultiplex.pGroups ){
-    sqlite3_log(SQLITE_MISUSE, "sqlite3_multiplex_shutdown() called "
-                "while database connections are still open");
-    if( !eForce ) return SQLITE_MISUSE;
-    rc = SQLITE_MISUSE;
-  }
   gMultiplex.isInitialized = 0;
-  sqlite3_mutex_free(gMultiplex.pMutex);
   sqlite3_vfs_unregister(&gMultiplex.sThisVfs);
   memset(&gMultiplex, 0, sizeof(gMultiplex));
   return rc;
 }
 
 /***************************** Test Code ***********************************/
 #ifdef SQLITE_TEST
-#include <tcl.h>
+#if defined(INCLUDE_SQLITE_TCL_H)
+#  include "sqlite_tcl.h"
+#else
+#  include "tcl.h"
+#  ifndef SQLITE_TCLAPI
+#    define SQLITE_TCLAPI
+#  endif
+#endif
 extern const char *sqlite3ErrName(int);
 
 
 /*
 ** tclcmd: sqlite3_multiplex_initialize NAME MAKEDEFAULT
 */
-static int test_multiplex_initialize(
+static int SQLITE_TCLAPI test_multiplex_initialize(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   const char *zName;              /* Name of new multiplex VFS */
   int makeDefault;                /* True to make the new VFS the default */
   int rc;                         /* Value returned by multiplex_initialize() */
 
   UNUSED_PARAMETER(clientData);
@@ skipping 10 matching lines @@
   /* Call sqlite3_multiplex_initialize() */
   rc = sqlite3_multiplex_initialize(zName, makeDefault);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
 
   return TCL_OK;
 }
 
 /*
 ** tclcmd: sqlite3_multiplex_shutdown
 */
-static int test_multiplex_shutdown(
+static int SQLITE_TCLAPI test_multiplex_shutdown(
   void * clientData,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;                         /* Value returned by multiplex_shutdown() */
 
   UNUSED_PARAMETER(clientData);
 
   if( objc==2 && strcmp(Tcl_GetString(objv[1]),"-force")!=0 ){
     objc = 3;
   }
   if( (objc!=1 && objc!=2) ){
     Tcl_WrongNumArgs(interp, 1, objv, "?-force?");
     return TCL_ERROR;
   }
 
   /* Call sqlite3_multiplex_shutdown() */
   rc = sqlite3_multiplex_shutdown(objc==2);
   Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
 
   return TCL_OK;
 }
 
 /*
-** tclcmd:  sqlite3_multiplex_dump
-*/
-static int test_multiplex_dump(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  Tcl_Obj *pResult;
-  Tcl_Obj *pGroupTerm;
-  multiplexGroup *pGroup;
-  int i;
-  int nChunks = 0;
-
-  UNUSED_PARAMETER(clientData);
-  UNUSED_PARAMETER(objc);
-  UNUSED_PARAMETER(objv);
-
-  pResult = Tcl_NewObj();
-  multiplexEnter();
-  for(pGroup=gMultiplex.pGroups; pGroup; pGroup=pGroup->pNext){
-    pGroupTerm = Tcl_NewObj();
-
-    if( pGroup->zName ){
-      pGroup->zName[pGroup->nName] = '\0';
-      Tcl_ListObjAppendElement(interp, pGroupTerm,
-          Tcl_NewStringObj(pGroup->zName, -1));
-    }else{
-      Tcl_ListObjAppendElement(interp, pGroupTerm, Tcl_NewObj());
-    }
-    Tcl_ListObjAppendElement(interp, pGroupTerm,
-          Tcl_NewIntObj(pGroup->nName));
-    Tcl_ListObjAppendElement(interp, pGroupTerm,
-          Tcl_NewIntObj(pGroup->flags));
-
-    /* count number of chunks with open handles */
-    for(i=0; i<pGroup->nReal; i++){
-      if( pGroup->aReal[i].p!=0 ) nChunks++;
-    }
-    Tcl_ListObjAppendElement(interp, pGroupTerm,
-          Tcl_NewIntObj(nChunks));
-
-    Tcl_ListObjAppendElement(interp, pGroupTerm,
-          Tcl_NewIntObj(pGroup->szChunk));
-    Tcl_ListObjAppendElement(interp, pGroupTerm,
-          Tcl_NewIntObj(pGroup->nReal));
-
-    Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
-  }
-  multiplexLeave();
-  Tcl_SetObjResult(interp, pResult);
-  return TCL_OK;
-}
-
-/*
 ** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE?
 */
-static int test_multiplex_control(
+static int SQLITE_TCLAPI test_multiplex_control(
   ClientData cd,
   Tcl_Interp *interp,
   int objc,
   Tcl_Obj *CONST objv[]
 ){
   int rc;                         /* Return code from file_control() */
   int idx;                        /* Index in aSub[] */
   Tcl_CmdInfo cmdInfo;            /* Command info structure for HANDLE */
   sqlite3 *db;                    /* Underlying db handle for HANDLE */
   int iValue = 0;
@@ skipping 50 matching lines @@
 ** module.  This should be the only procedure visible from outside
 ** of this module.
 */
 int Sqlitemultiplex_Init(Tcl_Interp *interp){
   static struct {
      char *zName;
      Tcl_ObjCmdProc *xProc;
   } aCmd[] = {
     { "sqlite3_multiplex_initialize", test_multiplex_initialize },
     { "sqlite3_multiplex_shutdown", test_multiplex_shutdown },
-    { "sqlite3_multiplex_dump", test_multiplex_dump },
     { "sqlite3_multiplex_control", test_multiplex_control },
   };
   int i;
 
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
   }
 
   return TCL_OK;
 }
 #endif