Annotation of embedaddon/sqlite3/src/test_schema.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2006 June 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: ** Code for testing the virtual table interfaces. This code
! 13: ** is not included in the SQLite library. It is used for automated
! 14: ** testing of the SQLite library.
! 15: */
! 16:
! 17: /* The code in this file defines a sqlite3 virtual-table module that
! 18: ** provides a read-only view of the current database schema. There is one
! 19: ** row in the schema table for each column in the database schema.
! 20: */
! 21: #define SCHEMA \
! 22: "CREATE TABLE x(" \
! 23: "database," /* Name of database (i.e. main, temp etc.) */ \
! 24: "tablename," /* Name of table */ \
! 25: "cid," /* Column number (from left-to-right, 0 upward) */ \
! 26: "name," /* Column name */ \
! 27: "type," /* Specified type (i.e. VARCHAR(32)) */ \
! 28: "not_null," /* Boolean. True if NOT NULL was specified */ \
! 29: "dflt_value," /* Default value for this column */ \
! 30: "pk" /* True if this column is part of the primary key */ \
! 31: ")"
! 32:
! 33: /* If SQLITE_TEST is defined this code is preprocessed for use as part
! 34: ** of the sqlite test binary "testfixture". Otherwise it is preprocessed
! 35: ** to be compiled into an sqlite dynamic extension.
! 36: */
! 37: #ifdef SQLITE_TEST
! 38: #include "sqliteInt.h"
! 39: #include "tcl.h"
! 40: #else
! 41: #include "sqlite3ext.h"
! 42: SQLITE_EXTENSION_INIT1
! 43: #endif
! 44:
! 45: #include <stdlib.h>
! 46: #include <string.h>
! 47: #include <assert.h>
! 48:
! 49: typedef struct schema_vtab schema_vtab;
! 50: typedef struct schema_cursor schema_cursor;
! 51:
! 52: /* A schema table object */
! 53: struct schema_vtab {
! 54: sqlite3_vtab base;
! 55: sqlite3 *db;
! 56: };
! 57:
! 58: /* A schema table cursor object */
! 59: struct schema_cursor {
! 60: sqlite3_vtab_cursor base;
! 61: sqlite3_stmt *pDbList;
! 62: sqlite3_stmt *pTableList;
! 63: sqlite3_stmt *pColumnList;
! 64: int rowid;
! 65: };
! 66:
! 67: /*
! 68: ** None of this works unless we have virtual tables.
! 69: */
! 70: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 71:
! 72: /*
! 73: ** Table destructor for the schema module.
! 74: */
! 75: static int schemaDestroy(sqlite3_vtab *pVtab){
! 76: sqlite3_free(pVtab);
! 77: return 0;
! 78: }
! 79:
! 80: /*
! 81: ** Table constructor for the schema module.
! 82: */
! 83: static int schemaCreate(
! 84: sqlite3 *db,
! 85: void *pAux,
! 86: int argc, const char *const*argv,
! 87: sqlite3_vtab **ppVtab,
! 88: char **pzErr
! 89: ){
! 90: int rc = SQLITE_NOMEM;
! 91: schema_vtab *pVtab = sqlite3_malloc(sizeof(schema_vtab));
! 92: if( pVtab ){
! 93: memset(pVtab, 0, sizeof(schema_vtab));
! 94: pVtab->db = db;
! 95: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 96: rc = sqlite3_declare_vtab(db, SCHEMA);
! 97: #endif
! 98: }
! 99: *ppVtab = (sqlite3_vtab *)pVtab;
! 100: return rc;
! 101: }
! 102:
! 103: /*
! 104: ** Open a new cursor on the schema table.
! 105: */
! 106: static int schemaOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
! 107: int rc = SQLITE_NOMEM;
! 108: schema_cursor *pCur;
! 109: pCur = sqlite3_malloc(sizeof(schema_cursor));
! 110: if( pCur ){
! 111: memset(pCur, 0, sizeof(schema_cursor));
! 112: *ppCursor = (sqlite3_vtab_cursor *)pCur;
! 113: rc = SQLITE_OK;
! 114: }
! 115: return rc;
! 116: }
! 117:
! 118: /*
! 119: ** Close a schema table cursor.
! 120: */
! 121: static int schemaClose(sqlite3_vtab_cursor *cur){
! 122: schema_cursor *pCur = (schema_cursor *)cur;
! 123: sqlite3_finalize(pCur->pDbList);
! 124: sqlite3_finalize(pCur->pTableList);
! 125: sqlite3_finalize(pCur->pColumnList);
! 126: sqlite3_free(pCur);
! 127: return SQLITE_OK;
! 128: }
! 129:
! 130: /*
! 131: ** Retrieve a column of data.
! 132: */
! 133: static int schemaColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
! 134: schema_cursor *pCur = (schema_cursor *)cur;
! 135: switch( i ){
! 136: case 0:
! 137: sqlite3_result_value(ctx, sqlite3_column_value(pCur->pDbList, 1));
! 138: break;
! 139: case 1:
! 140: sqlite3_result_value(ctx, sqlite3_column_value(pCur->pTableList, 0));
! 141: break;
! 142: default:
! 143: sqlite3_result_value(ctx, sqlite3_column_value(pCur->pColumnList, i-2));
! 144: break;
! 145: }
! 146: return SQLITE_OK;
! 147: }
! 148:
! 149: /*
! 150: ** Retrieve the current rowid.
! 151: */
! 152: static int schemaRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
! 153: schema_cursor *pCur = (schema_cursor *)cur;
! 154: *pRowid = pCur->rowid;
! 155: return SQLITE_OK;
! 156: }
! 157:
! 158: static int finalize(sqlite3_stmt **ppStmt){
! 159: int rc = sqlite3_finalize(*ppStmt);
! 160: *ppStmt = 0;
! 161: return rc;
! 162: }
! 163:
! 164: static int schemaEof(sqlite3_vtab_cursor *cur){
! 165: schema_cursor *pCur = (schema_cursor *)cur;
! 166: return (pCur->pDbList ? 0 : 1);
! 167: }
! 168:
! 169: /*
! 170: ** Advance the cursor to the next row.
! 171: */
! 172: static int schemaNext(sqlite3_vtab_cursor *cur){
! 173: int rc = SQLITE_OK;
! 174: schema_cursor *pCur = (schema_cursor *)cur;
! 175: schema_vtab *pVtab = (schema_vtab *)(cur->pVtab);
! 176: char *zSql = 0;
! 177:
! 178: while( !pCur->pColumnList || SQLITE_ROW!=sqlite3_step(pCur->pColumnList) ){
! 179: if( SQLITE_OK!=(rc = finalize(&pCur->pColumnList)) ) goto next_exit;
! 180:
! 181: while( !pCur->pTableList || SQLITE_ROW!=sqlite3_step(pCur->pTableList) ){
! 182: if( SQLITE_OK!=(rc = finalize(&pCur->pTableList)) ) goto next_exit;
! 183:
! 184: assert(pCur->pDbList);
! 185: while( SQLITE_ROW!=sqlite3_step(pCur->pDbList) ){
! 186: rc = finalize(&pCur->pDbList);
! 187: goto next_exit;
! 188: }
! 189:
! 190: /* Set zSql to the SQL to pull the list of tables from the
! 191: ** sqlite_master (or sqlite_temp_master) table of the database
! 192: ** identfied by the row pointed to by the SQL statement pCur->pDbList
! 193: ** (iterating through a "PRAGMA database_list;" statement).
! 194: */
! 195: if( sqlite3_column_int(pCur->pDbList, 0)==1 ){
! 196: zSql = sqlite3_mprintf(
! 197: "SELECT name FROM sqlite_temp_master WHERE type='table'"
! 198: );
! 199: }else{
! 200: sqlite3_stmt *pDbList = pCur->pDbList;
! 201: zSql = sqlite3_mprintf(
! 202: "SELECT name FROM %Q.sqlite_master WHERE type='table'",
! 203: sqlite3_column_text(pDbList, 1)
! 204: );
! 205: }
! 206: if( !zSql ){
! 207: rc = SQLITE_NOMEM;
! 208: goto next_exit;
! 209: }
! 210:
! 211: rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pTableList, 0);
! 212: sqlite3_free(zSql);
! 213: if( rc!=SQLITE_OK ) goto next_exit;
! 214: }
! 215:
! 216: /* Set zSql to the SQL to the table_info pragma for the table currently
! 217: ** identified by the rows pointed to by statements pCur->pDbList and
! 218: ** pCur->pTableList.
! 219: */
! 220: zSql = sqlite3_mprintf("PRAGMA %Q.table_info(%Q)",
! 221: sqlite3_column_text(pCur->pDbList, 1),
! 222: sqlite3_column_text(pCur->pTableList, 0)
! 223: );
! 224:
! 225: if( !zSql ){
! 226: rc = SQLITE_NOMEM;
! 227: goto next_exit;
! 228: }
! 229: rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pColumnList, 0);
! 230: sqlite3_free(zSql);
! 231: if( rc!=SQLITE_OK ) goto next_exit;
! 232: }
! 233: pCur->rowid++;
! 234:
! 235: next_exit:
! 236: /* TODO: Handle rc */
! 237: return rc;
! 238: }
! 239:
! 240: /*
! 241: ** Reset a schema table cursor.
! 242: */
! 243: static int schemaFilter(
! 244: sqlite3_vtab_cursor *pVtabCursor,
! 245: int idxNum, const char *idxStr,
! 246: int argc, sqlite3_value **argv
! 247: ){
! 248: int rc;
! 249: schema_vtab *pVtab = (schema_vtab *)(pVtabCursor->pVtab);
! 250: schema_cursor *pCur = (schema_cursor *)pVtabCursor;
! 251: pCur->rowid = 0;
! 252: finalize(&pCur->pTableList);
! 253: finalize(&pCur->pColumnList);
! 254: finalize(&pCur->pDbList);
! 255: rc = sqlite3_prepare(pVtab->db,"PRAGMA database_list", -1, &pCur->pDbList, 0);
! 256: return (rc==SQLITE_OK ? schemaNext(pVtabCursor) : rc);
! 257: }
! 258:
! 259: /*
! 260: ** Analyse the WHERE condition.
! 261: */
! 262: static int schemaBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
! 263: return SQLITE_OK;
! 264: }
! 265:
! 266: /*
! 267: ** A virtual table module that merely echos method calls into TCL
! 268: ** variables.
! 269: */
! 270: static sqlite3_module schemaModule = {
! 271: 0, /* iVersion */
! 272: schemaCreate,
! 273: schemaCreate,
! 274: schemaBestIndex,
! 275: schemaDestroy,
! 276: schemaDestroy,
! 277: schemaOpen, /* xOpen - open a cursor */
! 278: schemaClose, /* xClose - close a cursor */
! 279: schemaFilter, /* xFilter - configure scan constraints */
! 280: schemaNext, /* xNext - advance a cursor */
! 281: schemaEof, /* xEof */
! 282: schemaColumn, /* xColumn - read data */
! 283: schemaRowid, /* xRowid - read data */
! 284: 0, /* xUpdate */
! 285: 0, /* xBegin */
! 286: 0, /* xSync */
! 287: 0, /* xCommit */
! 288: 0, /* xRollback */
! 289: 0, /* xFindMethod */
! 290: 0, /* xRename */
! 291: };
! 292:
! 293: #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */
! 294:
! 295: #ifdef SQLITE_TEST
! 296:
! 297: /*
! 298: ** Decode a pointer to an sqlite3 object.
! 299: */
! 300: extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
! 301:
! 302: /*
! 303: ** Register the schema virtual table module.
! 304: */
! 305: static int register_schema_module(
! 306: ClientData clientData, /* Not used */
! 307: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 308: int objc, /* Number of arguments */
! 309: Tcl_Obj *CONST objv[] /* Command arguments */
! 310: ){
! 311: sqlite3 *db;
! 312: if( objc!=2 ){
! 313: Tcl_WrongNumArgs(interp, 1, objv, "DB");
! 314: return TCL_ERROR;
! 315: }
! 316: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 317: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 318: sqlite3_create_module(db, "schema", &schemaModule, 0);
! 319: #endif
! 320: return TCL_OK;
! 321: }
! 322:
! 323: /*
! 324: ** Register commands with the TCL interpreter.
! 325: */
! 326: int Sqlitetestschema_Init(Tcl_Interp *interp){
! 327: static struct {
! 328: char *zName;
! 329: Tcl_ObjCmdProc *xProc;
! 330: void *clientData;
! 331: } aObjCmd[] = {
! 332: { "register_schema_module", register_schema_module, 0 },
! 333: };
! 334: int i;
! 335: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
! 336: Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
! 337: aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
! 338: }
! 339: return TCL_OK;
! 340: }
! 341:
! 342: #else
! 343:
! 344: /*
! 345: ** Extension load function.
! 346: */
! 347: int sqlite3_extension_init(
! 348: sqlite3 *db,
! 349: char **pzErrMsg,
! 350: const sqlite3_api_routines *pApi
! 351: ){
! 352: SQLITE_EXTENSION_INIT2(pApi);
! 353: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 354: sqlite3_create_module(db, "schema", &schemaModule, 0);
! 355: #endif
! 356: return 0;
! 357: }
! 358:
! 359: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_schema.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src