| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2010 October 28 | |
| 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 ** | |
| 13 ** This file contains a VFS "shim" - a layer that sits in between the | |
| 14 ** pager and the real VFS - that breaks up a very large database file | |
| 15 ** into two or more smaller files on disk. This is useful, for example, | |
| 16 ** in order to support large, multi-gigabyte databases on older filesystems | |
| 17 ** that limit the maximum file size to 2 GiB. | |
| 18 ** | |
| 19 ** USAGE: | |
| 20 ** | |
| 21 ** Compile this source file and link it with your application. Then | |
| 22 ** at start-time, invoke the following procedure: | |
| 23 ** | |
| 24 ** int sqlite3_multiplex_initialize( | |
| 25 ** const char *zOrigVfsName, // The underlying real VFS | |
| 26 ** int makeDefault // True to make multiplex the default VFS | |
| 27 ** ); | |
| 28 ** | |
| 29 ** The procedure call above will create and register a new VFS shim named | |
| 30 ** "multiplex". The multiplex VFS will use the VFS named by zOrigVfsName to | |
| 31 ** do the actual disk I/O. (The zOrigVfsName parameter may be NULL, in | |
| 32 ** which case the default VFS at the moment sqlite3_multiplex_initialize() | |
| 33 ** is called will be used as the underlying real VFS.) | |
| 34 ** | |
| 35 ** If the makeDefault parameter is TRUE then multiplex becomes the new | |
| 36 ** default VFS. Otherwise, you can use the multiplex VFS by specifying | |
| 37 ** "multiplex" as the 4th parameter to sqlite3_open_v2() or by employing | |
| 38 ** URI filenames and adding "vfs=multiplex" as a parameter to the filename | |
| 39 ** URI. | |
| 40 ** | |
| 41 ** The multiplex VFS allows databases up to 32 GiB in size. But it splits | |
| 42 ** the files up into smaller pieces, so that they will work even on | |
| 43 ** filesystems that do not support large files. The default chunk size | |
| 44 ** is 2147418112 bytes (which is 64KiB less than 2GiB) but this can be | |
| 45 ** changed at compile-time by defining the SQLITE_MULTIPLEX_CHUNK_SIZE | |
| 46 ** macro. Use the "chunksize=NNNN" query parameter with a URI filename | |
| 47 ** in order to select an alternative chunk size for individual connections | |
| 48 ** at run-time. | |
| 49 */ | |
| 50 #include "sqlite3.h" | |
| 51 #include <string.h> | |
| 52 #include <assert.h> | |
| 53 #include <stdlib.h> | |
| 54 #include "test_multiplex.h" | |
| 55 | |
| 56 #ifndef SQLITE_CORE | |
| 57 #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */ | |
| 58 #endif | |
| 59 #include "sqlite3ext.h" | |
| 60 | |
| 61 /* | |
| 62 ** These should be defined to be the same as the values in | |
| 63 ** sqliteInt.h. They are defined separately here so that | |
| 64 ** the multiplex VFS shim can be built as a loadable | |
| 65 ** module. | |
| 66 */ | |
| 67 #define UNUSED_PARAMETER(x) (void)(x) | |
| 68 #define MAX_PAGE_SIZE 0x10000 | |
| 69 #define DEFAULT_SECTOR_SIZE 0x1000 | |
| 70 | |
| 71 /* | |
| 72 ** For a build without mutexes, no-op the mutex calls. | |
| 73 */ | |
| 74 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0 | |
| 75 #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) | |
| 76 #define sqlite3_mutex_free(X) | |
| 77 #define sqlite3_mutex_enter(X) | |
| 78 #define sqlite3_mutex_try(X) SQLITE_OK | |
| 79 #define sqlite3_mutex_leave(X) | |
| 80 #define sqlite3_mutex_held(X) ((void)(X),1) | |
| 81 #define sqlite3_mutex_notheld(X) ((void)(X),1) | |
| 82 #endif /* SQLITE_THREADSAFE==0 */ | |
| 83 | |
| 84 /* Maximum chunk number */ | |
| 85 #define MX_CHUNK_NUMBER 299 | |
| 86 | |
| 87 /* First chunk for rollback journal files */ | |
| 88 #define SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET 400 | |
| 89 #define SQLITE_MULTIPLEX_WAL_8_3_OFFSET 700 | |
| 90 | |
| 91 | |
| 92 /************************ Shim Definitions ******************************/ | |
| 93 | |
| 94 #ifndef SQLITE_MULTIPLEX_VFS_NAME | |
| 95 # define SQLITE_MULTIPLEX_VFS_NAME "multiplex" | |
| 96 #endif | |
| 97 | |
| 98 /* This is the limit on the chunk size. It may be changed by calling | |
| 99 ** the xFileControl() interface. It will be rounded up to a | |
| 100 ** multiple of MAX_PAGE_SIZE. We default it here to 2GiB less 64KiB. | |
| 101 */ | |
| 102 #ifndef SQLITE_MULTIPLEX_CHUNK_SIZE | |
| 103 # define SQLITE_MULTIPLEX_CHUNK_SIZE 2147418112 | |
| 104 #endif | |
| 105 | |
| 106 /* This used to be the default limit on number of chunks, but | |
| 107 ** it is no longer enforced. There is currently no limit to the | |
| 108 ** number of chunks. | |
| 109 ** | |
| 110 ** May be changed by calling the xFileControl() interface. | |
| 111 */ | |
| 112 #ifndef SQLITE_MULTIPLEX_MAX_CHUNKS | |
| 113 # define SQLITE_MULTIPLEX_MAX_CHUNKS 12 | |
| 114 #endif | |
| 115 | |
| 116 /************************ Object Definitions ******************************/ | |
| 117 | |
| 118 /* Forward declaration of all object types */ | |
| 119 typedef struct multiplexGroup multiplexGroup; | |
| 120 typedef struct multiplexConn multiplexConn; | |
| 121 | |
| 122 /* | |
| 123 ** A "multiplex group" is a collection of files that collectively | |
| 124 ** makeup a single SQLite DB file. This allows the size of the DB | |
| 125 ** to exceed the limits imposed by the file system. | |
| 126 ** | |
| 127 ** There is an instance of the following object for each defined multiplex | |
| 128 ** group. | |
| 129 */ | |
| 130 struct multiplexGroup { | |
| 131 struct multiplexReal { /* For each chunk */ | |
| 132 sqlite3_file *p; /* Handle for the chunk */ | |
| 133 char *z; /* Name of this chunk */ | |
| 134 } *aReal; /* list of all chunks */ | |
| 135 int nReal; /* Number of chunks */ | |
| 136 char *zName; /* Base filename of this group */ | |
| 137 int nName; /* Length of base filename */ | |
| 138 int flags; /* Flags used for original opening */ | |
| 139 unsigned int szChunk; /* Chunk size used for this group */ | |
| 140 unsigned char bEnabled; /* TRUE to use Multiplex VFS for this file */ | |
| 141 unsigned char bTruncate; /* TRUE to enable truncation of databases */ | |
| 142 multiplexGroup *pNext, *pPrev; /* Doubly linked list of all group objects */ | |
| 143 }; | |
| 144 | |
| 145 /* | |
| 146 ** An instance of the following object represents each open connection | |
| 147 ** to a file that is multiplex'ed. This object is a | |
| 148 ** subclass of sqlite3_file. The sqlite3_file object for the underlying | |
| 149 ** VFS is appended to this structure. | |
| 150 */ | |
| 151 struct multiplexConn { | |
| 152 sqlite3_file base; /* Base class - must be first */ | |
| 153 multiplexGroup *pGroup; /* The underlying group of files */ | |
| 154 }; | |
| 155 | |
| 156 /************************* Global Variables **********************************/ | |
| 157 /* | |
| 158 ** All global variables used by this file are containing within the following | |
| 159 ** gMultiplex structure. | |
| 160 */ | |
| 161 static struct { | |
| 162 /* The pOrigVfs is the real, original underlying VFS implementation. | |
| 163 ** Most operations pass-through to the real VFS. This value is read-only | |
| 164 ** during operation. It is only modified at start-time and thus does not | |
| 165 ** require a mutex. | |
| 166 */ | |
| 167 sqlite3_vfs *pOrigVfs; | |
| 168 | |
| 169 /* The sThisVfs is the VFS structure used by this shim. It is initialized | |
| 170 ** at start-time and thus does not require a mutex | |
| 171 */ | |
| 172 sqlite3_vfs sThisVfs; | |
| 173 | |
| 174 /* The sIoMethods defines the methods used by sqlite3_file objects | |
| 175 ** associated with this shim. It is initialized at start-time and does | |
| 176 ** not require a mutex. | |
| 177 ** | |
| 178 ** When the underlying VFS is called to open a file, it might return | |
| 179 ** either a version 1 or a version 2 sqlite3_file object. This shim | |
| 180 ** has to create a wrapper sqlite3_file of the same version. Hence | |
| 181 ** there are two I/O method structures, one for version 1 and the other | |
| 182 ** for version 2. | |
| 183 */ | |
| 184 sqlite3_io_methods sIoMethodsV1; | |
| 185 sqlite3_io_methods sIoMethodsV2; | |
| 186 | |
| 187 /* True when this shim has been initialized. | |
| 188 */ | |
| 189 int isInitialized; | |
| 190 | |
| 191 /* For run-time access any of the other global data structures in this | |
| 192 ** shim, the following mutex must be held. | |
| 193 */ | |
| 194 sqlite3_mutex *pMutex; | |
| 195 | |
| 196 /* List of multiplexGroup objects. | |
| 197 */ | |
| 198 multiplexGroup *pGroups; | |
| 199 } gMultiplex; | |
| 200 | |
| 201 /************************* Utility Routines *********************************/ | |
| 202 /* | |
| 203 ** Acquire and release the mutex used to serialize access to the | |
| 204 ** list of multiplexGroups. | |
| 205 */ | |
| 206 static void multiplexEnter(void){ sqlite3_mutex_enter(gMultiplex.pMutex); } | |
| 207 static void multiplexLeave(void){ sqlite3_mutex_leave(gMultiplex.pMutex); } | |
| 208 | |
| 209 /* | |
| 210 ** Compute a string length that is limited to what can be stored in | |
| 211 ** lower 30 bits of a 32-bit signed integer. | |
| 212 ** | |
| 213 ** The value returned will never be negative. Nor will it ever be greater | |
| 214 ** than the actual length of the string. For very long strings (greater | |
| 215 ** than 1GiB) the value returned might be less than the true string length. | |
| 216 */ | |
| 217 static int multiplexStrlen30(const char *z){ | |
| 218 const char *z2 = z; | |
| 219 if( z==0 ) return 0; | |
| 220 while( *z2 ){ z2++; } | |
| 221 return 0x3fffffff & (int)(z2 - z); | |
| 222 } | |
| 223 | |
| 224 /* | |
| 225 ** Generate the file-name for chunk iChunk of the group with base name | |
| 226 ** zBase. The file-name is written to buffer zOut before returning. Buffer | |
| 227 ** zOut must be allocated by the caller so that it is at least (nBase+5) | |
| 228 ** bytes in size, where nBase is the length of zBase, not including the | |
| 229 ** nul-terminator. | |
| 230 ** | |
| 231 ** If iChunk is 0 (or 400 - the number for the first journal file chunk), | |
| 232 ** the output is a copy of the input string. Otherwise, if | |
| 233 ** SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain | |
| 234 ** a "." character, then the output is a copy of the input string with the | |
| 235 ** three-digit zero-padded decimal representation if iChunk appended to it. | |
| 236 ** For example: | |
| 237 ** | |
| 238 ** zBase="test.db", iChunk=4 -> zOut="test.db004" | |
| 239 ** | |
| 240 ** Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains | |
| 241 ** a "." character, then everything after the "." is replaced by the | |
| 242 ** three-digit representation of iChunk. | |
| 243 ** | |
| 244 ** zBase="test.db", iChunk=4 -> zOut="test.004" | |
| 245 ** | |
| 246 ** The output buffer string is terminated by 2 0x00 bytes. This makes it safe | |
| 247 ** to pass to sqlite3_uri_parameter() and similar. | |
| 248 */ | |
| 249 static void multiplexFilename( | |
| 250 const char *zBase, /* Filename for chunk 0 */ | |
| 251 int nBase, /* Size of zBase in bytes (without \0) */ | |
| 252 int flags, /* Flags used to open file */ | |
| 253 int iChunk, /* Chunk to generate filename for */ | |
| 254 char *zOut /* Buffer to write generated name to */ | |
| 255 ){ | |
| 256 int n = nBase; | |
| 257 memcpy(zOut, zBase, n+1); | |
| 258 if( iChunk!=0 && iChunk<=MX_CHUNK_NUMBER ){ | |
| 259 #ifdef SQLITE_ENABLE_8_3_NAMES | |
| 260 int i; | |
| 261 for(i=n-1; i>0 && i>=n-4 && zOut[i]!='.'; i--){} | |
| 262 if( i>=n-4 ) n = i+1; | |
| 263 if( flags & SQLITE_OPEN_MAIN_JOURNAL ){ | |
| 264 /* The extensions on overflow files for main databases are 001, 002, | |
| 265 ** 003 and so forth. To avoid name collisions, add 400 to the | |
| 266 ** extensions of journal files so that they are 401, 402, 403, .... | |
| 267 */ | |
| 268 iChunk += SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET; | |
| 269 }else if( flags & SQLITE_OPEN_WAL ){ | |
| 270 /* To avoid name collisions, add 700 to the | |
| 271 ** extensions of WAL files so that they are 701, 702, 703, .... | |
| 272 */ | |
| 273 iChunk += SQLITE_MULTIPLEX_WAL_8_3_OFFSET; | |
| 274 } | |
| 275 #endif | |
| 276 sqlite3_snprintf(4,&zOut[n],"%03d",iChunk); | |
| 277 n += 3; | |
| 278 } | |
| 279 | |
| 280 assert( zOut[n]=='\0' ); | |
| 281 zOut[n+1] = '\0'; | |
| 282 } | |
| 283 | |
| 284 /* Compute the filename for the iChunk-th chunk | |
| 285 */ | |
| 286 static int multiplexSubFilename(multiplexGroup *pGroup, int iChunk){ | |
| 287 if( iChunk>=pGroup->nReal ){ | |
| 288 struct multiplexReal *p; | |
| 289 p = sqlite3_realloc(pGroup->aReal, (iChunk+1)*sizeof(*p)); | |
| 290 if( p==0 ){ | |
| 291 return SQLITE_NOMEM; | |
| 292 } | |
| 293 memset(&p[pGroup->nReal], 0, sizeof(p[0])*(iChunk+1-pGroup->nReal)); | |
| 294 pGroup->aReal = p; | |
| 295 pGroup->nReal = iChunk+1; | |
| 296 } | |
| 297 if( pGroup->zName && pGroup->aReal[iChunk].z==0 ){ | |
| 298 char *z; | |
| 299 int n = pGroup->nName; | |
| 300 pGroup->aReal[iChunk].z = z = sqlite3_malloc( n+5 ); | |
| 301 if( z==0 ){ | |
| 302 return SQLITE_NOMEM; | |
| 303 } | |
| 304 multiplexFilename(pGroup->zName, pGroup->nName, pGroup->flags, iChunk, z); | |
| 305 } | |
| 306 return SQLITE_OK; | |
| 307 } | |
| 308 | |
| 309 /* Translate an sqlite3_file* that is really a multiplexGroup* into | |
| 310 ** the sqlite3_file* for the underlying original VFS. | |
| 311 ** | |
| 312 ** For chunk 0, the pGroup->flags determines whether or not a new file | |
| 313 ** is created if it does not already exist. For chunks 1 and higher, the | |
| 314 ** file is created only if createFlag is 1. | |
| 315 */ | |
| 316 static sqlite3_file *multiplexSubOpen( | |
| 317 multiplexGroup *pGroup, /* The multiplexor group */ | |
| 318 int iChunk, /* Which chunk to open. 0==original file */ | |
| 319 int *rc, /* Result code in and out */ | |
| 320 int *pOutFlags, /* Output flags */ | |
| 321 int createFlag /* True to create if iChunk>0 */ | |
| 322 ){ | |
| 323 sqlite3_file *pSubOpen = 0; | |
| 324 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */ | |
| 325 | |
| 326 #ifdef SQLITE_ENABLE_8_3_NAMES | |
| 327 /* If JOURNAL_8_3_OFFSET is set to (say) 400, then any overflow files are | |
| 328 ** part of a database journal are named db.401, db.402, and so on. A | |
| 329 ** database may therefore not grow to larger than 400 chunks. Attempting | |
| 330 ** to open chunk 401 indicates the database is full. */ | |
| 331 if( iChunk>=SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET ){ | |
| 332 sqlite3_log(SQLITE_FULL, "multiplexed chunk overflow: %s", pGroup->zName); | |
| 333 *rc = SQLITE_FULL; | |
| 334 return 0; | |
| 335 } | |
| 336 #endif | |
| 337 | |
| 338 *rc = multiplexSubFilename(pGroup, iChunk); | |
| 339 if( (*rc)==SQLITE_OK && (pSubOpen = pGroup->aReal[iChunk].p)==0 ){ | |
| 340 int flags, bExists; | |
| 341 flags = pGroup->flags; | |
| 342 if( createFlag ){ | |
| 343 flags |= SQLITE_OPEN_CREATE; | |
| 344 }else if( iChunk==0 ){ | |
| 345 /* Fall through */ | |
| 346 }else if( pGroup->aReal[iChunk].z==0 ){ | |
| 347 return 0; | |
| 348 }else{ | |
| 349 *rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[iChunk].z, | |
| 350 SQLITE_ACCESS_EXISTS, &bExists); | |
| 351 if( *rc || !bExists ){ | |
| 352 if( *rc ){ | |
| 353 sqlite3_log(*rc, "multiplexor.xAccess failure on %s", | |
| 354 pGroup->aReal[iChunk].z); | |
| 355 } | |
| 356 return 0; | |
| 357 } | |
| 358 flags &= ~SQLITE_OPEN_CREATE; | |
| 359 } | |
| 360 pSubOpen = sqlite3_malloc( pOrigVfs->szOsFile ); | |
| 361 if( pSubOpen==0 ){ | |
| 362 *rc = SQLITE_IOERR_NOMEM; | |
| 363 return 0; | |
| 364 } | |
| 365 pGroup->aReal[iChunk].p = pSubOpen; | |
| 366 *rc = pOrigVfs->xOpen(pOrigVfs, pGroup->aReal[iChunk].z, pSubOpen, | |
| 367 flags, pOutFlags); | |
| 368 if( (*rc)!=SQLITE_OK ){ | |
| 369 sqlite3_log(*rc, "multiplexor.xOpen failure on %s", | |
| 370 pGroup->aReal[iChunk].z); | |
| 371 sqlite3_free(pSubOpen); | |
| 372 pGroup->aReal[iChunk].p = 0; | |
| 373 return 0; | |
| 374 } | |
| 375 } | |
| 376 return pSubOpen; | |
| 377 } | |
| 378 | |
| 379 /* | |
| 380 ** Return the size, in bytes, of chunk number iChunk. If that chunk | |
| 381 ** does not exist, then return 0. This function does not distingish between | |
| 382 ** non-existant files and zero-length files. | |
| 383 */ | |
| 384 static sqlite3_int64 multiplexSubSize( | |
| 385 multiplexGroup *pGroup, /* The multiplexor group */ | |
| 386 int iChunk, /* Which chunk to open. 0==original file */ | |
| 387 int *rc /* Result code in and out */ | |
| 388 ){ | |
| 389 sqlite3_file *pSub; | |
| 390 sqlite3_int64 sz = 0; | |
| 391 | |
| 392 if( *rc ) return 0; | |
| 393 pSub = multiplexSubOpen(pGroup, iChunk, rc, NULL, 0); | |
| 394 if( pSub==0 ) return 0; | |
| 395 *rc = pSub->pMethods->xFileSize(pSub, &sz); | |
| 396 return sz; | |
| 397 } | |
| 398 | |
| 399 /* | |
| 400 ** This is the implementation of the multiplex_control() SQL function. | |
| 401 */ | |
| 402 static void multiplexControlFunc( | |
| 403 sqlite3_context *context, | |
| 404 int argc, | |
| 405 sqlite3_value **argv | |
| 406 ){ | |
| 407 int rc = SQLITE_OK; | |
| 408 sqlite3 *db = sqlite3_context_db_handle(context); | |
| 409 int op; | |
| 410 int iVal; | |
| 411 | |
| 412 if( !db || argc!=2 ){ | |
| 413 rc = SQLITE_ERROR; | |
| 414 }else{ | |
| 415 /* extract params */ | |
| 416 op = sqlite3_value_int(argv[0]); | |
| 417 iVal = sqlite3_value_int(argv[1]); | |
| 418 /* map function op to file_control op */ | |
| 419 switch( op ){ | |
| 420 case 1: | |
| 421 op = MULTIPLEX_CTRL_ENABLE; | |
| 422 break; | |
| 423 case 2: | |
| 424 op = MULTIPLEX_CTRL_SET_CHUNK_SIZE; | |
| 425 break; | |
| 426 case 3: | |
| 427 op = MULTIPLEX_CTRL_SET_MAX_CHUNKS; | |
| 428 break; | |
| 429 default: | |
| 430 rc = SQLITE_NOTFOUND; | |
| 431 break; | |
| 432 } | |
| 433 } | |
| 434 if( rc==SQLITE_OK ){ | |
| 435 rc = sqlite3_file_control(db, 0, op, &iVal); | |
| 436 } | |
| 437 sqlite3_result_error_code(context, rc); | |
| 438 } | |
| 439 | |
| 440 /* | |
| 441 ** This is the entry point to register the auto-extension for the | |
| 442 ** multiplex_control() function. | |
| 443 */ | |
| 444 static int multiplexFuncInit( | |
| 445 sqlite3 *db, | |
| 446 char **pzErrMsg, | |
| 447 const sqlite3_api_routines *pApi | |
| 448 ){ | |
| 449 int rc; | |
| 450 rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY, | |
| 451 0, multiplexControlFunc, 0, 0); | |
| 452 return rc; | |
| 453 } | |
| 454 | |
| 455 /* | |
| 456 ** Close a single sub-file in the connection group. | |
| 457 */ | |
| 458 static void multiplexSubClose( | |
| 459 multiplexGroup *pGroup, | |
| 460 int iChunk, | |
| 461 sqlite3_vfs *pOrigVfs | |
| 462 ){ | |
| 463 sqlite3_file *pSubOpen = pGroup->aReal[iChunk].p; | |
| 464 if( pSubOpen ){ | |
| 465 pSubOpen->pMethods->xClose(pSubOpen); | |
| 466 if( pOrigVfs && pGroup->aReal[iChunk].z ){ | |
| 467 pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0); | |
| 468 } | |
| 469 sqlite3_free(pGroup->aReal[iChunk].p); | |
| 470 } | |
| 471 sqlite3_free(pGroup->aReal[iChunk].z); | |
| 472 memset(&pGroup->aReal[iChunk], 0, sizeof(pGroup->aReal[iChunk])); | |
| 473 } | |
| 474 | |
| 475 /* | |
| 476 ** Deallocate memory held by a multiplexGroup | |
| 477 */ | |
| 478 static void multiplexFreeComponents(multiplexGroup *pGroup){ | |
| 479 int i; | |
| 480 for(i=0; i<pGroup->nReal; i++){ multiplexSubClose(pGroup, i, 0); } | |
| 481 sqlite3_free(pGroup->aReal); | |
| 482 pGroup->aReal = 0; | |
| 483 pGroup->nReal = 0; | |
| 484 } | |
| 485 | |
| 486 | |
| 487 /************************* VFS Method Wrappers *****************************/ | |
| 488 | |
| 489 /* | |
| 490 ** This is the xOpen method used for the "multiplex" VFS. | |
| 491 ** | |
| 492 ** Most of the work is done by the underlying original VFS. This method | |
| 493 ** simply links the new file into the appropriate multiplex group if it is a | |
| 494 ** file that needs to be tracked. | |
| 495 */ | |
| 496 static int multiplexOpen( | |
| 497 sqlite3_vfs *pVfs, /* The multiplex VFS */ | |
| 498 const char *zName, /* Name of file to be opened */ | |
| 499 sqlite3_file *pConn, /* Fill in this file descriptor */ | |
| 500 int flags, /* Flags to control the opening */ | |
| 501 int *pOutFlags /* Flags showing results of opening */ | |
| 502 ){ | |
| 503 int rc = SQLITE_OK; /* Result code */ | |
| 504 multiplexConn *pMultiplexOpen; /* The new multiplex file descriptor */ | |
| 505 multiplexGroup *pGroup = 0; /* Corresponding multiplexGroup object */ | |
| 506 sqlite3_file *pSubOpen = 0; /* Real file descriptor */ | |
| 507 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */ | |
| 508 int nName = 0; | |
| 509 int sz = 0; | |
| 510 char *zToFree = 0; | |
| 511 | |
| 512 UNUSED_PARAMETER(pVfs); | |
| 513 memset(pConn, 0, pVfs->szOsFile); | |
| 514 assert( zName || (flags & SQLITE_OPEN_DELETEONCLOSE) ); | |
| 515 | |
| 516 /* We need to create a group structure and manage | |
| 517 ** access to this group of files. | |
| 518 */ | |
| 519 multiplexEnter(); | |
| 520 pMultiplexOpen = (multiplexConn*)pConn; | |
| 521 | |
| 522 if( rc==SQLITE_OK ){ | |
| 523 /* allocate space for group */ | |
| 524 nName = zName ? multiplexStrlen30(zName) : 0; | |
| 525 sz = sizeof(multiplexGroup) /* multiplexGroup */ | |
| 526 + nName + 1; /* zName */ | |
| 527 pGroup = sqlite3_malloc( sz ); | |
| 528 if( pGroup==0 ){ | |
| 529 rc = SQLITE_NOMEM; | |
| 530 } | |
| 531 } | |
| 532 | |
| 533 if( rc==SQLITE_OK ){ | |
| 534 const char *zUri = (flags & SQLITE_OPEN_URI) ? zName : 0; | |
| 535 /* assign pointers to extra space allocated */ | |
| 536 memset(pGroup, 0, sz); | |
| 537 pMultiplexOpen->pGroup = pGroup; | |
| 538 pGroup->bEnabled = -1; | |
| 539 pGroup->bTruncate = sqlite3_uri_boolean(zUri, "truncate", | |
| 540 (flags & SQLITE_OPEN_MAIN_DB)==0); | |
| 541 pGroup->szChunk = (int)sqlite3_uri_int64(zUri, "chunksize", | |
| 542 SQLITE_MULTIPLEX_CHUNK_SIZE); | |
| 543 pGroup->szChunk = (pGroup->szChunk+0xffff)&~0xffff; | |
| 544 if( zName ){ | |
| 545 char *p = (char *)&pGroup[1]; | |
| 546 pGroup->zName = p; | |
| 547 memcpy(pGroup->zName, zName, nName+1); | |
| 548 pGroup->nName = nName; | |
| 549 } | |
| 550 if( pGroup->bEnabled ){ | |
| 551 /* Make sure that the chunksize is such that the pending byte does not | |
| 552 ** falls at the end of a chunk. A region of up to 64K following | |
| 553 ** the pending byte is never written, so if the pending byte occurs | |
| 554 ** near the end of a chunk, that chunk will be too small. */ | |
| 555 #ifndef SQLITE_OMIT_WSD | |
| 556 extern int sqlite3PendingByte; | |
| 557 #else | |
| 558 int sqlite3PendingByte = 0x40000000; | |
| 559 #endif | |
| 560 while( (sqlite3PendingByte % pGroup->szChunk)>=(pGroup->szChunk-65536) ){ | |
| 561 pGroup->szChunk += 65536; | |
| 562 } | |
| 563 } | |
| 564 pGroup->flags = flags; | |
| 565 rc = multiplexSubFilename(pGroup, 1); | |
| 566 if( rc==SQLITE_OK ){ | |
| 567 pSubOpen = multiplexSubOpen(pGroup, 0, &rc, pOutFlags, 0); | |
| 568 if( pSubOpen==0 && rc==SQLITE_OK ) rc = SQLITE_CANTOPEN; | |
| 569 } | |
| 570 if( rc==SQLITE_OK ){ | |
| 571 sqlite3_int64 sz; | |
| 572 | |
| 573 rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz); | |
| 574 if( rc==SQLITE_OK && zName ){ | |
| 575 int bExists; | |
| 576 if( sz==0 ){ | |
| 577 if( flags & SQLITE_OPEN_MAIN_JOURNAL ){ | |
| 578 /* If opening a main journal file and the first chunk is zero | |
| 579 ** bytes in size, delete any subsequent chunks from the | |
| 580 ** file-system. */ | |
| 581 int iChunk = 1; | |
| 582 do { | |
| 583 rc = pOrigVfs->xAccess(pOrigVfs, | |
| 584 pGroup->aReal[iChunk].z, SQLITE_ACCESS_EXISTS, &bExists | |
| 585 ); | |
| 586 if( rc==SQLITE_OK && bExists ){ | |
| 587 rc = pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0); | |
| 588 if( rc==SQLITE_OK ){ | |
| 589 rc = multiplexSubFilename(pGroup, ++iChunk); | |
| 590 } | |
| 591 } | |
| 592 }while( rc==SQLITE_OK && bExists ); | |
| 593 } | |
| 594 }else{ | |
| 595 /* If the first overflow file exists and if the size of the main file | |
| 596 ** is different from the chunk size, that means the chunk size is set | |
| 597 ** set incorrectly. So fix it. | |
| 598 ** | |
| 599 ** Or, if the first overflow file does not exist and the main file is | |
| 600 ** larger than the chunk size, that means the chunk size is too small. | |
| 601 ** But we have no way of determining the intended chunk size, so | |
| 602 ** just disable the multiplexor all togethre. | |
| 603 */ | |
| 604 rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[1].z, | |
| 605 SQLITE_ACCESS_EXISTS, &bExists); | |
| 606 bExists = multiplexSubSize(pGroup, 1, &rc)>0; | |
| 607 if( rc==SQLITE_OK && bExists && sz==(sz&0xffff0000) && sz>0 | |
| 608 && sz!=pGroup->szChunk ){ | |
| 609 pGroup->szChunk = (int)sz; | |
| 610 }else if( rc==SQLITE_OK && !bExists && sz>pGroup->szChunk ){ | |
| 611 pGroup->bEnabled = 0; | |
| 612 } | |
| 613 } | |
| 614 } | |
| 615 } | |
| 616 | |
| 617 if( rc==SQLITE_OK ){ | |
| 618 if( pSubOpen->pMethods->iVersion==1 ){ | |
| 619 pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV1; | |
| 620 }else{ | |
| 621 pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV2; | |
| 622 } | |
| 623 /* place this group at the head of our list */ | |
| 624 pGroup->pNext = gMultiplex.pGroups; | |
| 625 if( gMultiplex.pGroups ) gMultiplex.pGroups->pPrev = pGroup; | |
| 626 gMultiplex.pGroups = pGroup; | |
| 627 }else{ | |
| 628 multiplexFreeComponents(pGroup); | |
| 629 sqlite3_free(pGroup); | |
| 630 } | |
| 631 } | |
| 632 multiplexLeave(); | |
| 633 sqlite3_free(zToFree); | |
| 634 return rc; | |
| 635 } | |
| 636 | |
| 637 /* | |
| 638 ** This is the xDelete method used for the "multiplex" VFS. | |
| 639 ** It attempts to delete the filename specified. | |
| 640 */ | |
| 641 static int multiplexDelete( | |
| 642 sqlite3_vfs *pVfs, /* The multiplex VFS */ | |
| 643 const char *zName, /* Name of file to delete */ | |
| 644 int syncDir | |
| 645 ){ | |
| 646 int rc; | |
| 647 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */ | |
| 648 rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir); | |
| 649 if( rc==SQLITE_OK ){ | |
| 650 /* If the main chunk was deleted successfully, also delete any subsequent | |
| 651 ** chunks - starting with the last (highest numbered). | |
| 652 */ | |
| 653 int nName = (int)strlen(zName); | |
| 654 char *z; | |
| 655 z = sqlite3_malloc(nName + 5); | |
| 656 if( z==0 ){ | |
| 657 rc = SQLITE_IOERR_NOMEM; | |
| 658 }else{ | |
| 659 int iChunk = 0; | |
| 660 int bExists; | |
| 661 do{ | |
| 662 multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, ++iChunk, z); | |
| 663 rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists); | |
| 664 }while( rc==SQLITE_OK && bExists ); | |
| 665 while( rc==SQLITE_OK && iChunk>1 ){ | |
| 666 multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, --iChunk, z); | |
| 667 rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir); | |
| 668 } | |
| 669 if( rc==SQLITE_OK ){ | |
| 670 iChunk = 0; | |
| 671 do{ | |
| 672 multiplexFilename(zName, nName, SQLITE_OPEN_WAL, ++iChunk, z); | |
| 673 rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists); | |
| 674 }while( rc==SQLITE_OK && bExists ); | |
| 675 while( rc==SQLITE_OK && iChunk>1 ){ | |
| 676 multiplexFilename(zName, nName, SQLITE_OPEN_WAL, --iChunk, z); | |
| 677 rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir); | |
| 678 } | |
| 679 } | |
| 680 } | |
| 681 sqlite3_free(z); | |
| 682 } | |
| 683 return rc; | |
| 684 } | |
| 685 | |
| 686 static int multiplexAccess(sqlite3_vfs *a, const char *b, int c, int *d){ | |
| 687 return gMultiplex.pOrigVfs->xAccess(gMultiplex.pOrigVfs, b, c, d); | |
| 688 } | |
| 689 static int multiplexFullPathname(sqlite3_vfs *a, const char *b, int c, char *d){ | |
| 690 return gMultiplex.pOrigVfs->xFullPathname(gMultiplex.pOrigVfs, b, c, d); | |
| 691 } | |
| 692 static void *multiplexDlOpen(sqlite3_vfs *a, const char *b){ | |
| 693 return gMultiplex.pOrigVfs->xDlOpen(gMultiplex.pOrigVfs, b); | |
| 694 } | |
| 695 static void multiplexDlError(sqlite3_vfs *a, int b, char *c){ | |
| 696 gMultiplex.pOrigVfs->xDlError(gMultiplex.pOrigVfs, b, c); | |
| 697 } | |
| 698 static void (*multiplexDlSym(sqlite3_vfs *a, void *b, const char *c))(void){ | |
| 699 return gMultiplex.pOrigVfs->xDlSym(gMultiplex.pOrigVfs, b, c); | |
| 700 } | |
| 701 static void multiplexDlClose(sqlite3_vfs *a, void *b){ | |
| 702 gMultiplex.pOrigVfs->xDlClose(gMultiplex.pOrigVfs, b); | |
| 703 } | |
| 704 static int multiplexRandomness(sqlite3_vfs *a, int b, char *c){ | |
| 705 return gMultiplex.pOrigVfs->xRandomness(gMultiplex.pOrigVfs, b, c); | |
| 706 } | |
| 707 static int multiplexSleep(sqlite3_vfs *a, int b){ | |
| 708 return gMultiplex.pOrigVfs->xSleep(gMultiplex.pOrigVfs, b); | |
| 709 } | |
| 710 static int multiplexCurrentTime(sqlite3_vfs *a, double *b){ | |
| 711 return gMultiplex.pOrigVfs->xCurrentTime(gMultiplex.pOrigVfs, b); | |
| 712 } | |
| 713 static int multiplexGetLastError(sqlite3_vfs *a, int b, char *c){ | |
| 714 return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c); | |
| 715 } | |
| 716 static int multiplexCurrentTimeInt64(sqlite3_vfs *a, sqlite3_int64 *b){ | |
| 717 return gMultiplex.pOrigVfs->xCurrentTimeInt64(gMultiplex.pOrigVfs, b); | |
| 718 } | |
| 719 | |
| 720 /************************ I/O Method Wrappers *******************************/ | |
| 721 | |
| 722 /* xClose requests get passed through to the original VFS. | |
| 723 ** We loop over all open chunk handles and close them. | |
| 724 ** The group structure for this file is unlinked from | |
| 725 ** our list of groups and freed. | |
| 726 */ | |
| 727 static int multiplexClose(sqlite3_file *pConn){ | |
| 728 multiplexConn *p = (multiplexConn*)pConn; | |
| 729 multiplexGroup *pGroup = p->pGroup; | |
| 730 int rc = SQLITE_OK; | |
| 731 multiplexEnter(); | |
| 732 multiplexFreeComponents(pGroup); | |
| 733 /* remove from linked list */ | |
| 734 if( pGroup->pNext ) pGroup->pNext->pPrev = pGroup->pPrev; | |
| 735 if( pGroup->pPrev ){ | |
| 736 pGroup->pPrev->pNext = pGroup->pNext; | |
| 737 }else{ | |
| 738 gMultiplex.pGroups = pGroup->pNext; | |
| 739 } | |
| 740 sqlite3_free(pGroup); | |
| 741 multiplexLeave(); | |
| 742 return rc; | |
| 743 } | |
| 744 | |
| 745 /* Pass xRead requests thru to the original VFS after | |
| 746 ** determining the correct chunk to operate on. | |
| 747 ** Break up reads across chunk boundaries. | |
| 748 */ | |
| 749 static int multiplexRead( | |
| 750 sqlite3_file *pConn, | |
| 751 void *pBuf, | |
| 752 int iAmt, | |
| 753 sqlite3_int64 iOfst | |
| 754 ){ | |
| 755 multiplexConn *p = (multiplexConn*)pConn; | |
| 756 multiplexGroup *pGroup = p->pGroup; | |
| 757 int rc = SQLITE_OK; | |
| 758 int nMutex = 0; | |
| 759 multiplexEnter(); nMutex++; | |
| 760 if( !pGroup->bEnabled ){ | |
| 761 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); | |
| 762 multiplexLeave(); nMutex--; | |
| 763 if( pSubOpen==0 ){ | |
| 764 rc = SQLITE_IOERR_READ; | |
| 765 }else{ | |
| 766 rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst); | |
| 767 } | |
| 768 }else{ | |
| 769 while( iAmt > 0 ){ | |
| 770 int i = (int)(iOfst / pGroup->szChunk); | |
| 771 sqlite3_file *pSubOpen; | |
| 772 if( nMutex==0 ){ multiplexEnter(); nMutex++; } | |
| 773 pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1); | |
| 774 multiplexLeave(); nMutex--; | |
| 775 if( pSubOpen ){ | |
| 776 int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - pGroup->szChunk; | |
| 777 if( extra<0 ) extra = 0; | |
| 778 iAmt -= extra; | |
| 779 rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, | |
| 780 iOfst % pGroup->szChunk); | |
| 781 if( rc!=SQLITE_OK ) break; | |
| 782 pBuf = (char *)pBuf + iAmt; | |
| 783 iOfst += iAmt; | |
| 784 iAmt = extra; | |
| 785 }else{ | |
| 786 rc = SQLITE_IOERR_READ; | |
| 787 break; | |
| 788 } | |
| 789 } | |
| 790 } | |
| 791 assert( nMutex==0 || nMutex==1 ); | |
| 792 if( nMutex ) multiplexLeave(); | |
| 793 return rc; | |
| 794 } | |
| 795 | |
| 796 /* Pass xWrite requests thru to the original VFS after | |
| 797 ** determining the correct chunk to operate on. | |
| 798 ** Break up writes across chunk boundaries. | |
| 799 */ | |
| 800 static int multiplexWrite( | |
| 801 sqlite3_file *pConn, | |
| 802 const void *pBuf, | |
| 803 int iAmt, | |
| 804 sqlite3_int64 iOfst | |
| 805 ){ | |
| 806 multiplexConn *p = (multiplexConn*)pConn; | |
| 807 multiplexGroup *pGroup = p->pGroup; | |
| 808 int rc = SQLITE_OK; | |
| 809 multiplexEnter(); | |
| 810 if( !pGroup->bEnabled ){ | |
| 811 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); | |
| 812 if( pSubOpen==0 ){ | |
| 813 rc = SQLITE_IOERR_WRITE; | |
| 814 }else{ | |
| 815 rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst); | |
| 816 } | |
| 817 }else{ | |
| 818 while( rc==SQLITE_OK && iAmt>0 ){ | |
| 819 int i = (int)(iOfst / pGroup->szChunk); | |
| 820 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1); | |
| 821 if( pSubOpen ){ | |
| 822 int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - | |
| 823 pGroup->szChunk; | |
| 824 if( extra<0 ) extra = 0; | |
| 825 iAmt -= extra; | |
| 826 rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, | |
| 827 iOfst % pGroup->szChunk); | |
| 828 pBuf = (char *)pBuf + iAmt; | |
| 829 iOfst += iAmt; | |
| 830 iAmt = extra; | |
| 831 } | |
| 832 } | |
| 833 } | |
| 834 multiplexLeave(); | |
| 835 return rc; | |
| 836 } | |
| 837 | |
| 838 /* Pass xTruncate requests thru to the original VFS after | |
| 839 ** determining the correct chunk to operate on. Delete any | |
| 840 ** chunks above the truncate mark. | |
| 841 */ | |
| 842 static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){ | |
| 843 multiplexConn *p = (multiplexConn*)pConn; | |
| 844 multiplexGroup *pGroup = p->pGroup; | |
| 845 int rc = SQLITE_OK; | |
| 846 multiplexEnter(); | |
| 847 if( !pGroup->bEnabled ){ | |
| 848 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); | |
| 849 if( pSubOpen==0 ){ | |
| 850 rc = SQLITE_IOERR_TRUNCATE; | |
| 851 }else{ | |
| 852 rc = pSubOpen->pMethods->xTruncate(pSubOpen, size); | |
| 853 } | |
| 854 }else{ | |
| 855 int i; | |
| 856 int iBaseGroup = (int)(size / pGroup->szChunk); | |
| 857 sqlite3_file *pSubOpen; | |
| 858 sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */ | |
| 859 /* delete the chunks above the truncate limit */ | |
| 860 for(i = pGroup->nReal-1; i>iBaseGroup && rc==SQLITE_OK; i--){ | |
| 861 if( pGroup->bTruncate ){ | |
| 862 multiplexSubClose(pGroup, i, pOrigVfs); | |
| 863 }else{ | |
| 864 pSubOpen = multiplexSubOpen(pGroup, i, &rc, 0, 0); | |
| 865 if( pSubOpen ){ | |
| 866 rc = pSubOpen->pMethods->xTruncate(pSubOpen, 0); | |
| 867 } | |
| 868 } | |
| 869 } | |
| 870 if( rc==SQLITE_OK ){ | |
| 871 pSubOpen = multiplexSubOpen(pGroup, iBaseGroup, &rc, 0, 0); | |
| 872 if( pSubOpen ){ | |
| 873 rc = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->szChunk); | |
| 874 } | |
| 875 } | |
| 876 if( rc ) rc = SQLITE_IOERR_TRUNCATE; | |
| 877 } | |
| 878 multiplexLeave(); | |
| 879 return rc; | |
| 880 } | |
| 881 | |
| 882 /* Pass xSync requests through to the original VFS without change | |
| 883 */ | |
| 884 static int multiplexSync(sqlite3_file *pConn, int flags){ | |
| 885 multiplexConn *p = (multiplexConn*)pConn; | |
| 886 multiplexGroup *pGroup = p->pGroup; | |
| 887 int rc = SQLITE_OK; | |
| 888 int i; | |
| 889 multiplexEnter(); | |
| 890 for(i=0; i<pGroup->nReal; i++){ | |
| 891 sqlite3_file *pSubOpen = pGroup->aReal[i].p; | |
| 892 if( pSubOpen ){ | |
| 893 int rc2 = pSubOpen->pMethods->xSync(pSubOpen, flags); | |
| 894 if( rc2!=SQLITE_OK ) rc = rc2; | |
| 895 } | |
| 896 } | |
| 897 multiplexLeave(); | |
| 898 return rc; | |
| 899 } | |
| 900 | |
| 901 /* Pass xFileSize requests through to the original VFS. | |
| 902 ** Aggregate the size of all the chunks before returning. | |
| 903 */ | |
| 904 static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){ | |
| 905 multiplexConn *p = (multiplexConn*)pConn; | |
| 906 multiplexGroup *pGroup = p->pGroup; | |
| 907 int rc = SQLITE_OK; | |
| 908 int i; | |
| 909 multiplexEnter(); | |
| 910 if( !pGroup->bEnabled ){ | |
| 911 sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); | |
| 912 if( pSubOpen==0 ){ | |
| 913 rc = SQLITE_IOERR_FSTAT; | |
| 914 }else{ | |
| 915 rc = pSubOpen->pMethods->xFileSize(pSubOpen, pSize); | |
| 916 } | |
| 917 }else{ | |
| 918 *pSize = 0; | |
| 919 for(i=0; rc==SQLITE_OK; i++){ | |
| 920 sqlite3_int64 sz = multiplexSubSize(pGroup, i, &rc); | |
| 921 if( sz==0 ) break; | |
| 922 *pSize = i*(sqlite3_int64)pGroup->szChunk + sz; | |
| 923 } | |
| 924 } | |
| 925 multiplexLeave(); | |
| 926 return rc; | |
| 927 } | |
| 928 | |
| 929 /* Pass xLock requests through to the original VFS unchanged. | |
| 930 */ | |
| 931 static int multiplexLock(sqlite3_file *pConn, int lock){ | |
| 932 multiplexConn *p = (multiplexConn*)pConn; | |
| 933 int rc; | |
| 934 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 935 if( pSubOpen ){ | |
| 936 return pSubOpen->pMethods->xLock(pSubOpen, lock); | |
| 937 } | |
| 938 return SQLITE_BUSY; | |
| 939 } | |
| 940 | |
| 941 /* Pass xUnlock requests through to the original VFS unchanged. | |
| 942 */ | |
| 943 static int multiplexUnlock(sqlite3_file *pConn, int lock){ | |
| 944 multiplexConn *p = (multiplexConn*)pConn; | |
| 945 int rc; | |
| 946 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 947 if( pSubOpen ){ | |
| 948 return pSubOpen->pMethods->xUnlock(pSubOpen, lock); | |
| 949 } | |
| 950 return SQLITE_IOERR_UNLOCK; | |
| 951 } | |
| 952 | |
| 953 /* Pass xCheckReservedLock requests through to the original VFS unchanged. | |
| 954 */ | |
| 955 static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){ | |
| 956 multiplexConn *p = (multiplexConn*)pConn; | |
| 957 int rc; | |
| 958 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 959 if( pSubOpen ){ | |
| 960 return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut); | |
| 961 } | |
| 962 return SQLITE_IOERR_CHECKRESERVEDLOCK; | |
| 963 } | |
| 964 | |
| 965 /* Pass xFileControl requests through to the original VFS unchanged, | |
| 966 ** except for any MULTIPLEX_CTRL_* requests here. | |
| 967 */ | |
| 968 static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){ | |
| 969 multiplexConn *p = (multiplexConn*)pConn; | |
| 970 multiplexGroup *pGroup = p->pGroup; | |
| 971 int rc = SQLITE_ERROR; | |
| 972 sqlite3_file *pSubOpen; | |
| 973 | |
| 974 if( !gMultiplex.isInitialized ) return SQLITE_MISUSE; | |
| 975 switch( op ){ | |
| 976 case MULTIPLEX_CTRL_ENABLE: | |
| 977 if( pArg ) { | |
| 978 int bEnabled = *(int *)pArg; | |
| 979 pGroup->bEnabled = bEnabled; | |
| 980 rc = SQLITE_OK; | |
| 981 } | |
| 982 break; | |
| 983 case MULTIPLEX_CTRL_SET_CHUNK_SIZE: | |
| 984 if( pArg ) { | |
| 985 unsigned int szChunk = *(unsigned*)pArg; | |
| 986 if( szChunk<1 ){ | |
| 987 rc = SQLITE_MISUSE; | |
| 988 }else{ | |
| 989 /* Round up to nearest multiple of MAX_PAGE_SIZE. */ | |
| 990 szChunk = (szChunk + (MAX_PAGE_SIZE-1)); | |
| 991 szChunk &= ~(MAX_PAGE_SIZE-1); | |
| 992 pGroup->szChunk = szChunk; | |
| 993 rc = SQLITE_OK; | |
| 994 } | |
| 995 } | |
| 996 break; | |
| 997 case MULTIPLEX_CTRL_SET_MAX_CHUNKS: | |
| 998 rc = SQLITE_OK; | |
| 999 break; | |
| 1000 case SQLITE_FCNTL_SIZE_HINT: | |
| 1001 case SQLITE_FCNTL_CHUNK_SIZE: | |
| 1002 /* no-op these */ | |
| 1003 rc = SQLITE_OK; | |
| 1004 break; | |
| 1005 case SQLITE_FCNTL_PRAGMA: { | |
| 1006 char **aFcntl = (char**)pArg; | |
| 1007 if( aFcntl[1] && sqlite3_stricmp(aFcntl[1],"multiplex_truncate")==0 ){ | |
| 1008 if( aFcntl[2] && aFcntl[2][0] ){ | |
| 1009 if( sqlite3_stricmp(aFcntl[2], "on")==0 | |
| 1010 || sqlite3_stricmp(aFcntl[2], "1")==0 ){ | |
| 1011 pGroup->bTruncate = 1; | |
| 1012 }else | |
| 1013 if( sqlite3_stricmp(aFcntl[2], "off")==0 | |
| 1014 || sqlite3_stricmp(aFcntl[2], "0")==0 ){ | |
| 1015 pGroup->bTruncate = 0; | |
| 1016 } | |
| 1017 } | |
| 1018 aFcntl[0] = sqlite3_mprintf(pGroup->bTruncate ? "on" : "off"); | |
| 1019 rc = SQLITE_OK; | |
| 1020 break; | |
| 1021 } | |
| 1022 /* If the multiplexor does not handle the pragma, pass it through | |
| 1023 ** into the default case. */ | |
| 1024 } | |
| 1025 default: | |
| 1026 pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); | |
| 1027 if( pSubOpen ){ | |
| 1028 rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg); | |
| 1029 if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){ | |
| 1030 *(char**)pArg = sqlite3_mprintf("multiplex/%z", *(char**)pArg); | |
| 1031 } | |
| 1032 } | |
| 1033 break; | |
| 1034 } | |
| 1035 return rc; | |
| 1036 } | |
| 1037 | |
| 1038 /* Pass xSectorSize requests through to the original VFS unchanged. | |
| 1039 */ | |
| 1040 static int multiplexSectorSize(sqlite3_file *pConn){ | |
| 1041 multiplexConn *p = (multiplexConn*)pConn; | |
| 1042 int rc; | |
| 1043 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 1044 if( pSubOpen && pSubOpen->pMethods->xSectorSize ){ | |
| 1045 return pSubOpen->pMethods->xSectorSize(pSubOpen); | |
| 1046 } | |
| 1047 return DEFAULT_SECTOR_SIZE; | |
| 1048 } | |
| 1049 | |
| 1050 /* Pass xDeviceCharacteristics requests through to the original VFS unchanged. | |
| 1051 */ | |
| 1052 static int multiplexDeviceCharacteristics(sqlite3_file *pConn){ | |
| 1053 multiplexConn *p = (multiplexConn*)pConn; | |
| 1054 int rc; | |
| 1055 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 1056 if( pSubOpen ){ | |
| 1057 return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen); | |
| 1058 } | |
| 1059 return 0; | |
| 1060 } | |
| 1061 | |
| 1062 /* Pass xShmMap requests through to the original VFS unchanged. | |
| 1063 */ | |
| 1064 static int multiplexShmMap( | |
| 1065 sqlite3_file *pConn, /* Handle open on database file */ | |
| 1066 int iRegion, /* Region to retrieve */ | |
| 1067 int szRegion, /* Size of regions */ | |
| 1068 int bExtend, /* True to extend file if necessary */ | |
| 1069 void volatile **pp /* OUT: Mapped memory */ | |
| 1070 ){ | |
| 1071 multiplexConn *p = (multiplexConn*)pConn; | |
| 1072 int rc; | |
| 1073 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 1074 if( pSubOpen ){ | |
| 1075 return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend,pp); | |
| 1076 } | |
| 1077 return SQLITE_IOERR; | |
| 1078 } | |
| 1079 | |
| 1080 /* Pass xShmLock requests through to the original VFS unchanged. | |
| 1081 */ | |
| 1082 static int multiplexShmLock( | |
| 1083 sqlite3_file *pConn, /* Database file holding the shared memory */ | |
| 1084 int ofst, /* First lock to acquire or release */ | |
| 1085 int n, /* Number of locks to acquire or release */ | |
| 1086 int flags /* What to do with the lock */ | |
| 1087 ){ | |
| 1088 multiplexConn *p = (multiplexConn*)pConn; | |
| 1089 int rc; | |
| 1090 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 1091 if( pSubOpen ){ | |
| 1092 return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags); | |
| 1093 } | |
| 1094 return SQLITE_BUSY; | |
| 1095 } | |
| 1096 | |
| 1097 /* Pass xShmBarrier requests through to the original VFS unchanged. | |
| 1098 */ | |
| 1099 static void multiplexShmBarrier(sqlite3_file *pConn){ | |
| 1100 multiplexConn *p = (multiplexConn*)pConn; | |
| 1101 int rc; | |
| 1102 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 1103 if( pSubOpen ){ | |
| 1104 pSubOpen->pMethods->xShmBarrier(pSubOpen); | |
| 1105 } | |
| 1106 } | |
| 1107 | |
| 1108 /* Pass xShmUnmap requests through to the original VFS unchanged. | |
| 1109 */ | |
| 1110 static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){ | |
| 1111 multiplexConn *p = (multiplexConn*)pConn; | |
| 1112 int rc; | |
| 1113 sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); | |
| 1114 if( pSubOpen ){ | |
| 1115 return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag); | |
| 1116 } | |
| 1117 return SQLITE_OK; | |
| 1118 } | |
| 1119 | |
| 1120 /************************** Public Interfaces *****************************/ | |
| 1121 /* | |
| 1122 ** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize() | |
| 1123 ** | |
| 1124 ** Use the VFS named zOrigVfsName as the VFS that does the actual work. | |
| 1125 ** Use the default if zOrigVfsName==NULL. | |
| 1126 ** | |
| 1127 ** The multiplex VFS shim is named "multiplex". It will become the default | |
| 1128 ** VFS if makeDefault is non-zero. | |
| 1129 ** | |
| 1130 ** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once | |
| 1131 ** during start-up. | |
| 1132 */ | |
| 1133 int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){ | |
| 1134 sqlite3_vfs *pOrigVfs; | |
| 1135 if( gMultiplex.isInitialized ) return SQLITE_MISUSE; | |
| 1136 pOrigVfs = sqlite3_vfs_find(zOrigVfsName); | |
| 1137 if( pOrigVfs==0 ) return SQLITE_ERROR; | |
| 1138 assert( pOrigVfs!=&gMultiplex.sThisVfs ); | |
| 1139 gMultiplex.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); | |
| 1140 if( !gMultiplex.pMutex ){ | |
| 1141 return SQLITE_NOMEM; | |
| 1142 } | |
| 1143 gMultiplex.pGroups = NULL; | |
| 1144 gMultiplex.isInitialized = 1; | |
| 1145 gMultiplex.pOrigVfs = pOrigVfs; | |
| 1146 gMultiplex.sThisVfs = *pOrigVfs; | |
| 1147 gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn); | |
| 1148 gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME; | |
| 1149 gMultiplex.sThisVfs.xOpen = multiplexOpen; | |
| 1150 gMultiplex.sThisVfs.xDelete = multiplexDelete; | |
| 1151 gMultiplex.sThisVfs.xAccess = multiplexAccess; | |
| 1152 gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname; | |
| 1153 gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen; | |
| 1154 gMultiplex.sThisVfs.xDlError = multiplexDlError; | |
| 1155 gMultiplex.sThisVfs.xDlSym = multiplexDlSym; | |
| 1156 gMultiplex.sThisVfs.xDlClose = multiplexDlClose; | |
| 1157 gMultiplex.sThisVfs.xRandomness = multiplexRandomness; | |
| 1158 gMultiplex.sThisVfs.xSleep = multiplexSleep; | |
| 1159 gMultiplex.sThisVfs.xCurrentTime = multiplexCurrentTime; | |
| 1160 gMultiplex.sThisVfs.xGetLastError = multiplexGetLastError; | |
| 1161 gMultiplex.sThisVfs.xCurrentTimeInt64 = multiplexCurrentTimeInt64; | |
| 1162 | |
| 1163 gMultiplex.sIoMethodsV1.iVersion = 1; | |
| 1164 gMultiplex.sIoMethodsV1.xClose = multiplexClose; | |
| 1165 gMultiplex.sIoMethodsV1.xRead = multiplexRead; | |
| 1166 gMultiplex.sIoMethodsV1.xWrite = multiplexWrite; | |
| 1167 gMultiplex.sIoMethodsV1.xTruncate = multiplexTruncate; | |
| 1168 gMultiplex.sIoMethodsV1.xSync = multiplexSync; | |
| 1169 gMultiplex.sIoMethodsV1.xFileSize = multiplexFileSize; | |
| 1170 gMultiplex.sIoMethodsV1.xLock = multiplexLock; | |
| 1171 gMultiplex.sIoMethodsV1.xUnlock = multiplexUnlock; | |
| 1172 gMultiplex.sIoMethodsV1.xCheckReservedLock = multiplexCheckReservedLock; | |
| 1173 gMultiplex.sIoMethodsV1.xFileControl = multiplexFileControl; | |
| 1174 gMultiplex.sIoMethodsV1.xSectorSize = multiplexSectorSize; | |
| 1175 gMultiplex.sIoMethodsV1.xDeviceCharacteristics = | |
| 1176 multiplexDeviceCharacteristics; | |
| 1177 gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1; | |
| 1178 gMultiplex.sIoMethodsV2.iVersion = 2; | |
| 1179 gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap; | |
| 1180 gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock; | |
| 1181 gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier; | |
| 1182 gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap; | |
| 1183 sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault); | |
| 1184 | |
| 1185 sqlite3_auto_extension((void*)multiplexFuncInit); | |
| 1186 | |
| 1187 return SQLITE_OK; | |
| 1188 } | |
| 1189 | |
| 1190 /* | |
| 1191 ** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown() | |
| 1192 ** | |
| 1193 ** All SQLite database connections must be closed before calling this | |
| 1194 ** routine. | |
| 1195 ** | |
| 1196 ** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once while | |
| 1197 ** shutting down in order to free all remaining multiplex groups. | |
| 1198 */ | |
| 1199 int sqlite3_multiplex_shutdown(int eForce){ | |
| 1200 int rc = SQLITE_OK; | |
| 1201 if( gMultiplex.isInitialized==0 ) return SQLITE_MISUSE; | |
| 1202 if( gMultiplex.pGroups ){ | |
| 1203 sqlite3_log(SQLITE_MISUSE, "sqlite3_multiplex_shutdown() called " | |
| 1204 "while database connections are still open"); | |
| 1205 if( !eForce ) return SQLITE_MISUSE; | |
| 1206 rc = SQLITE_MISUSE; | |
| 1207 } | |
| 1208 gMultiplex.isInitialized = 0; | |
| 1209 sqlite3_mutex_free(gMultiplex.pMutex); | |
| 1210 sqlite3_vfs_unregister(&gMultiplex.sThisVfs); | |
| 1211 memset(&gMultiplex, 0, sizeof(gMultiplex)); | |
| 1212 return rc; | |
| 1213 } | |
| 1214 | |
| 1215 /***************************** Test Code ***********************************/ | |
| 1216 #ifdef SQLITE_TEST | |
| 1217 #include <tcl.h> | |
| 1218 extern const char *sqlite3ErrName(int); | |
| 1219 | |
| 1220 | |
| 1221 /* | |
| 1222 ** tclcmd: sqlite3_multiplex_initialize NAME MAKEDEFAULT | |
| 1223 */ | |
| 1224 static int test_multiplex_initialize( | |
| 1225 void * clientData, | |
| 1226 Tcl_Interp *interp, | |
| 1227 int objc, | |
| 1228 Tcl_Obj *CONST objv[] | |
| 1229 ){ | |
| 1230 const char *zName; /* Name of new multiplex VFS */ | |
| 1231 int makeDefault; /* True to make the new VFS the default */ | |
| 1232 int rc; /* Value returned by multiplex_initialize() */ | |
| 1233 | |
| 1234 UNUSED_PARAMETER(clientData); | |
| 1235 | |
| 1236 /* Process arguments */ | |
| 1237 if( objc!=3 ){ | |
| 1238 Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT"); | |
| 1239 return TCL_ERROR; | |
| 1240 } | |
| 1241 zName = Tcl_GetString(objv[1]); | |
| 1242 if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR; | |
| 1243 if( zName[0]=='\0' ) zName = 0; | |
| 1244 | |
| 1245 /* Call sqlite3_multiplex_initialize() */ | |
| 1246 rc = sqlite3_multiplex_initialize(zName, makeDefault); | |
| 1247 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); | |
| 1248 | |
| 1249 return TCL_OK; | |
| 1250 } | |
| 1251 | |
| 1252 /* | |
| 1253 ** tclcmd: sqlite3_multiplex_shutdown | |
| 1254 */ | |
| 1255 static int test_multiplex_shutdown( | |
| 1256 void * clientData, | |
| 1257 Tcl_Interp *interp, | |
| 1258 int objc, | |
| 1259 Tcl_Obj *CONST objv[] | |
| 1260 ){ | |
| 1261 int rc; /* Value returned by multiplex_shutdown() */ | |
| 1262 | |
| 1263 UNUSED_PARAMETER(clientData); | |
| 1264 | |
| 1265 if( objc==2 && strcmp(Tcl_GetString(objv[1]),"-force")!=0 ){ | |
| 1266 objc = 3; | |
| 1267 } | |
| 1268 if( (objc!=1 && objc!=2) ){ | |
| 1269 Tcl_WrongNumArgs(interp, 1, objv, "?-force?"); | |
| 1270 return TCL_ERROR; | |
| 1271 } | |
| 1272 | |
| 1273 /* Call sqlite3_multiplex_shutdown() */ | |
| 1274 rc = sqlite3_multiplex_shutdown(objc==2); | |
| 1275 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); | |
| 1276 | |
| 1277 return TCL_OK; | |
| 1278 } | |
| 1279 | |
| 1280 /* | |
| 1281 ** tclcmd: sqlite3_multiplex_dump | |
| 1282 */ | |
| 1283 static int test_multiplex_dump( | |
| 1284 void * clientData, | |
| 1285 Tcl_Interp *interp, | |
| 1286 int objc, | |
| 1287 Tcl_Obj *CONST objv[] | |
| 1288 ){ | |
| 1289 Tcl_Obj *pResult; | |
| 1290 Tcl_Obj *pGroupTerm; | |
| 1291 multiplexGroup *pGroup; | |
| 1292 int i; | |
| 1293 int nChunks = 0; | |
| 1294 | |
| 1295 UNUSED_PARAMETER(clientData); | |
| 1296 UNUSED_PARAMETER(objc); | |
| 1297 UNUSED_PARAMETER(objv); | |
| 1298 | |
| 1299 pResult = Tcl_NewObj(); | |
| 1300 multiplexEnter(); | |
| 1301 for(pGroup=gMultiplex.pGroups; pGroup; pGroup=pGroup->pNext){ | |
| 1302 pGroupTerm = Tcl_NewObj(); | |
| 1303 | |
| 1304 if( pGroup->zName ){ | |
| 1305 pGroup->zName[pGroup->nName] = '\0'; | |
| 1306 Tcl_ListObjAppendElement(interp, pGroupTerm, | |
| 1307 Tcl_NewStringObj(pGroup->zName, -1)); | |
| 1308 }else{ | |
| 1309 Tcl_ListObjAppendElement(interp, pGroupTerm, Tcl_NewObj()); | |
| 1310 } | |
| 1311 Tcl_ListObjAppendElement(interp, pGroupTerm, | |
| 1312 Tcl_NewIntObj(pGroup->nName)); | |
| 1313 Tcl_ListObjAppendElement(interp, pGroupTerm, | |
| 1314 Tcl_NewIntObj(pGroup->flags)); | |
| 1315 | |
| 1316 /* count number of chunks with open handles */ | |
| 1317 for(i=0; i<pGroup->nReal; i++){ | |
| 1318 if( pGroup->aReal[i].p!=0 ) nChunks++; | |
| 1319 } | |
| 1320 Tcl_ListObjAppendElement(interp, pGroupTerm, | |
| 1321 Tcl_NewIntObj(nChunks)); | |
| 1322 | |
| 1323 Tcl_ListObjAppendElement(interp, pGroupTerm, | |
| 1324 Tcl_NewIntObj(pGroup->szChunk)); | |
| 1325 Tcl_ListObjAppendElement(interp, pGroupTerm, | |
| 1326 Tcl_NewIntObj(pGroup->nReal)); | |
| 1327 | |
| 1328 Tcl_ListObjAppendElement(interp, pResult, pGroupTerm); | |
| 1329 } | |
| 1330 multiplexLeave(); | |
| 1331 Tcl_SetObjResult(interp, pResult); | |
| 1332 return TCL_OK; | |
| 1333 } | |
| 1334 | |
| 1335 /* | |
| 1336 ** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE? | |
| 1337 */ | |
| 1338 static int test_multiplex_control( | |
| 1339 ClientData cd, | |
| 1340 Tcl_Interp *interp, | |
| 1341 int objc, | |
| 1342 Tcl_Obj *CONST objv[] | |
| 1343 ){ | |
| 1344 int rc; /* Return code from file_control() */ | |
| 1345 int idx; /* Index in aSub[] */ | |
| 1346 Tcl_CmdInfo cmdInfo; /* Command info structure for HANDLE */ | |
| 1347 sqlite3 *db; /* Underlying db handle for HANDLE */ | |
| 1348 int iValue = 0; | |
| 1349 void *pArg = 0; | |
| 1350 | |
| 1351 struct SubCommand { | |
| 1352 const char *zName; | |
| 1353 int op; | |
| 1354 int argtype; | |
| 1355 } aSub[] = { | |
| 1356 { "enable", MULTIPLEX_CTRL_ENABLE, 1 }, | |
| 1357 { "chunk_size", MULTIPLEX_CTRL_SET_CHUNK_SIZE, 1 }, | |
| 1358 { "max_chunks", MULTIPLEX_CTRL_SET_MAX_CHUNKS, 1 }, | |
| 1359 { 0, 0, 0 } | |
| 1360 }; | |
| 1361 | |
| 1362 if( objc!=5 ){ | |
| 1363 Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE"); | |
| 1364 return TCL_ERROR; | |
| 1365 } | |
| 1366 | |
| 1367 if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){ | |
| 1368 Tcl_AppendResult(interp, "expected database handle, got \"", 0); | |
| 1369 Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", 0); | |
| 1370 return TCL_ERROR; | |
| 1371 }else{ | |
| 1372 db = *(sqlite3 **)cmdInfo.objClientData; | |
| 1373 } | |
| 1374 | |
| 1375 rc = Tcl_GetIndexFromObjStruct( | |
| 1376 interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx | |
| 1377 ); | |
| 1378 if( rc!=TCL_OK ) return rc; | |
| 1379 | |
| 1380 switch( aSub[idx].argtype ){ | |
| 1381 case 1: | |
| 1382 if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){ | |
| 1383 return TCL_ERROR; | |
| 1384 } | |
| 1385 pArg = (void *)&iValue; | |
| 1386 break; | |
| 1387 default: | |
| 1388 Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND"); | |
| 1389 return TCL_ERROR; | |
| 1390 } | |
| 1391 | |
| 1392 rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg); | |
| 1393 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); | |
| 1394 return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR; | |
| 1395 } | |
| 1396 | |
| 1397 /* | |
| 1398 ** This routine registers the custom TCL commands defined in this | |
| 1399 ** module. This should be the only procedure visible from outside | |
| 1400 ** of this module. | |
| 1401 */ | |
| 1402 int Sqlitemultiplex_Init(Tcl_Interp *interp){ | |
| 1403 static struct { | |
| 1404 char *zName; | |
| 1405 Tcl_ObjCmdProc *xProc; | |
| 1406 } aCmd[] = { | |
| 1407 { "sqlite3_multiplex_initialize", test_multiplex_initialize }, | |
| 1408 { "sqlite3_multiplex_shutdown", test_multiplex_shutdown }, | |
| 1409 { "sqlite3_multiplex_dump", test_multiplex_dump }, | |
| 1410 { "sqlite3_multiplex_control", test_multiplex_control }, | |
| 1411 }; | |
| 1412 int i; | |
| 1413 | |
| 1414 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ | |
| 1415 Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); | |
| 1416 } | |
| 1417 | |
| 1418 return TCL_OK; | |
| 1419 } | |
| 1420 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
