Merge the multiplexer enhancements back into the trunk.
FossilOrigin-Name: 2c125710cbf04198464d436b16e5ef37c5b219cf
This commit is contained in:
drh
commit
d820b42c29
15
manifest
15
manifest
@ -1,5 +1,5 @@
|
||||
C Add\sa\sscript\sthat\swill\sbreak\sthe\samalgamation\ssource\sfile\sup\sinto\s4\sor\s5\nsmaller\ssource\sfiles,\seach\s32K\slines\sor\sfewer,\sand\sa\ssingle\s"sqlite3-all.c"\nsource\sfile\sthat\s#includes\sthe\sothers.
|
||||
D 2011-04-01T18:12:58.662
|
||||
C Merge\sthe\smultiplexer\senhancements\sback\sinto\sthe\strunk.
|
||||
D 2011-04-01T18:39:24.584
|
||||
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
|
||||
F Makefile.in 27701a1653595a1f2187dc61c8117e00a6c1d50f
|
||||
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
|
||||
@ -209,7 +209,8 @@ F src/test_intarray.h 489edb9068bb926583445cb02589344961054207
|
||||
F src/test_journal.c 785edd54f963aefb3c1628124170a56697c68c70
|
||||
F src/test_loadext.c df586c27176e3c2cb2e099c78da67bf14379a56e
|
||||
F src/test_malloc.c fd6188b1501c0010fb4241ddc9f0d5ac402c688d
|
||||
F src/test_multiplex.c 655cb3b663f87db7d3d2427ea127c9daacae4abc
|
||||
F src/test_multiplex.c fdabd793ee7a9642c5a8a470def2347144c46d05
|
||||
F src/test_multiplex.h e99c571bc4968b7a9363b661481f3934bfead61d
|
||||
F src/test_mutex.c a6bd7b9cf6e19d989e31392b06ac8d189f0d573e
|
||||
F src/test_onefile.c 40cf9e212a377a6511469384a64b01e6e34b2eec
|
||||
F src/test_osinst.c f408c6a181f2fb04c56273afd5c3e1e82f60392c
|
||||
@ -579,7 +580,7 @@ F test/misc5.test 45b2e3ed5f79af2b4f38ae362eaf4c49674575bd
|
||||
F test/misc6.test 953cc693924d88e6117aeba16f46f0bf5abede91
|
||||
F test/misc7.test 29032efcd3d826fbd409e2a7af873e7939f4a4e3
|
||||
F test/misuse.test 30b3a458e5a70c31e74c291937b6c82204c59f33
|
||||
F test/multiplex.test 92a4839213fd8cba8b59f86d42b7a1da1857db39
|
||||
F test/multiplex.test a88f3e2c16e567e72be7296195c59fbdd6a8d3d4
|
||||
F test/mutex1.test 78b2b9bb320e51d156c4efdb71b99b051e7a4b41
|
||||
F test/mutex2.test bfeaeac2e73095b2ac32285d2756e3a65e681660
|
||||
F test/nan.test a44e04df1486fcfb02d32468cbcd3c8e1e433723
|
||||
@ -922,7 +923,7 @@ F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
|
||||
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
|
||||
F tool/split-sqlite3c.tcl d9be87f1c340285a3e081eb19b4a247981ed290c
|
||||
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
|
||||
P 9415201c8a0b9b640f5997c5348c5df812e88230
|
||||
R c3ff07e6303499e88c2cf0a9abaa71e9
|
||||
P 5d34e64d4d2398aa9a54fd0a4f1de37ced7ea5dd 718f1ad7df9115871ba6159012d3183183fc40a1
|
||||
R 3be437ca6e714e1f6c593836a791944c
|
||||
U drh
|
||||
Z 975ba0a508eed8e252cfd7014026f442
|
||||
Z e8e2d5336305d42bc1912c6d6b830ecf
|
||||
|
||||
@ -1 +1 @@
|
||||
5d34e64d4d2398aa9a54fd0a4f1de37ced7ea5dd
|
||||
2c125710cbf04198464d436b16e5ef37c5b219cf
|
||||
@ -22,7 +22,22 @@
|
||||
#include "sqlite3.h"
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
#include "sqliteInt.h"
|
||||
#include "test_multiplex.h"
|
||||
|
||||
#ifndef SQLITE_CORE
|
||||
#define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
|
||||
#endif
|
||||
#include "sqlite3ext.h"
|
||||
|
||||
/*
|
||||
** These should be defined to be the same as the values in
|
||||
** sqliteInt.h. They are defined seperately 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.
|
||||
@ -40,14 +55,18 @@
|
||||
|
||||
/************************ Shim Definitions ******************************/
|
||||
|
||||
#define SQLITE_MULTIPLEX_VFS_NAME "multiplex"
|
||||
|
||||
/* This is the limit on the chunk size. It may be changed by calling
|
||||
** the sqlite3_multiplex_set() interface.
|
||||
** the xFileControl() interface. It will be rounded up to a
|
||||
** multiple of MAX_PAGE_SIZE. We default it here to 1GB.
|
||||
*/
|
||||
#define SQLITE_MULTIPLEX_CHUNK_SIZE 0x40000000
|
||||
#define SQLITE_MULTIPLEX_CHUNK_SIZE (MAX_PAGE_SIZE*16384)
|
||||
|
||||
/* Default limit on number of chunks. Care should be taken
|
||||
** so that values for chunks numbers fit in the SQLITE_MULTIPLEX_EXT_FMT
|
||||
** format specifier. It may be changed by calling
|
||||
** the sqlite3_multiplex_set() interface.
|
||||
** the xFileControl() interface.
|
||||
*/
|
||||
#define SQLITE_MULTIPLEX_MAX_CHUNKS 32
|
||||
|
||||
@ -82,6 +101,9 @@ struct multiplexGroup {
|
||||
char *zName; /* Base filename of this group */
|
||||
int nName; /* Length of base filename */
|
||||
int flags; /* Flags used for original opening */
|
||||
int nChunkSize; /* Chunk size used for this group */
|
||||
int nMaxChunks; /* Max number of chunks for this group */
|
||||
int bEnabled; /* TRUE to use Multiplex VFS for this file */
|
||||
multiplexGroup *pNext, *pPrev; /* Doubly linked list of all group objects */
|
||||
};
|
||||
|
||||
@ -140,11 +162,6 @@ static struct {
|
||||
*/
|
||||
multiplexGroup *pGroups;
|
||||
|
||||
/* Chunk params.
|
||||
*/
|
||||
int nChunkSize;
|
||||
int nMaxChunks;
|
||||
|
||||
/* Storage for temp file names. Allocated during
|
||||
** initialization to the max pathname of the underlying VFS.
|
||||
*/
|
||||
@ -160,13 +177,28 @@ static struct {
|
||||
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.
|
||||
*/
|
||||
int multiplexStrlen30(const char *z){
|
||||
const char *z2 = z;
|
||||
if( z==0 ) return 0;
|
||||
while( *z2 ){ z2++; }
|
||||
return 0x3fffffff & (int)(z2 - z);
|
||||
}
|
||||
|
||||
/* Translate an sqlite3_file* that is really a multiplexGroup* into
|
||||
** the sqlite3_file* for the underlying original VFS.
|
||||
*/
|
||||
static sqlite3_file *multiplexSubOpen(multiplexConn *pConn, int iChunk, int *rc, int *pOutFlags){
|
||||
multiplexGroup *pGroup = pConn->pGroup;
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
if( iChunk<gMultiplex.nMaxChunks ){
|
||||
if( iChunk<pGroup->nMaxChunks ){
|
||||
sqlite3_file *pSubOpen = pGroup->pReal[iChunk]; /* Real file descriptor */
|
||||
if( !pGroup->bOpen[iChunk] ){
|
||||
memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
|
||||
@ -191,6 +223,62 @@ static sqlite3_file *multiplexSubOpen(multiplexConn *pConn, int iChunk, int *rc,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
** This is the implementation of the multiplex_control() SQL function.
|
||||
*/
|
||||
static void multiplexControlFunc(
|
||||
sqlite3_context *context,
|
||||
int argc,
|
||||
sqlite3_value **argv
|
||||
){
|
||||
int rc = SQLITE_OK;
|
||||
sqlite3 *db = sqlite3_context_db_handle(context);
|
||||
int op;
|
||||
int iVal;
|
||||
|
||||
if( !db || argc!=2 ){
|
||||
rc = SQLITE_ERROR;
|
||||
}else{
|
||||
/* extract params */
|
||||
op = sqlite3_value_int(argv[0]);
|
||||
iVal = sqlite3_value_int(argv[1]);
|
||||
/* map function op to file_control op */
|
||||
switch( op ){
|
||||
case 1:
|
||||
op = MULTIPLEX_CTRL_ENABLE;
|
||||
break;
|
||||
case 2:
|
||||
op = MULTIPLEX_CTRL_SET_CHUNK_SIZE;
|
||||
break;
|
||||
case 3:
|
||||
op = MULTIPLEX_CTRL_SET_MAX_CHUNKS;
|
||||
break;
|
||||
default:
|
||||
rc = SQLITE_NOTFOUND;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if( rc==SQLITE_OK ){
|
||||
rc = sqlite3_file_control(db, 0, op, &iVal);
|
||||
}
|
||||
sqlite3_result_error_code(context, rc);
|
||||
}
|
||||
|
||||
/*
|
||||
** This is the entry point to register the auto-extension for the
|
||||
** multiplex_control() function.
|
||||
*/
|
||||
static int multiplexFuncInit(
|
||||
sqlite3 *db,
|
||||
char **pzErrMsg,
|
||||
const sqlite3_api_routines *pApi
|
||||
){
|
||||
int rc;
|
||||
rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY,
|
||||
0, multiplexControlFunc, 0, 0);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/************************* VFS Method Wrappers *****************************/
|
||||
|
||||
/*
|
||||
@ -212,7 +300,7 @@ static int multiplexOpen(
|
||||
multiplexGroup *pGroup; /* Corresponding multiplexGroup object */
|
||||
sqlite3_file *pSubOpen; /* Real file descriptor */
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
int nName = sqlite3Strlen30(zName);
|
||||
int nName = multiplexStrlen30(zName);
|
||||
int i;
|
||||
int sz;
|
||||
|
||||
@ -224,11 +312,11 @@ static int multiplexOpen(
|
||||
multiplexEnter();
|
||||
pMultiplexOpen = (multiplexConn*)pConn;
|
||||
/* allocate space for group */
|
||||
sz = sizeof(multiplexGroup) /* multiplexGroup */
|
||||
+ (sizeof(sqlite3_file *)*gMultiplex.nMaxChunks) /* pReal[] */
|
||||
+ (pOrigVfs->szOsFile*gMultiplex.nMaxChunks) /* *pReal */
|
||||
+ gMultiplex.nMaxChunks /* bOpen[] */
|
||||
+ nName + 1; /* zName */
|
||||
sz = sizeof(multiplexGroup) /* multiplexGroup */
|
||||
+ (sizeof(sqlite3_file *)*SQLITE_MULTIPLEX_MAX_CHUNKS) /* pReal[] */
|
||||
+ (pOrigVfs->szOsFile*SQLITE_MULTIPLEX_MAX_CHUNKS) /* *pReal */
|
||||
+ SQLITE_MULTIPLEX_MAX_CHUNKS /* bOpen[] */
|
||||
+ nName + 1; /* zName */
|
||||
#ifndef SQLITE_MULTIPLEX_EXT_OVWR
|
||||
sz += SQLITE_MULTIPLEX_EXT_SZ;
|
||||
assert(nName+SQLITE_MULTIPLEX_EXT_SZ < pOrigVfs->mxPathname);
|
||||
@ -244,14 +332,18 @@ static int multiplexOpen(
|
||||
char *p = (char *)&pGroup[1];
|
||||
pMultiplexOpen->pGroup = pGroup;
|
||||
memset(pGroup, 0, sz);
|
||||
pGroup->bEnabled = -1;
|
||||
pGroup->nChunkSize = SQLITE_MULTIPLEX_CHUNK_SIZE;
|
||||
pGroup->nMaxChunks = SQLITE_MULTIPLEX_MAX_CHUNKS;
|
||||
pGroup->pReal = (sqlite3_file **)p;
|
||||
p += (sizeof(sqlite3_file *)*gMultiplex.nMaxChunks);
|
||||
for(i=0; i<gMultiplex.nMaxChunks; i++){
|
||||
p += (sizeof(sqlite3_file *)*pGroup->nMaxChunks);
|
||||
for(i=0; i<pGroup->nMaxChunks; i++){
|
||||
pGroup->pReal[i] = (sqlite3_file *)p;
|
||||
p += pOrigVfs->szOsFile;
|
||||
}
|
||||
/* bOpen[] vals should all be zero from memset above */
|
||||
pGroup->bOpen = p;
|
||||
p += gMultiplex.nMaxChunks;
|
||||
p += pGroup->nMaxChunks;
|
||||
pGroup->zName = p;
|
||||
/* save off base filename, name length, and original open flags */
|
||||
memcpy(pGroup->zName, zName, nName+1);
|
||||
@ -259,6 +351,14 @@ static int multiplexOpen(
|
||||
pGroup->flags = flags;
|
||||
pSubOpen = multiplexSubOpen(pMultiplexOpen, 0, &rc, pOutFlags);
|
||||
if( pSubOpen ){
|
||||
/* if this file is already larger than chunk size, disable
|
||||
** the multiplex feature.
|
||||
*/
|
||||
sqlite3_int64 sz;
|
||||
int rc2 = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
|
||||
if( (rc2==SQLITE_OK) && (sz>pGroup->nChunkSize) ){
|
||||
pGroup->bEnabled = 0;
|
||||
}
|
||||
if( pSubOpen->pMethods->iVersion==1 ){
|
||||
pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV1;
|
||||
}else{
|
||||
@ -288,24 +388,29 @@ static int multiplexDelete(
|
||||
){
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
int rc = SQLITE_OK;
|
||||
int nName = sqlite3Strlen30(zName);
|
||||
int nName = multiplexStrlen30(zName);
|
||||
int i;
|
||||
|
||||
UNUSED_PARAMETER(pVfs);
|
||||
|
||||
multiplexEnter();
|
||||
memcpy(gMultiplex.zName, zName, nName+1);
|
||||
for(i=0; i<gMultiplex.nMaxChunks; i++){
|
||||
for(i=0; i<SQLITE_MULTIPLEX_MAX_CHUNKS; i++){
|
||||
int rc2;
|
||||
int exists = 0;
|
||||
if( i ){
|
||||
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+nName-SQLITE_MULTIPLEX_EXT_SZ, SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
|
||||
gMultiplex.zName+nName-SQLITE_MULTIPLEX_EXT_SZ,
|
||||
SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#else
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+nName, SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
|
||||
gMultiplex.zName+nName,
|
||||
SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#endif
|
||||
}
|
||||
rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName, SQLITE_ACCESS_EXISTS, &exists);
|
||||
rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName,
|
||||
SQLITE_ACCESS_EXISTS, &exists);
|
||||
if( rc2==SQLITE_OK && exists){
|
||||
/* if it exists, delete it */
|
||||
rc2 = pOrigVfs->xDelete(pOrigVfs, gMultiplex.zName, syncDir);
|
||||
@ -367,7 +472,7 @@ static int multiplexClose(sqlite3_file *pConn){
|
||||
int i;
|
||||
multiplexEnter();
|
||||
/* close any open handles */
|
||||
for(i=0; i<gMultiplex.nMaxChunks; i++){
|
||||
for(i=0; i<pGroup->nMaxChunks; i++){
|
||||
if( pGroup->bOpen[i] ){
|
||||
sqlite3_file *pSubOpen = pGroup->pReal[i];
|
||||
int rc2 = pSubOpen->pMethods->xClose(pSubOpen);
|
||||
@ -398,23 +503,29 @@ static int multiplexRead(
|
||||
sqlite3_int64 iOfst
|
||||
){
|
||||
multiplexConn *p = (multiplexConn*)pConn;
|
||||
multiplexGroup *pGroup = p->pGroup;
|
||||
int rc = SQLITE_OK;
|
||||
multiplexEnter();
|
||||
while( iAmt > 0 ){
|
||||
int i = (int)(iOfst/gMultiplex.nChunkSize);
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
|
||||
if( pSubOpen ){
|
||||
int extra = ((int)(iOfst % gMultiplex.nChunkSize) + iAmt) - gMultiplex.nChunkSize;
|
||||
if( extra<0 ) extra = 0;
|
||||
iAmt -= extra;
|
||||
rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst%gMultiplex.nChunkSize);
|
||||
if( rc!=SQLITE_OK ) break;
|
||||
pBuf = (char *)pBuf + iAmt;
|
||||
iOfst += iAmt;
|
||||
iAmt = extra;
|
||||
}else{
|
||||
rc = SQLITE_IOERR_READ;
|
||||
break;
|
||||
if( !pGroup->bEnabled ){
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
|
||||
rc = ( !pSubOpen ) ? SQLITE_IOERR_READ : pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
|
||||
}else{
|
||||
while( iAmt > 0 ){
|
||||
int i = (int)(iOfst / pGroup->nChunkSize);
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
|
||||
if( pSubOpen ){
|
||||
int extra = ((int)(iOfst % pGroup->nChunkSize) + iAmt) - pGroup->nChunkSize;
|
||||
if( extra<0 ) extra = 0;
|
||||
iAmt -= extra;
|
||||
rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst % pGroup->nChunkSize);
|
||||
if( rc!=SQLITE_OK ) break;
|
||||
pBuf = (char *)pBuf + iAmt;
|
||||
iOfst += iAmt;
|
||||
iAmt = extra;
|
||||
}else{
|
||||
rc = SQLITE_IOERR_READ;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
multiplexLeave();
|
||||
@ -432,23 +543,29 @@ static int multiplexWrite(
|
||||
sqlite3_int64 iOfst
|
||||
){
|
||||
multiplexConn *p = (multiplexConn*)pConn;
|
||||
multiplexGroup *pGroup = p->pGroup;
|
||||
int rc = SQLITE_OK;
|
||||
multiplexEnter();
|
||||
while( iAmt > 0 ){
|
||||
int i = (int)(iOfst/gMultiplex.nChunkSize);
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
|
||||
if( pSubOpen ){
|
||||
int extra = ((int)(iOfst % gMultiplex.nChunkSize) + iAmt) - gMultiplex.nChunkSize;
|
||||
if( extra<0 ) extra = 0;
|
||||
iAmt -= extra;
|
||||
rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst%gMultiplex.nChunkSize);
|
||||
if( rc!=SQLITE_OK ) break;
|
||||
pBuf = (char *)pBuf + iAmt;
|
||||
iOfst += iAmt;
|
||||
iAmt = extra;
|
||||
}else{
|
||||
rc = SQLITE_IOERR_WRITE;
|
||||
break;
|
||||
if( !pGroup->bEnabled ){
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
|
||||
rc = ( !pSubOpen ) ? SQLITE_IOERR_WRITE : pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
|
||||
}else{
|
||||
while( iAmt > 0 ){
|
||||
int i = (int)(iOfst / pGroup->nChunkSize);
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
|
||||
if( pSubOpen ){
|
||||
int extra = ((int)(iOfst % pGroup->nChunkSize) + iAmt) - pGroup->nChunkSize;
|
||||
if( extra<0 ) extra = 0;
|
||||
iAmt -= extra;
|
||||
rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst % pGroup->nChunkSize);
|
||||
if( rc!=SQLITE_OK ) break;
|
||||
pBuf = (char *)pBuf + iAmt;
|
||||
iOfst += iAmt;
|
||||
iAmt = extra;
|
||||
}else{
|
||||
rc = SQLITE_IOERR_WRITE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
multiplexLeave();
|
||||
@ -463,35 +580,44 @@ static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){
|
||||
multiplexConn *p = (multiplexConn*)pConn;
|
||||
multiplexGroup *pGroup = p->pGroup;
|
||||
int rc = SQLITE_OK;
|
||||
int rc2;
|
||||
int i;
|
||||
sqlite3_file *pSubOpen;
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
multiplexEnter();
|
||||
memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
|
||||
/* delete the chunks above the truncate limit */
|
||||
for(i=(int)(size/gMultiplex.nChunkSize)+1; i<gMultiplex.nMaxChunks; i++){
|
||||
/* close any open chunks before deleting them */
|
||||
if( pGroup->bOpen[i] ){
|
||||
pSubOpen = pGroup->pReal[i];
|
||||
rc2 = pSubOpen->pMethods->xClose(pSubOpen);
|
||||
if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
|
||||
pGroup->bOpen[i] = 0;
|
||||
}
|
||||
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ, SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#else
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName, SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#endif
|
||||
rc2 = pOrigVfs->xDelete(pOrigVfs, gMultiplex.zName, 0);
|
||||
if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
|
||||
}
|
||||
pSubOpen = multiplexSubOpen(p, (int)(size/gMultiplex.nChunkSize), &rc2, NULL);
|
||||
if( pSubOpen ){
|
||||
rc2 = pSubOpen->pMethods->xTruncate(pSubOpen, size%gMultiplex.nChunkSize);
|
||||
if( rc2!=SQLITE_OK ) rc = rc2;
|
||||
if( !pGroup->bEnabled ){
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
|
||||
rc = ( !pSubOpen ) ? SQLITE_IOERR_TRUNCATE : pSubOpen->pMethods->xTruncate(pSubOpen, size);
|
||||
}else{
|
||||
rc = SQLITE_IOERR_TRUNCATE;
|
||||
int rc2;
|
||||
int i;
|
||||
sqlite3_file *pSubOpen;
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
|
||||
/* delete the chunks above the truncate limit */
|
||||
for(i=(int)(size / pGroup->nChunkSize)+1; i<pGroup->nMaxChunks; i++){
|
||||
/* close any open chunks before deleting them */
|
||||
if( pGroup->bOpen[i] ){
|
||||
pSubOpen = pGroup->pReal[i];
|
||||
rc2 = pSubOpen->pMethods->xClose(pSubOpen);
|
||||
if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
|
||||
pGroup->bOpen[i] = 0;
|
||||
}
|
||||
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
|
||||
gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ,
|
||||
SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#else
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
|
||||
gMultiplex.zName+pGroup->nName,
|
||||
SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#endif
|
||||
rc2 = pOrigVfs->xDelete(pOrigVfs, gMultiplex.zName, 0);
|
||||
if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
|
||||
}
|
||||
pSubOpen = multiplexSubOpen(p, (int)(size / pGroup->nChunkSize), &rc2, NULL);
|
||||
if( pSubOpen ){
|
||||
rc2 = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->nChunkSize);
|
||||
if( rc2!=SQLITE_OK ) rc = rc2;
|
||||
}else{
|
||||
rc = SQLITE_IOERR_TRUNCATE;
|
||||
}
|
||||
}
|
||||
multiplexLeave();
|
||||
return rc;
|
||||
@ -505,7 +631,7 @@ static int multiplexSync(sqlite3_file *pConn, int flags){
|
||||
int rc = SQLITE_OK;
|
||||
int i;
|
||||
multiplexEnter();
|
||||
for(i=0; i<gMultiplex.nMaxChunks; i++){
|
||||
for(i=0; i<pGroup->nMaxChunks; i++){
|
||||
/* if we don't have it open, we don't need to sync it */
|
||||
if( pGroup->bOpen[i] ){
|
||||
sqlite3_file *pSubOpen = pGroup->pReal[i];
|
||||
@ -527,46 +653,56 @@ static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
|
||||
int rc2;
|
||||
int i;
|
||||
multiplexEnter();
|
||||
*pSize = 0;
|
||||
for(i=0; i<gMultiplex.nMaxChunks; i++){
|
||||
sqlite3_file *pSubOpen = NULL;
|
||||
/* if not opened already, check to see if the chunk exists */
|
||||
if( pGroup->bOpen[i] ){
|
||||
pSubOpen = pGroup->pReal[i];
|
||||
}else{
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
int exists = 0;
|
||||
memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
|
||||
if( i ){
|
||||
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ, SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#else
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName, SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#endif
|
||||
}
|
||||
rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName, SQLITE_ACCESS_EXISTS, &exists);
|
||||
if( rc2==SQLITE_OK && exists){
|
||||
/* if it exists, open it */
|
||||
pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
|
||||
if( !pGroup->bEnabled ){
|
||||
sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
|
||||
rc = ( !pSubOpen ) ? SQLITE_IOERR_FSTAT : pSubOpen->pMethods->xFileSize(pSubOpen, pSize);
|
||||
}else{
|
||||
*pSize = 0;
|
||||
for(i=0; i<pGroup->nMaxChunks; i++){
|
||||
sqlite3_file *pSubOpen = NULL;
|
||||
/* if not opened already, check to see if the chunk exists */
|
||||
if( pGroup->bOpen[i] ){
|
||||
pSubOpen = pGroup->pReal[i];
|
||||
}else{
|
||||
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
|
||||
int exists = 0;
|
||||
memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
|
||||
if( i ){
|
||||
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
|
||||
gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ,
|
||||
SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#else
|
||||
sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
|
||||
gMultiplex.zName+pGroup->nName,
|
||||
SQLITE_MULTIPLEX_EXT_FMT, i);
|
||||
#endif
|
||||
}
|
||||
rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName,
|
||||
SQLITE_ACCESS_EXISTS, &exists);
|
||||
if( rc2==SQLITE_OK && exists){
|
||||
/* if it exists, open it */
|
||||
pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
|
||||
}else{
|
||||
/* stop at first "gap" */
|
||||
break;
|
||||
}
|
||||
}
|
||||
if( pSubOpen ){
|
||||
sqlite3_int64 sz;
|
||||
rc2 = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
|
||||
if( rc2!=SQLITE_OK ){
|
||||
rc = rc2;
|
||||
}else{
|
||||
if( sz>pGroup->nChunkSize ){
|
||||
rc = SQLITE_IOERR_FSTAT;
|
||||
}
|
||||
*pSize += sz;
|
||||
}
|
||||
}else{
|
||||
/* stop at first "gap" */
|
||||
break;
|
||||
}
|
||||
}
|
||||
if( pSubOpen ){
|
||||
sqlite3_int64 sz;
|
||||
rc2 = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
|
||||
if( rc2!=SQLITE_OK ){
|
||||
rc = rc2;
|
||||
}else{
|
||||
if( sz>gMultiplex.nChunkSize ){
|
||||
rc = SQLITE_IOERR_FSTAT;
|
||||
}
|
||||
*pSize += sz;
|
||||
}
|
||||
}else{
|
||||
break;
|
||||
}
|
||||
}
|
||||
multiplexLeave();
|
||||
return rc;
|
||||
@ -608,18 +744,62 @@ static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){
|
||||
return SQLITE_IOERR_CHECKRESERVEDLOCK;
|
||||
}
|
||||
|
||||
/* Pass xFileControl requests through to the original VFS unchanged.
|
||||
/* Pass xFileControl requests through to the original VFS unchanged,
|
||||
** except for any MULTIPLEX_CTRL_* requests here.
|
||||
*/
|
||||
static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
|
||||
multiplexConn *p = (multiplexConn*)pConn;
|
||||
int rc;
|
||||
multiplexGroup *pGroup = p->pGroup;
|
||||
int rc = SQLITE_ERROR;
|
||||
sqlite3_file *pSubOpen;
|
||||
if ( op==SQLITE_FCNTL_SIZE_HINT || op==SQLITE_FCNTL_CHUNK_SIZE ) return SQLITE_OK;
|
||||
pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
|
||||
if( pSubOpen ){
|
||||
return pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
|
||||
|
||||
if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
|
||||
switch( op ){
|
||||
case MULTIPLEX_CTRL_ENABLE:
|
||||
if( pArg ) {
|
||||
int bEnabled = *(int *)pArg;
|
||||
pGroup->bEnabled = bEnabled;
|
||||
rc = SQLITE_OK;
|
||||
}
|
||||
break;
|
||||
case MULTIPLEX_CTRL_SET_CHUNK_SIZE:
|
||||
if( pArg ) {
|
||||
int nChunkSize = *(int *)pArg;
|
||||
if( nChunkSize<1 ){
|
||||
rc = SQLITE_MISUSE;
|
||||
}else{
|
||||
/* Round up to nearest multiple of MAX_PAGE_SIZE. */
|
||||
nChunkSize = (nChunkSize + (MAX_PAGE_SIZE-1));
|
||||
nChunkSize &= ~(MAX_PAGE_SIZE-1);
|
||||
pGroup->nChunkSize = nChunkSize;
|
||||
rc = SQLITE_OK;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case MULTIPLEX_CTRL_SET_MAX_CHUNKS:
|
||||
if( pArg ) {
|
||||
int nMaxChunks = *(int *)pArg;
|
||||
if(( nMaxChunks<1 ) || ( nMaxChunks>SQLITE_MULTIPLEX_MAX_CHUNKS )){
|
||||
rc = SQLITE_MISUSE;
|
||||
}else{
|
||||
pGroup->nMaxChunks = nMaxChunks;
|
||||
rc = SQLITE_OK;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SQLITE_FCNTL_SIZE_HINT:
|
||||
case SQLITE_FCNTL_CHUNK_SIZE:
|
||||
/* no-op these */
|
||||
rc = SQLITE_OK;
|
||||
break;
|
||||
default:
|
||||
pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
|
||||
if( pSubOpen ){
|
||||
rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return SQLITE_ERROR;
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Pass xSectorSize requests through to the original VFS unchanged.
|
||||
@ -631,7 +811,7 @@ static int multiplexSectorSize(sqlite3_file *pConn){
|
||||
if( pSubOpen ){
|
||||
return pSubOpen->pMethods->xSectorSize(pSubOpen);
|
||||
}
|
||||
return SQLITE_DEFAULT_SECTOR_SIZE;
|
||||
return DEFAULT_SECTOR_SIZE;
|
||||
}
|
||||
|
||||
/* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
|
||||
@ -706,9 +886,10 @@ static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){
|
||||
|
||||
/************************** Public Interfaces *****************************/
|
||||
/*
|
||||
** Initialize the multiplex VFS shim. Use the VFS named zOrigVfsName
|
||||
** as the VFS that does the actual work. Use the default if
|
||||
** zOrigVfsName==NULL.
|
||||
** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
|
||||
**
|
||||
** Use the VFS named zOrigVfsName as the VFS that does the actual work.
|
||||
** Use the default if zOrigVfsName==NULL.
|
||||
**
|
||||
** The multiplex VFS shim is named "multiplex". It will become the default
|
||||
** VFS if makeDefault is non-zero.
|
||||
@ -731,14 +912,12 @@ int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
|
||||
sqlite3_mutex_free(gMultiplex.pMutex);
|
||||
return SQLITE_NOMEM;
|
||||
}
|
||||
gMultiplex.nChunkSize = SQLITE_MULTIPLEX_CHUNK_SIZE;
|
||||
gMultiplex.nMaxChunks = SQLITE_MULTIPLEX_MAX_CHUNKS;
|
||||
gMultiplex.pGroups = NULL;
|
||||
gMultiplex.isInitialized = 1;
|
||||
gMultiplex.pOrigVfs = pOrigVfs;
|
||||
gMultiplex.sThisVfs = *pOrigVfs;
|
||||
gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);
|
||||
gMultiplex.sThisVfs.zName = "multiplex";
|
||||
gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;
|
||||
gMultiplex.sThisVfs.xOpen = multiplexOpen;
|
||||
gMultiplex.sThisVfs.xDelete = multiplexDelete;
|
||||
gMultiplex.sThisVfs.xAccess = multiplexAccess;
|
||||
@ -773,11 +952,14 @@ int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
|
||||
gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;
|
||||
gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;
|
||||
sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);
|
||||
|
||||
sqlite3_auto_extension((void*)multiplexFuncInit);
|
||||
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Shutdown the multiplex system.
|
||||
** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
|
||||
**
|
||||
** All SQLite database connections must be closed before calling this
|
||||
** routine.
|
||||
@ -796,31 +978,9 @@ int sqlite3_multiplex_shutdown(void){
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Adjust chunking params. VFS should be initialized first.
|
||||
** No files should be open. Re-intializing will reset these
|
||||
** to the default.
|
||||
*/
|
||||
int sqlite3_multiplex_set(
|
||||
int nChunkSize, /* Max chunk size */
|
||||
int nMaxChunks /* Max number of chunks */
|
||||
){
|
||||
if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
|
||||
if( gMultiplex.pGroups ) return SQLITE_MISUSE;
|
||||
if( nChunkSize<32 ) return SQLITE_MISUSE;
|
||||
if( nMaxChunks<1 ) return SQLITE_MISUSE;
|
||||
if( nMaxChunks>99 ) return SQLITE_MISUSE;
|
||||
multiplexEnter();
|
||||
gMultiplex.nChunkSize = nChunkSize;
|
||||
gMultiplex.nMaxChunks = nMaxChunks;
|
||||
multiplexLeave();
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/***************************** Test Code ***********************************/
|
||||
#ifdef SQLITE_TEST
|
||||
#include <tcl.h>
|
||||
|
||||
extern const char *sqlite3TestErrorName(int);
|
||||
|
||||
|
||||
@ -880,36 +1040,6 @@ static int test_multiplex_shutdown(
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** tclcmd: sqlite3_multiplex_set CHUNK_SIZE MAX_CHUNKS
|
||||
*/
|
||||
static int test_multiplex_set(
|
||||
void * clientData,
|
||||
Tcl_Interp *interp,
|
||||
int objc,
|
||||
Tcl_Obj *CONST objv[]
|
||||
){
|
||||
int nChunkSize; /* Max chunk size */
|
||||
int nMaxChunks; /* Max number of chunks */
|
||||
int rc; /* Value returned by sqlite3_multiplex_set() */
|
||||
|
||||
UNUSED_PARAMETER(clientData);
|
||||
|
||||
/* Process arguments */
|
||||
if( objc!=3 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "CHUNK_SIZE MAX_CHUNKS");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
if( Tcl_GetIntFromObj(interp, objv[1], &nChunkSize) ) return TCL_ERROR;
|
||||
if( Tcl_GetIntFromObj(interp, objv[2], &nMaxChunks) ) return TCL_ERROR;
|
||||
|
||||
/* Invoke sqlite3_multiplex_set() */
|
||||
rc = sqlite3_multiplex_set(nChunkSize, nMaxChunks);
|
||||
|
||||
Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** tclcmd: sqlite3_multiplex_dump
|
||||
*/
|
||||
@ -943,16 +1073,16 @@ static int test_multiplex_dump(
|
||||
Tcl_NewIntObj(pGroup->flags));
|
||||
|
||||
/* count number of chunks with open handles */
|
||||
for(i=0; i<gMultiplex.nMaxChunks; i++){
|
||||
for(i=0; i<pGroup->nMaxChunks; i++){
|
||||
if( pGroup->bOpen[i] ) nChunks++;
|
||||
}
|
||||
Tcl_ListObjAppendElement(interp, pGroupTerm,
|
||||
Tcl_NewIntObj(nChunks));
|
||||
|
||||
Tcl_ListObjAppendElement(interp, pGroupTerm,
|
||||
Tcl_NewIntObj(gMultiplex.nChunkSize));
|
||||
Tcl_NewIntObj(pGroup->nChunkSize));
|
||||
Tcl_ListObjAppendElement(interp, pGroupTerm,
|
||||
Tcl_NewIntObj(gMultiplex.nMaxChunks));
|
||||
Tcl_NewIntObj(pGroup->nMaxChunks));
|
||||
|
||||
Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
|
||||
}
|
||||
@ -961,6 +1091,68 @@ static int test_multiplex_dump(
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE?
|
||||
*/
|
||||
static int 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;
|
||||
void *pArg = 0;
|
||||
|
||||
struct SubCommand {
|
||||
const char *zName;
|
||||
int op;
|
||||
int argtype;
|
||||
} aSub[] = {
|
||||
{ "enable", MULTIPLEX_CTRL_ENABLE, 1 },
|
||||
{ "chunk_size", MULTIPLEX_CTRL_SET_CHUNK_SIZE, 1 },
|
||||
{ "max_chunks", MULTIPLEX_CTRL_SET_MAX_CHUNKS, 1 },
|
||||
{ 0, 0, 0 }
|
||||
};
|
||||
|
||||
if( objc!=5 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
|
||||
Tcl_AppendResult(interp, "expected database handle, got \"", 0);
|
||||
Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", 0);
|
||||
return TCL_ERROR;
|
||||
}else{
|
||||
db = *(sqlite3 **)cmdInfo.objClientData;
|
||||
}
|
||||
|
||||
rc = Tcl_GetIndexFromObjStruct(
|
||||
interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx
|
||||
);
|
||||
if( rc!=TCL_OK ) return rc;
|
||||
|
||||
switch( aSub[idx].argtype ){
|
||||
case 1:
|
||||
if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){
|
||||
return TCL_ERROR;
|
||||
}
|
||||
pArg = (void *)&iValue;
|
||||
break;
|
||||
default:
|
||||
Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
|
||||
rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg);
|
||||
Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
||||
return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
** This routine registers the custom TCL commands defined in this
|
||||
** module. This should be the only procedure visible from outside
|
||||
@ -973,8 +1165,8 @@ int Sqlitemultiplex_Init(Tcl_Interp *interp){
|
||||
} aCmd[] = {
|
||||
{ "sqlite3_multiplex_initialize", test_multiplex_initialize },
|
||||
{ "sqlite3_multiplex_shutdown", test_multiplex_shutdown },
|
||||
{ "sqlite3_multiplex_set", test_multiplex_set },
|
||||
{ "sqlite3_multiplex_dump", test_multiplex_dump },
|
||||
{ "sqlite3_multiplex_control", test_multiplex_control },
|
||||
};
|
||||
int i;
|
||||
|
||||
|
||||
91
src/test_multiplex.h
Normal file
91
src/test_multiplex.h
Normal file
@ -0,0 +1,91 @@
|
||||
/*
|
||||
** 2011 March 18
|
||||
**
|
||||
** 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 a VFS "shim" - a layer that sits in between the
|
||||
** pager and the real VFS.
|
||||
**
|
||||
** This particular shim enforces a multiplex system on DB files.
|
||||
** This shim shards/partitions a single DB file into smaller
|
||||
** "chunks" such that the total DB file size may exceed the maximum
|
||||
** file size of the underlying file system.
|
||||
**
|
||||
*/
|
||||
|
||||
#ifndef _TEST_MULTIPLEX_H
|
||||
#define _TEST_MULTIPLEX_H
|
||||
|
||||
/*
|
||||
** CAPI: File-control Operations Supported by Multiplex VFS
|
||||
**
|
||||
** Values interpreted by the xFileControl method of a Multiplex VFS db file-handle.
|
||||
**
|
||||
** MULTIPLEX_CTRL_ENABLE:
|
||||
** This file control is used to enable or disable the multiplex
|
||||
** shim.
|
||||
**
|
||||
** MULTIPLEX_CTRL_SET_CHUNK_SIZE:
|
||||
** This file control is used to set the maximum allowed chunk
|
||||
** size for a multiplex file set. The chunk size should be
|
||||
** a multiple of SQLITE_MAX_PAGE_SIZE, and will be rounded up
|
||||
** if not.
|
||||
**
|
||||
** MULTIPLEX_CTRL_SET_MAX_CHUNKS:
|
||||
** This file control is used to set the maximum number of chunks
|
||||
** allowed to be used for a mutliplex file set.
|
||||
*/
|
||||
#define MULTIPLEX_CTRL_ENABLE 214014
|
||||
#define MULTIPLEX_CTRL_SET_CHUNK_SIZE 214015
|
||||
#define MULTIPLEX_CTRL_SET_MAX_CHUNKS 214016
|
||||
|
||||
/*
|
||||
** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
|
||||
**
|
||||
** Use the VFS named zOrigVfsName as the VFS that does the actual work.
|
||||
** Use the default if zOrigVfsName==NULL.
|
||||
**
|
||||
** The multiplex VFS shim is named "multiplex". It will become the default
|
||||
** VFS if makeDefault is non-zero.
|
||||
**
|
||||
** An auto-extension is registered which will make the function
|
||||
** multiplex_control() available to database connections. This
|
||||
** function gives access to the xFileControl interface of the
|
||||
** multiplex VFS shim.
|
||||
**
|
||||
** SELECT multiplex_control(<op>,<val>);
|
||||
**
|
||||
** <op>=1 MULTIPLEX_CTRL_ENABLE
|
||||
** <val>=0 disable
|
||||
** <val>=1 enable
|
||||
**
|
||||
** <op>=2 MULTIPLEX_CTRL_SET_CHUNK_SIZE
|
||||
** <val> int, chunk size
|
||||
**
|
||||
** <op>=3 MULTIPLEX_CTRL_SET_MAX_CHUNKS
|
||||
** <val> int, max chunks
|
||||
**
|
||||
** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
|
||||
** during start-up.
|
||||
*/
|
||||
extern int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault);
|
||||
|
||||
/*
|
||||
** 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.
|
||||
*/
|
||||
extern int sqlite3_multiplex_shutdown(void);
|
||||
|
||||
#endif
|
||||
@ -14,7 +14,7 @@ set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
source $testdir/malloc_common.tcl
|
||||
|
||||
set g_chunk_size 2147483648
|
||||
set g_chunk_size [ expr ($::SQLITE_MAX_PAGE_SIZE*16384) ]
|
||||
set g_max_chunks 32
|
||||
|
||||
# This handles appending the chunk number
|
||||
@ -32,13 +32,17 @@ proc multiplex_name {name chunk} {
|
||||
}
|
||||
|
||||
# This saves off the parameters and calls the
|
||||
# underlying sqlite3_multiplex_set() API.
|
||||
proc multiplex_set {chunk_size max_chunks} {
|
||||
# underlying sqlite3_multiplex_control() API.
|
||||
proc multiplex_set {db name chunk_size max_chunks} {
|
||||
global g_chunk_size
|
||||
global g_max_chunks
|
||||
set g_chunk_size $chunk_size
|
||||
set g_chunk_size [ expr (($chunk_size+($::SQLITE_MAX_PAGE_SIZE-1)) & ~($::SQLITE_MAX_PAGE_SIZE-1)) ]
|
||||
set g_max_chunks $max_chunks
|
||||
sqlite3_multiplex_set $chunk_size $max_chunks
|
||||
set rc [catch {sqlite3_multiplex_control $db $name chunk_size $chunk_size} msg]
|
||||
if { $rc==0 } {
|
||||
set rc [catch {sqlite3_multiplex_control $db $name max_chunks $max_chunks} msg]
|
||||
}
|
||||
list $msg
|
||||
}
|
||||
|
||||
# This attempts to delete the base file and
|
||||
@ -70,14 +74,51 @@ do_test multiplex-1.6 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
do_test multiplex-1.7 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.8 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test multiplex-1.9 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.10.1 { multiplex_set 32768 16 } {SQLITE_OK}
|
||||
do_test multiplex-1.10.2 { multiplex_set 32768 -1 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.10.3 { multiplex_set -1 16 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.10.4 { multiplex_set 31 16 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.10.5 { multiplex_set 32768 100 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.11 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test multiplex-1.9.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.9.2 { sqlite3 db test.db } {}
|
||||
do_test multiplex-1.9.3 { multiplex_set db main 32768 16 } {SQLITE_OK}
|
||||
do_test multiplex-1.9.4 { multiplex_set db main 32768 -1 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.9.5 { multiplex_set db main -1 16 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.9.6 { multiplex_set db main 31 16 } {SQLITE_OK}
|
||||
do_test multiplex-1.9.7 { multiplex_set db main 32768 100 } {SQLITE_MISUSE}
|
||||
do_test multiplex-1.9.8 { multiplex_set db main 1073741824 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.9.9 { db close } {}
|
||||
do_test multiplex-1.9.10 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test multiplex-1.10.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.10.2 { sqlite3 db test.db } {}
|
||||
do_test multiplex-1.10.3 { lindex [ catchsql { SELECT multiplex_control(2, 32768); } ] 0 } {0}
|
||||
do_test multiplex-1.10.4 { lindex [ catchsql { SELECT multiplex_control(3, -1); } ] 0 } {1}
|
||||
do_test multiplex-1.10.5 { lindex [ catchsql { SELECT multiplex_control(2, -1); } ] 0 } {1}
|
||||
do_test multiplex-1.10.6 { lindex [ catchsql { SELECT multiplex_control(2, 31); } ] 0 } {0}
|
||||
do_test multiplex-1.10.7 { lindex [ catchsql { SELECT multiplex_control(3, 100); } ] 0 } {1}
|
||||
do_test multiplex-1.10.8 { lindex [ catchsql { SELECT multiplex_control(2, 1073741824); } ] 0 } {0}
|
||||
do_test multiplex-1.10.9 { db close } {}
|
||||
do_test multiplex-1.10.10 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test multiplex-1.11.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.11.2 { sqlite3 db test.db } {}
|
||||
do_test multiplex-1.11.3 { sqlite3_multiplex_control db main enable 0 } {SQLITE_OK}
|
||||
do_test multiplex-1.11.4 { sqlite3_multiplex_control db main enable 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.11.5 { sqlite3_multiplex_control db main enable -1 } {SQLITE_OK}
|
||||
do_test multiplex-1.11.6 { db close } {}
|
||||
do_test multiplex-1.11.7 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test multiplex-1.12.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.12.2 { sqlite3 db test.db } {}
|
||||
do_test multiplex-1.12.3 { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 } {0}
|
||||
do_test multiplex-1.12.4 { lindex [ catchsql { SELECT multiplex_control(1, 1); } ] 0 } {0}
|
||||
do_test multiplex-1.12.5 { lindex [ catchsql { SELECT multiplex_control(1, -1); } ] 0 } {0}
|
||||
do_test multiplex-1.12.6 { db close } {}
|
||||
do_test multiplex-1.12.7 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
do_test multiplex-1.13.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-1.13.2 { sqlite3 db test.db } {}
|
||||
do_test multiplex-1.13.3 { lindex [ catchsql { SELECT multiplex_control(-1, 0); } ] 0 } {1}
|
||||
do_test multiplex-1.13.4 { lindex [ catchsql { SELECT multiplex_control(4, 1); } ] 0 } {1}
|
||||
do_test multiplex-1.13.6 { db close } {}
|
||||
do_test multiplex-1.13.7 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Some simple warm-body tests with a single database file in rollback
|
||||
@ -98,9 +139,12 @@ do_test multiplex-1.11 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
#
|
||||
# multiplex-2.6.*: More reading/writing with varying small chunk sizes, as
|
||||
# well as varying journal mode.
|
||||
#
|
||||
# multiplex-2.7.*: Disable/enable tests.
|
||||
#
|
||||
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 32768 16
|
||||
multiplex_set db main 32768 16
|
||||
|
||||
do_test multiplex-2.1.2 {
|
||||
sqlite3 db test.db
|
||||
@ -130,6 +174,7 @@ do_test multiplex-2.3.1 {
|
||||
db2 close
|
||||
} {}
|
||||
|
||||
|
||||
do_test multiplex-2.4.1 {
|
||||
sqlite3_multiplex_shutdown
|
||||
} {SQLITE_MISUSE}
|
||||
@ -146,11 +191,11 @@ do_test multiplex-2.4.99 {
|
||||
do_test multiplex-2.5.1 {
|
||||
multiplex_delete test.db
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 4096 16
|
||||
sqlite3 db test.db
|
||||
multiplex_set db main 4096 16
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test multiplex-2.5.2 {
|
||||
sqlite3 db test.db
|
||||
execsql {
|
||||
PRAGMA page_size = 1024;
|
||||
PRAGMA journal_mode = delete;
|
||||
@ -165,7 +210,9 @@ do_test multiplex-2.5.3 {
|
||||
INSERT INTO t1 VALUES(2, randomblob(4000));
|
||||
INSERT INTO t1 VALUES(3, 'three');
|
||||
INSERT INTO t1 VALUES(4, randomblob(4000));
|
||||
INSERT INTO t1 VALUES(5, 'five')
|
||||
INSERT INTO t1 VALUES(5, 'five');
|
||||
INSERT INTO t1 VALUES(6, randomblob($g_chunk_size));
|
||||
INSERT INTO t1 VALUES(7, randomblob($g_chunk_size));
|
||||
}
|
||||
} {}
|
||||
|
||||
@ -205,11 +252,11 @@ foreach jmode $all_journal_modes {
|
||||
do_test multiplex-2.6.1.$sz.$jmode {
|
||||
multiplex_delete test.db
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set $sz 32
|
||||
sqlite3 db test.db
|
||||
multiplex_set db main $sz 32
|
||||
} {SQLITE_OK}
|
||||
|
||||
do_test multiplex-2.6.2.$sz.$jmode {
|
||||
sqlite3 db test.db
|
||||
db eval {
|
||||
PRAGMA page_size = 1024;
|
||||
PRAGMA auto_vacuum = off;
|
||||
@ -243,6 +290,31 @@ foreach jmode $all_journal_modes {
|
||||
}
|
||||
}
|
||||
|
||||
do_test multiplex-2.7.1 { multiplex_delete test.db } {}
|
||||
do_test multiplex-2.7.2 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK}
|
||||
do_test multiplex-2.7.3 { sqlite3 db test.db } {}
|
||||
do_test multiplex-2.7.4 { lindex [ catchsql { SELECT multiplex_control(2, 65536); } ] 0 } {0}
|
||||
do_test multiplex-2.7.5 { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 } {0}
|
||||
do_test multiplex-2.7.6 {
|
||||
execsql {
|
||||
CREATE TABLE t1(a PRIMARY KEY, b);
|
||||
INSERT INTO t1 VALUES(1, randomblob(1000));
|
||||
}
|
||||
} {}
|
||||
# verify only one file, and file size is less than chunks size
|
||||
do_test multiplex-2.7.7 { expr ([file size [multiplex_name test.db 0]] < 65536) } {1}
|
||||
do_test multiplex-2.7.8 { file exists [multiplex_name test.db 1] } {0}
|
||||
do_test multiplex-2.7.9 {
|
||||
execsql {
|
||||
INSERT INTO t1 VALUES(2, randomblob(65536));
|
||||
}
|
||||
} {}
|
||||
# verify only one file, and file size exceeds chunks size
|
||||
do_test multiplex-2.7.10 { expr ([file size [multiplex_name test.db 0]] > 65536) } {1}
|
||||
do_test multiplex-2.7.11 { file exists [multiplex_name test.db 1] } {0}
|
||||
do_test multiplex-2.7.12 { db close } {}
|
||||
do_test multiplex-2.7.13 { sqlite3_multiplex_shutdown } {SQLITE_OK}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Try some tests with more than one connection to a database file. Still
|
||||
# in rollback mode.
|
||||
@ -255,10 +327,10 @@ foreach jmode $all_journal_modes {
|
||||
do_test multiplex-3.1.1 {
|
||||
multiplex_delete test.db
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 32768 16
|
||||
sqlite3 db test.db
|
||||
multiplex_set db main 32768 16
|
||||
} {SQLITE_OK}
|
||||
do_test multiplex-3.1.2 {
|
||||
sqlite3 db test.db
|
||||
execsql {
|
||||
PRAGMA page_size = 1024;
|
||||
PRAGMA journal_mode = delete;
|
||||
@ -341,7 +413,7 @@ do_test multiplex-3.2.X {
|
||||
#
|
||||
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 32768 16
|
||||
multiplex_set db main 32768 16
|
||||
|
||||
# Return a list of all currently defined multiplexs.
|
||||
proc multiplex_list {} {
|
||||
@ -403,7 +475,7 @@ do_test multiplex-4.1.12 {
|
||||
#
|
||||
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 32768 16
|
||||
multiplex_set db main 32768 16
|
||||
|
||||
do_faultsim_test multiplex-5.1 -prep {
|
||||
catch {db close}
|
||||
@ -448,7 +520,7 @@ do_faultsim_test multiplex-5.5 -prep {
|
||||
catch { sqlite3_multiplex_shutdown }
|
||||
} -body {
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 32768 16
|
||||
multiplex_set db main 32768 16
|
||||
}
|
||||
|
||||
# test that mismatch filesize is detected
|
||||
@ -473,20 +545,20 @@ if {0==[info exists ::G(perm:presql)] || $::G(perm:presql) == ""} {
|
||||
do_test multiplex-5.6.2.$jmode {
|
||||
execsql {
|
||||
CREATE TABLE t1(a, b);
|
||||
INSERT INTO t1 VALUES(1, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(2, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(3, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(4, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(5, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(1, randomblob(15000));
|
||||
INSERT INTO t1 VALUES(2, randomblob(15000));
|
||||
INSERT INTO t1 VALUES(3, randomblob(15000));
|
||||
INSERT INTO t1 VALUES(4, randomblob(15000));
|
||||
INSERT INTO t1 VALUES(5, randomblob(15000));
|
||||
}
|
||||
db close
|
||||
sqlite3_multiplex_initialize "" 1
|
||||
multiplex_set 4096 16
|
||||
sqlite3 db test.db
|
||||
} {}
|
||||
multiplex_set db main 4096 16
|
||||
} {SQLITE_OK}
|
||||
do_test multiplex-5.6.3.$jmode {
|
||||
catchsql {
|
||||
INSERT INTO t1 VALUES(6, randomblob(1100));
|
||||
INSERT INTO t1 VALUES(6, randomblob(15000));
|
||||
}
|
||||
} {1 {disk I/O error}}
|
||||
do_test multiplex-5.6.4.$jmode {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user