| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2009 November 10 | |
| 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 implements a read-only VIRTUAL TABLE that contains the | |
| 14 ** content of a C-language array of integer values. See the corresponding | |
| 15 ** header file for full details. | |
| 16 */ | |
| 17 #include "test_intarray.h" | |
| 18 #include <string.h> | |
| 19 #include <assert.h> | |
| 20 | |
| 21 | |
| 22 /* | |
| 23 ** Definition of the sqlite3_intarray object. | |
| 24 ** | |
| 25 ** The internal representation of an intarray object is subject | |
| 26 ** to change, is not externally visible, and should be used by | |
| 27 ** the implementation of intarray only. This object is opaque | |
| 28 ** to users. | |
| 29 */ | |
| 30 struct sqlite3_intarray { | |
| 31 int n; /* Number of elements in the array */ | |
| 32 sqlite3_int64 *a; /* Contents of the array */ | |
| 33 void (*xFree)(void*); /* Function used to free a[] */ | |
| 34 }; | |
| 35 | |
| 36 /* Objects used internally by the virtual table implementation */ | |
| 37 typedef struct intarray_vtab intarray_vtab; | |
| 38 typedef struct intarray_cursor intarray_cursor; | |
| 39 | |
| 40 /* An intarray table object */ | |
| 41 struct intarray_vtab { | |
| 42 sqlite3_vtab base; /* Base class */ | |
| 43 sqlite3_intarray *pContent; /* Content of the integer array */ | |
| 44 }; | |
| 45 | |
| 46 /* An intarray cursor object */ | |
| 47 struct intarray_cursor { | |
| 48 sqlite3_vtab_cursor base; /* Base class */ | |
| 49 int i; /* Current cursor position */ | |
| 50 }; | |
| 51 | |
| 52 /* | |
| 53 ** None of this works unless we have virtual tables. | |
| 54 */ | |
| 55 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 56 | |
| 57 /* | |
| 58 ** Free an sqlite3_intarray object. | |
| 59 */ | |
| 60 static void intarrayFree(sqlite3_intarray *p){ | |
| 61 if( p->xFree ){ | |
| 62 p->xFree(p->a); | |
| 63 } | |
| 64 sqlite3_free(p); | |
| 65 } | |
| 66 | |
| 67 /* | |
| 68 ** Table destructor for the intarray module. | |
| 69 */ | |
| 70 static int intarrayDestroy(sqlite3_vtab *p){ | |
| 71 intarray_vtab *pVtab = (intarray_vtab*)p; | |
| 72 sqlite3_free(pVtab); | |
| 73 return 0; | |
| 74 } | |
| 75 | |
| 76 /* | |
| 77 ** Table constructor for the intarray module. | |
| 78 */ | |
| 79 static int intarrayCreate( | |
| 80 sqlite3 *db, /* Database where module is created */ | |
| 81 void *pAux, /* clientdata for the module */ | |
| 82 int argc, /* Number of arguments */ | |
| 83 const char *const*argv, /* Value for all arguments */ | |
| 84 sqlite3_vtab **ppVtab, /* Write the new virtual table object here */ | |
| 85 char **pzErr /* Put error message text here */ | |
| 86 ){ | |
| 87 int rc = SQLITE_NOMEM; | |
| 88 intarray_vtab *pVtab = sqlite3_malloc64(sizeof(intarray_vtab)); | |
| 89 | |
| 90 if( pVtab ){ | |
| 91 memset(pVtab, 0, sizeof(intarray_vtab)); | |
| 92 pVtab->pContent = (sqlite3_intarray*)pAux; | |
| 93 rc = sqlite3_declare_vtab(db, "CREATE TABLE x(value INTEGER PRIMARY KEY)"); | |
| 94 } | |
| 95 *ppVtab = (sqlite3_vtab *)pVtab; | |
| 96 return rc; | |
| 97 } | |
| 98 | |
| 99 /* | |
| 100 ** Open a new cursor on the intarray table. | |
| 101 */ | |
| 102 static int intarrayOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ | |
| 103 int rc = SQLITE_NOMEM; | |
| 104 intarray_cursor *pCur; | |
| 105 pCur = sqlite3_malloc64(sizeof(intarray_cursor)); | |
| 106 if( pCur ){ | |
| 107 memset(pCur, 0, sizeof(intarray_cursor)); | |
| 108 *ppCursor = (sqlite3_vtab_cursor *)pCur; | |
| 109 rc = SQLITE_OK; | |
| 110 } | |
| 111 return rc; | |
| 112 } | |
| 113 | |
| 114 /* | |
| 115 ** Close a intarray table cursor. | |
| 116 */ | |
| 117 static int intarrayClose(sqlite3_vtab_cursor *cur){ | |
| 118 intarray_cursor *pCur = (intarray_cursor *)cur; | |
| 119 sqlite3_free(pCur); | |
| 120 return SQLITE_OK; | |
| 121 } | |
| 122 | |
| 123 /* | |
| 124 ** Retrieve a column of data. | |
| 125 */ | |
| 126 static int intarrayColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i)
{ | |
| 127 intarray_cursor *pCur = (intarray_cursor*)cur; | |
| 128 intarray_vtab *pVtab = (intarray_vtab*)cur->pVtab; | |
| 129 if( pCur->i>=0 && pCur->i<pVtab->pContent->n ){ | |
| 130 sqlite3_result_int64(ctx, pVtab->pContent->a[pCur->i]); | |
| 131 } | |
| 132 return SQLITE_OK; | |
| 133 } | |
| 134 | |
| 135 /* | |
| 136 ** Retrieve the current rowid. | |
| 137 */ | |
| 138 static int intarrayRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ | |
| 139 intarray_cursor *pCur = (intarray_cursor *)cur; | |
| 140 *pRowid = pCur->i; | |
| 141 return SQLITE_OK; | |
| 142 } | |
| 143 | |
| 144 static int intarrayEof(sqlite3_vtab_cursor *cur){ | |
| 145 intarray_cursor *pCur = (intarray_cursor *)cur; | |
| 146 intarray_vtab *pVtab = (intarray_vtab *)cur->pVtab; | |
| 147 return pCur->i>=pVtab->pContent->n; | |
| 148 } | |
| 149 | |
| 150 /* | |
| 151 ** Advance the cursor to the next row. | |
| 152 */ | |
| 153 static int intarrayNext(sqlite3_vtab_cursor *cur){ | |
| 154 intarray_cursor *pCur = (intarray_cursor *)cur; | |
| 155 pCur->i++; | |
| 156 return SQLITE_OK; | |
| 157 } | |
| 158 | |
| 159 /* | |
| 160 ** Reset a intarray table cursor. | |
| 161 */ | |
| 162 static int intarrayFilter( | |
| 163 sqlite3_vtab_cursor *pVtabCursor, | |
| 164 int idxNum, const char *idxStr, | |
| 165 int argc, sqlite3_value **argv | |
| 166 ){ | |
| 167 intarray_cursor *pCur = (intarray_cursor *)pVtabCursor; | |
| 168 pCur->i = 0; | |
| 169 return SQLITE_OK; | |
| 170 } | |
| 171 | |
| 172 /* | |
| 173 ** Analyse the WHERE condition. | |
| 174 */ | |
| 175 static int intarrayBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ | |
| 176 return SQLITE_OK; | |
| 177 } | |
| 178 | |
| 179 /* | |
| 180 ** A virtual table module that merely echos method calls into TCL | |
| 181 ** variables. | |
| 182 */ | |
| 183 static sqlite3_module intarrayModule = { | |
| 184 0, /* iVersion */ | |
| 185 intarrayCreate, /* xCreate - create a new virtual table */ | |
| 186 intarrayCreate, /* xConnect - connect to an existing vtab */ | |
| 187 intarrayBestIndex, /* xBestIndex - find the best query index */ | |
| 188 intarrayDestroy, /* xDisconnect - disconnect a vtab */ | |
| 189 intarrayDestroy, /* xDestroy - destroy a vtab */ | |
| 190 intarrayOpen, /* xOpen - open a cursor */ | |
| 191 intarrayClose, /* xClose - close a cursor */ | |
| 192 intarrayFilter, /* xFilter - configure scan constraints */ | |
| 193 intarrayNext, /* xNext - advance a cursor */ | |
| 194 intarrayEof, /* xEof */ | |
| 195 intarrayColumn, /* xColumn - read data */ | |
| 196 intarrayRowid, /* xRowid - read data */ | |
| 197 0, /* xUpdate */ | |
| 198 0, /* xBegin */ | |
| 199 0, /* xSync */ | |
| 200 0, /* xCommit */ | |
| 201 0, /* xRollback */ | |
| 202 0, /* xFindMethod */ | |
| 203 0, /* xRename */ | |
| 204 }; | |
| 205 | |
| 206 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */ | |
| 207 | |
| 208 /* | |
| 209 ** Invoke this routine to create a specific instance of an intarray object. | |
| 210 ** The new intarray object is returned by the 3rd parameter. | |
| 211 ** | |
| 212 ** Each intarray object corresponds to a virtual table in the TEMP table | |
| 213 ** with a name of zName. | |
| 214 ** | |
| 215 ** Destroy the intarray object by dropping the virtual table. If not done | |
| 216 ** explicitly by the application, the virtual table will be dropped implicitly | |
| 217 ** by the system when the database connection is closed. | |
| 218 */ | |
| 219 SQLITE_API int sqlite3_intarray_create( | |
| 220 sqlite3 *db, | |
| 221 const char *zName, | |
| 222 sqlite3_intarray **ppReturn | |
| 223 ){ | |
| 224 int rc = SQLITE_OK; | |
| 225 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 226 sqlite3_intarray *p; | |
| 227 | |
| 228 *ppReturn = p = sqlite3_malloc64( sizeof(*p) ); | |
| 229 if( p==0 ){ | |
| 230 return SQLITE_NOMEM; | |
| 231 } | |
| 232 memset(p, 0, sizeof(*p)); | |
| 233 rc = sqlite3_create_module_v2(db, zName, &intarrayModule, p, | |
| 234 (void(*)(void*))intarrayFree); | |
| 235 if( rc==SQLITE_OK ){ | |
| 236 char *zSql; | |
| 237 zSql = sqlite3_mprintf("CREATE VIRTUAL TABLE temp.%Q USING %Q", | |
| 238 zName, zName); | |
| 239 rc = sqlite3_exec(db, zSql, 0, 0, 0); | |
| 240 sqlite3_free(zSql); | |
| 241 } | |
| 242 #endif | |
| 243 return rc; | |
| 244 } | |
| 245 | |
| 246 /* | |
| 247 ** Bind a new array array of integers to a specific intarray object. | |
| 248 ** | |
| 249 ** The array of integers bound must be unchanged for the duration of | |
| 250 ** any query against the corresponding virtual table. If the integer | |
| 251 ** array does change or is deallocated undefined behavior will result. | |
| 252 */ | |
| 253 SQLITE_API int sqlite3_intarray_bind( | |
| 254 sqlite3_intarray *pIntArray, /* The intarray object to bind to */ | |
| 255 int nElements, /* Number of elements in the intarray */ | |
| 256 sqlite3_int64 *aElements, /* Content of the intarray */ | |
| 257 void (*xFree)(void*) /* How to dispose of the intarray when done */ | |
| 258 ){ | |
| 259 if( pIntArray->xFree ){ | |
| 260 pIntArray->xFree(pIntArray->a); | |
| 261 } | |
| 262 pIntArray->n = nElements; | |
| 263 pIntArray->a = aElements; | |
| 264 pIntArray->xFree = xFree; | |
| 265 return SQLITE_OK; | |
| 266 } | |
| 267 | |
| 268 | |
| 269 /***************************************************************************** | |
| 270 ** Everything below is interface for testing this module. | |
| 271 */ | |
| 272 #ifdef SQLITE_TEST | |
| 273 #include <tcl.h> | |
| 274 | |
| 275 /* | |
| 276 ** Routines to encode and decode pointers | |
| 277 */ | |
| 278 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb); | |
| 279 extern void *sqlite3TestTextToPtr(const char*); | |
| 280 extern int sqlite3TestMakePointerStr(Tcl_Interp*, char *zPtr, void*); | |
| 281 extern const char *sqlite3ErrName(int); | |
| 282 | |
| 283 /* | |
| 284 ** sqlite3_intarray_create DB NAME | |
| 285 ** | |
| 286 ** Invoke the sqlite3_intarray_create interface. A string that becomes | |
| 287 ** the first parameter to sqlite3_intarray_bind. | |
| 288 */ | |
| 289 static int test_intarray_create( | |
| 290 ClientData clientData, /* Not used */ | |
| 291 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ | |
| 292 int objc, /* Number of arguments */ | |
| 293 Tcl_Obj *CONST objv[] /* Command arguments */ | |
| 294 ){ | |
| 295 sqlite3 *db; | |
| 296 const char *zName; | |
| 297 sqlite3_intarray *pArray; | |
| 298 int rc = SQLITE_OK; | |
| 299 char zPtr[100]; | |
| 300 | |
| 301 if( objc!=3 ){ | |
| 302 Tcl_WrongNumArgs(interp, 1, objv, "DB"); | |
| 303 return TCL_ERROR; | |
| 304 } | |
| 305 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; | |
| 306 zName = Tcl_GetString(objv[2]); | |
| 307 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 308 rc = sqlite3_intarray_create(db, zName, &pArray); | |
| 309 #endif | |
| 310 if( rc!=SQLITE_OK ){ | |
| 311 assert( pArray==0 ); | |
| 312 Tcl_AppendResult(interp, sqlite3ErrName(rc), (char*)0); | |
| 313 return TCL_ERROR; | |
| 314 } | |
| 315 sqlite3TestMakePointerStr(interp, zPtr, pArray); | |
| 316 Tcl_AppendResult(interp, zPtr, (char*)0); | |
| 317 return TCL_OK; | |
| 318 } | |
| 319 | |
| 320 /* | |
| 321 ** sqlite3_intarray_bind INTARRAY ?VALUE ...? | |
| 322 ** | |
| 323 ** Invoke the sqlite3_intarray_bind interface on the given array of integers. | |
| 324 */ | |
| 325 static int test_intarray_bind( | |
| 326 ClientData clientData, /* Not used */ | |
| 327 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ | |
| 328 int objc, /* Number of arguments */ | |
| 329 Tcl_Obj *CONST objv[] /* Command arguments */ | |
| 330 ){ | |
| 331 sqlite3_intarray *pArray; | |
| 332 int rc = SQLITE_OK; | |
| 333 int i, n; | |
| 334 sqlite3_int64 *a; | |
| 335 | |
| 336 if( objc<2 ){ | |
| 337 Tcl_WrongNumArgs(interp, 1, objv, "INTARRAY"); | |
| 338 return TCL_ERROR; | |
| 339 } | |
| 340 pArray = (sqlite3_intarray*)sqlite3TestTextToPtr(Tcl_GetString(objv[1])); | |
| 341 n = objc - 2; | |
| 342 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 343 a = sqlite3_malloc64( sizeof(a[0])*n ); | |
| 344 if( a==0 ){ | |
| 345 Tcl_AppendResult(interp, "SQLITE_NOMEM", (char*)0); | |
| 346 return TCL_ERROR; | |
| 347 } | |
| 348 for(i=0; i<n; i++){ | |
| 349 Tcl_WideInt x = 0; | |
| 350 Tcl_GetWideIntFromObj(0, objv[i+2], &x); | |
| 351 a[i] = x; | |
| 352 } | |
| 353 rc = sqlite3_intarray_bind(pArray, n, a, sqlite3_free); | |
| 354 if( rc!=SQLITE_OK ){ | |
| 355 Tcl_AppendResult(interp, sqlite3ErrName(rc), (char*)0); | |
| 356 return TCL_ERROR; | |
| 357 } | |
| 358 #endif | |
| 359 return TCL_OK; | |
| 360 } | |
| 361 | |
| 362 /* | |
| 363 ** Register commands with the TCL interpreter. | |
| 364 */ | |
| 365 int Sqlitetestintarray_Init(Tcl_Interp *interp){ | |
| 366 static struct { | |
| 367 char *zName; | |
| 368 Tcl_ObjCmdProc *xProc; | |
| 369 void *clientData; | |
| 370 } aObjCmd[] = { | |
| 371 { "sqlite3_intarray_create", test_intarray_create, 0 }, | |
| 372 { "sqlite3_intarray_bind", test_intarray_bind, 0 }, | |
| 373 }; | |
| 374 int i; | |
| 375 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ | |
| 376 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, | |
| 377 aObjCmd[i].xProc, aObjCmd[i].clientData, 0); | |
| 378 } | |
| 379 return TCL_OK; | |
| 380 } | |
| 381 | |
| 382 #endif /* SQLITE_TEST */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
