Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Initial implementation and test cases for the "intarray" virtual table. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
0e7d29253f093d4125ede3cfc478e4bf |
User & Date: | drh 2009-11-10 17:24:37.000 |
Context
2009-11-10
| ||
17:55 | Additional intarray test cases and tweaks to comments. (check-in: 0c8db5d88e user: drh tags: trunk) | |
17:24 | Initial implementation and test cases for the "intarray" virtual table. (check-in: 0e7d29253f user: drh tags: trunk) | |
17:07 | Fix for datbase name being ignored with the -batch option in the CLI. Ticket [aeff892c57]. (check-in: 8097c64acf user: shaneh tags: trunk) | |
Changes
Changes to Makefile.in.
︙ | ︙ | |||
379 380 381 382 383 384 385 386 387 388 389 390 391 392 | $(TOP)/src/test_backup.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_init.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_pcache.c \ $(TOP)/src/test_schema.c \ | > | 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 | $(TOP)/src/test_backup.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_init.c \ $(TOP)/src/test_intarray.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_pcache.c \ $(TOP)/src/test_schema.c \ |
︙ | ︙ |
Changes to main.mk.
︙ | ︙ | |||
227 228 229 230 231 232 233 234 235 236 237 238 239 240 | $(TOP)/src/test_backup.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_init.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_pcache.c \ $(TOP)/src/test_schema.c \ | > | 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 | $(TOP)/src/test_backup.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_init.c \ $(TOP)/src/test_intarray.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ $(TOP)/src/test_mutex.c \ $(TOP)/src/test_onefile.c \ $(TOP)/src/test_osinst.c \ $(TOP)/src/test_pcache.c \ $(TOP)/src/test_schema.c \ |
︙ | ︙ |
Changes to src/tclsqlite.c.
︙ | ︙ | |||
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 | extern int Sqlitetestschema_Init(Tcl_Interp*); extern int Sqlitetestsse_Init(Tcl_Interp*); extern int Sqlitetesttclvar_Init(Tcl_Interp*); extern int SqlitetestThread_Init(Tcl_Interp*); extern int SqlitetestOnefile_Init(); extern int SqlitetestOsinst_Init(Tcl_Interp*); extern int Sqlitetestbackup_Init(Tcl_Interp*); Sqliteconfig_Init(interp); Sqlitetest1_Init(interp); Sqlitetest2_Init(interp); Sqlitetest3_Init(interp); Sqlitetest4_Init(interp); Sqlitetest5_Init(interp); | > | 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 | extern int Sqlitetestschema_Init(Tcl_Interp*); extern int Sqlitetestsse_Init(Tcl_Interp*); extern int Sqlitetesttclvar_Init(Tcl_Interp*); extern int SqlitetestThread_Init(Tcl_Interp*); extern int SqlitetestOnefile_Init(); extern int SqlitetestOsinst_Init(Tcl_Interp*); extern int Sqlitetestbackup_Init(Tcl_Interp*); extern int Sqlitetestintarray_Init(Tcl_Interp*); Sqliteconfig_Init(interp); Sqlitetest1_Init(interp); Sqlitetest2_Init(interp); Sqlitetest3_Init(interp); Sqlitetest4_Init(interp); Sqlitetest5_Init(interp); |
︙ | ︙ | |||
3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 | Sqlitetest_mutex_Init(interp); Sqlitetestschema_Init(interp); Sqlitetesttclvar_Init(interp); SqlitetestThread_Init(interp); SqlitetestOnefile_Init(interp); SqlitetestOsinst_Init(interp); Sqlitetestbackup_Init(interp); #ifdef SQLITE_SSE Sqlitetestsse_Init(interp); #endif } #endif if( argc>=2 ){ | > | 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 | Sqlitetest_mutex_Init(interp); Sqlitetestschema_Init(interp); Sqlitetesttclvar_Init(interp); SqlitetestThread_Init(interp); SqlitetestOnefile_Init(interp); SqlitetestOsinst_Init(interp); Sqlitetestbackup_Init(interp); Sqlitetestintarray_Init(interp); #ifdef SQLITE_SSE Sqlitetestsse_Init(interp); #endif } #endif if( argc>=2 ){ |
︙ | ︙ |
Added src/test_intarray.c.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 | /* ** 2009 November 10 ** ** 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 implements a read-only VIRTUAL TABLE that contains the ** content of a C-language array of integer values. See the corresponding ** header file for full details. */ #include "test_intarray.h" #include <string.h> #include <assert.h> /* ** Definition of the sqlite3_intarray object. ** ** The internal representation of an intarray object is subject ** to change, is not externally visible, and should be used by ** the implementation of intarray only. This object is opaque ** to users. */ struct sqlite3_intarray { int n; /* Number of elements in the array */ sqlite3_int64 *a; /* Contents of the array */ void (*xFree)(void*); /* Function used to free a[] */ }; /* Objects used internally by the virtual table implementation */ typedef struct intarray_vtab intarray_vtab; typedef struct intarray_cursor intarray_cursor; /* A intarray table object */ struct intarray_vtab { sqlite3_vtab base; /* Base class */ sqlite3_intarray *pContent; /* Content of the integer array */ }; /* A intarray cursor object */ struct intarray_cursor { sqlite3_vtab_cursor base; /* Base class */ int i; /* Current cursor position */ }; /* ** None of this works unless we have virtual tables. */ #ifndef SQLITE_OMIT_VIRTUALTABLE /* ** Free an sqlite3_intarray object */ static void intarrayFree(sqlite3_intarray *p){ if( p->xFree ){ p->xFree(p->a); } sqlite3_free(p); } /* ** Table destructor for the intarray module. */ static int intarrayDestroy(sqlite3_vtab *p){ intarray_vtab *pVtab = (intarray_vtab*)p; sqlite3_free(pVtab); return 0; } /* ** Table constructor for the intarray module. */ static int intarrayCreate( sqlite3 *db, /* Database where module is created */ void *pAux, /* clientdata for the module */ int argc, /* Number of arguments */ const char *const*argv, /* Value for all arguments */ sqlite3_vtab **ppVtab, /* Write the new virtual table object here */ char **pzErr /* Put error message text here */ ){ int rc = SQLITE_NOMEM; intarray_vtab *pVtab = sqlite3_malloc(sizeof(intarray_vtab)); if( pVtab ){ memset(pVtab, 0, sizeof(intarray_vtab)); pVtab->pContent = (sqlite3_intarray*)pAux; rc = sqlite3_declare_vtab(db, "CREATE TABLE x(value INTEGER PRIMARY KEY)"); } *ppVtab = (sqlite3_vtab *)pVtab; return rc; } /* ** Open a new cursor on the intarray table. */ static int intarrayOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ int rc = SQLITE_NOMEM; intarray_cursor *pCur; pCur = sqlite3_malloc(sizeof(intarray_cursor)); if( pCur ){ memset(pCur, 0, sizeof(intarray_cursor)); *ppCursor = (sqlite3_vtab_cursor *)pCur; rc = SQLITE_OK; } return rc; } /* ** Close a intarray table cursor. */ static int intarrayClose(sqlite3_vtab_cursor *cur){ intarray_cursor *pCur = (intarray_cursor *)cur; sqlite3_free(pCur); return SQLITE_OK; } /* ** Retrieve a column of data. */ static int intarrayColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ intarray_cursor *pCur = (intarray_cursor*)cur; intarray_vtab *pVtab = (intarray_vtab*)cur->pVtab; if( pCur->i>=0 && pCur->i<pVtab->pContent->n ){ sqlite3_result_int64(ctx, pVtab->pContent->a[pCur->i]); } return SQLITE_OK; } /* ** Retrieve the current rowid. */ static int intarrayRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ intarray_cursor *pCur = (intarray_cursor *)cur; *pRowid = pCur->i; return SQLITE_OK; } static int intarrayEof(sqlite3_vtab_cursor *cur){ intarray_cursor *pCur = (intarray_cursor *)cur; intarray_vtab *pVtab = (intarray_vtab *)cur->pVtab; return pCur->i>=pVtab->pContent->n; } /* ** Advance the cursor to the next row. */ static int intarrayNext(sqlite3_vtab_cursor *cur){ intarray_cursor *pCur = (intarray_cursor *)cur; pCur->i++; return SQLITE_OK; } /* ** Reset a intarray table cursor. */ static int intarrayFilter( sqlite3_vtab_cursor *pVtabCursor, int idxNum, const char *idxStr, int argc, sqlite3_value **argv ){ intarray_cursor *pCur = (intarray_cursor *)pVtabCursor; pCur->i = 0; return SQLITE_OK; } /* ** Analyse the WHERE condition. */ static int intarrayBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ return SQLITE_OK; } /* ** A virtual table module that merely echos method calls into TCL ** variables. */ static sqlite3_module intarrayModule = { 0, /* iVersion */ intarrayCreate, /* xCreate - create a new virtual table */ intarrayCreate, /* xConnect - connect to an existing vtab */ intarrayBestIndex, /* xBestIndex - find the best query index */ intarrayDestroy, /* xDisconnect - disconnect a vtab */ intarrayDestroy, /* xDestroy - destroy a vtab */ intarrayOpen, /* xOpen - open a cursor */ intarrayClose, /* xClose - close a cursor */ intarrayFilter, /* xFilter - configure scan constraints */ intarrayNext, /* xNext - advance a cursor */ intarrayEof, /* xEof */ intarrayColumn, /* xColumn - read data */ intarrayRowid, /* xRowid - read data */ 0, /* xUpdate */ 0, /* xBegin */ 0, /* xSync */ 0, /* xCommit */ 0, /* xRollback */ 0, /* xFindMethod */ 0, /* xRename */ }; #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */ /* ** Invoke this routine to create a specific instance of an intarray object. ** The new intarray object is returned by the 3rd parameter. ** ** Each intarray object corresponds to a virtual table in the TEMP table ** with a name of zName. ** ** Destroy the intarray object by dropping the virtual table. If not done ** explicitly by the application, the virtual table will be dropped implicitly ** by the system when the database connection is closed. */ int sqlite3_intarray_create( sqlite3 *db, const char *zName, sqlite3_intarray **ppReturn ){ int rc; sqlite3_intarray *p; *ppReturn = p = sqlite3_malloc( sizeof(*p) ); if( p==0 ){ return SQLITE_NOMEM; } memset(p, 0, sizeof(*p)); rc = sqlite3_create_module_v2(db, zName, &intarrayModule, p, (void(*)(void*))intarrayFree); if( rc==SQLITE_OK ){ char *zSql; zSql = sqlite3_mprintf("CREATE VIRTUAL TABLE temp.%Q USING %Q", zName, zName); rc = sqlite3_exec(db, zSql, 0, 0, 0); sqlite3_free(zSql); } return rc; } /* ** Bind a new array array of integers to a specific intarray object. ** ** The array of integers bound must be unchanged for the duration of ** any query against the corresponding virtual table. If the integer ** array does change or is deallocated undefined behavior will result. */ int sqlite3_intarray_bind( sqlite3_intarray *pIntArray, /* The intarray object to bind to */ int nElements, /* Number of elements in the intarray */ sqlite3_int64 *aElements, /* Content of the intarray */ void (*xFree)(void*) /* How to dispose of the intarray when done */ ){ if( pIntArray->xFree ){ pIntArray->xFree(pIntArray->a); } pIntArray->n = nElements; pIntArray->a = aElements; pIntArray->xFree = xFree; return SQLITE_OK; } /***************************************************************************** ** Everything below is interface for testing this module. */ #ifdef SQLITE_TEST #include <tcl.h> /* ** Routines to encode and decode pointers */ extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb); extern int sqlite3TestTextToPtr(const char*); extern int sqlite3TestMakePointerStr(Tcl_Interp*, char *zPtr, void*); extern const char *sqlite3TestErrorName(int); /* ** sqlite3_intarray_create DB NAME ** ** Invoke the sqlite3_intarray_create interface. A string that becomes ** the first parameter to sqlite3_intarray_bind. */ static int test_intarray_create( ClientData clientData, /* Not used */ Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int objc, /* Number of arguments */ Tcl_Obj *CONST objv[] /* Command arguments */ ){ sqlite3 *db; const char *zName; sqlite3_intarray *pArray; int rc; char zPtr[100]; if( objc!=3 ){ Tcl_WrongNumArgs(interp, 1, objv, "DB"); return TCL_ERROR; } if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; zName = Tcl_GetString(objv[2]); rc = sqlite3_intarray_create(db, zName, &pArray); if( rc!=SQLITE_OK ){ assert( pArray==0 ); Tcl_AppendResult(interp, sqlite3TestErrorName(rc), (char*)0); return TCL_ERROR; } sqlite3TestMakePointerStr(interp, zPtr, pArray); Tcl_AppendResult(interp, zPtr, (char*)0); return TCL_OK; } /* ** sqlite3_intarray_bind INTARRAY ?VALUE ...? ** ** Invoke the sqlite3_intarray_bind interface on the given array of integers. */ static int test_intarray_bind( ClientData clientData, /* Not used */ Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int objc, /* Number of arguments */ Tcl_Obj *CONST objv[] /* Command arguments */ ){ sqlite3_intarray *pArray; int rc; int i, n; sqlite3_int64 *a; if( objc<2 ){ Tcl_WrongNumArgs(interp, 1, objv, "INTARRAY"); return TCL_ERROR; } pArray = (sqlite3_intarray*)sqlite3TestTextToPtr(Tcl_GetString(objv[1])); n = objc - 2; a = sqlite3_malloc( sizeof(a[0])*n ); if( a==0 ){ Tcl_AppendResult(interp, "SQLITE_NOMEM", (char*)0); return TCL_ERROR; } for(i=0; i<n; i++){ a[i] = 0; Tcl_GetWideIntFromObj(0, objv[i+2], &a[i]); } rc = sqlite3_intarray_bind(pArray, n, a, sqlite3_free); if( rc!=SQLITE_OK ){ Tcl_AppendResult(interp, sqlite3TestErrorName(rc), (char*)0); return TCL_ERROR; } return TCL_OK; } /* ** Register commands with the TCL interpreter. */ int Sqlitetestintarray_Init(Tcl_Interp *interp){ static struct { char *zName; Tcl_ObjCmdProc *xProc; void *clientData; } aObjCmd[] = { { "sqlite3_intarray_create", test_intarray_create, 0 }, { "sqlite3_intarray_bind", test_intarray_bind, 0 }, }; int i; for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, aObjCmd[i].clientData, 0); } return TCL_OK; } #endif /* SQLITE_TEST */ |
Added src/test_intarray.h.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | /* ** 2009 November 10 ** ** 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 is the C-language interface definition for the "intarray" or ** integer array virtual table for SQLite. ** ** The intarray virtual table is designed to facilitate using an ** array of integers as the right-hand side of an IN operator. So ** instead of doing a prepared statement like this: ** ** SELECT * FROM table WHERE x IN (?,?,?,...,?); ** ** And then binding indivdual integers to each of ? slots, a C-language ** application can create an intarray object (named "ex1" in the following ** example), prepare a statement like this: ** ** SELECT * FROM table WHERE x IN ex1; ** ** Then bind an ordinary C/C++ array of integer values to the ex1 object ** to run the statement. ** ** USAGE: ** ** One or more intarray objects can be created as follows: ** ** sqlite3_intarray *p1, *p2, *p3; ** sqlite3_intarray_create(db, "ex1", &p1); ** sqlite3_intarray_create(db, "ex2", &p2); ** sqlite3_intarray_create(db, "ex3", &p3); ** ** Each call to sqlite3_intarray_create() generates a new virtual table ** module and a singleton of that virtual table module in the TEMP ** database. Both the module and the virtual table instance use the ** name given by the second parameter. The virtual tables can then be ** used in prepared statements: ** ** SELECT * FROM t1, t2, t3 ** WHERE t1.x IN ex1 ** AND t2.y IN ex2 ** AND t3.z IN ex3; ** ** Each integer array is initially empty. New arrays can be bound to ** an integer array as follows: ** ** sqlite3_int64 a1[] = { 1, 2, 3, 4 }; ** sqlite3_int64 a2[] = { 5, 6, 7, 8, 9, 10, 11 }; ** sqlite3_int64 *a3 = sqlite3_malloc( 100*sizeof(sqlite3_int64) ); ** // Fill in content of a3[] ** sqlite3_intarray_bind(p1, 4, a1, 0); ** sqlite3_intarray_bind(p2, 7, a2, 0); ** sqlite3_intarray_bind(p3, 100, a3, sqlite3_free); ** ** A single intarray object can be rebound multiple times. But do not ** attempt to change the bindings of an intarray while it is in the middle ** of a query. ** ** The array that holds the integers is automatically freed by the function ** in the fourth parameter to sqlite3_intarray_bind() when the array is no ** longer needed. The application must not change the intarray values ** while an intarray is in the middle of a query. ** ** The intarray object is automatically destroyed when its corresponding ** virtual table is dropped. Since the virtual tables are created in the ** TEMP database, they are automatically dropped when the database connection ** closes so the application does not normally need to take any special ** action to free the intarray objects. */ #include "sqlite3.h" /* ** An sqlite3_intarray is an abstract type to stores an instance of ** an integer array. */ typedef struct sqlite3_intarray sqlite3_intarray; /* ** Invoke this routine to create a specific instance of an intarray object. ** The new intarray object is returned by the 3rd parameter. ** ** Each intarray object corresponds to a virtual table in the TEMP table ** with a name of zName. ** ** Destroy the intarray object by dropping the virtual table. If not done ** explicitly by the application, the virtual table will be dropped implicitly ** by the system when the database connection is closed. */ int sqlite3_intarray_create( sqlite3 *db, const char *zName, sqlite3_intarray **ppReturn ); /* ** Bind a new array array of integers to a specific intarray object. ** ** The array of integers bound must be unchanged for the duration of ** any query against the corresponding virtual table. If the integer ** array does change or is deallocated undefined behavior will result. */ int sqlite3_intarray_bind( sqlite3_intarray *pIntArray, /* The intarray object to bind to */ int nElements, /* Number of elements in the intarray */ sqlite3_int64 *aElements, /* Content of the intarray */ void (*xFree)(void*) /* How to dispose of the intarray when done */ ); |
Added test/intarray.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | # 2009 November 10 # # 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 implements regression tests for SQLite library. # # This file implements tests for the "intarray" object implemented # in test_intarray.c. # set testdir [file dirname $argv0] source $testdir/tester.tcl ifcapable !vtab { return } do_test intarray-1.0 { db eval { CREATE TABLE t1(a INTEGER PRIMARY KEY, b); } for {set i 1} {$i<=999} {incr i} { set b [format {x%03d} $i] db eval {INSERT INTO t1(a,b) VALUES($i,$b)} } db eval { SELECT b FROM t1 WHERE a IN (12,34,56,78) ORDER BY a } } {x012 x034 x056 x078} do_test intarray-1.1 { set ia1 [sqlite3_intarray_create db ia1] set ia2 [sqlite3_intarray_create db ia2] set ia3 [sqlite3_intarray_create db ia3] set ia4 [sqlite3_intarray_create db ia4] db eval { SELECT type, name FROM sqlite_temp_master ORDER BY name } } {table ia1 table ia2 table ia3 table ia4} do_test intarray-1.2 { db eval { SELECT b FROM t1 WHERE a IN ia3 ORDER BY a } } {} do_test intarray-1.3 { sqlite3_intarray_bind $ia3 45 123 678 db eval { SELECT b FROM t1 WHERE a IN ia3 ORDER BY a } } {x045 x123 x678} finish_test |