static int
sqlite3VirtualTextInit (sqlite3 * db)
{
int rc = SQLITE_OK;
virtualtext_module.iVersion = 1;
virtualtext_module.xCreate = &vtxt_create;
virtualtext_module.xConnect = &vtxt_connect;
virtualtext_module.xBestIndex = &vtxt_best_index;
virtualtext_module.xDisconnect = &vtxt_disconnect;
virtualtext_module.xDestroy = &vtxt_destroy;
virtualtext_module.xOpen = &vtxt_open;
virtualtext_module.xClose = &vtxt_close;
virtualtext_module.xFilter = &vtxt_filter;
virtualtext_module.xNext = &vtxt_next;
virtualtext_module.xEof = &vtxt_eof;
virtualtext_module.xColumn = &vtxt_column;
virtualtext_module.xRowid = &vtxt_rowid;
virtualtext_module.xUpdate = &vtxt_update;
virtualtext_module.xBegin = &vtxt_begin;
virtualtext_module.xSync = &vtxt_sync;
virtualtext_module.xCommit = &vtxt_commit;
virtualtext_module.xRollback = &vtxt_rollback;
virtualtext_module.xFindFunction = NULL;
sqlite3_create_module_v2 (db, "VirtualText", &virtualtext_module, NULL, 0);
return rc;
}
static int
spliteVirtualXPathInit (sqlite3 * db, void *p_cache)
{
int rc = SQLITE_OK;
my_xpath_module.iVersion = 1;
my_xpath_module.xCreate = &vxpath_create;
my_xpath_module.xConnect = &vxpath_connect;
my_xpath_module.xBestIndex = &vxpath_best_index;
my_xpath_module.xDisconnect = &vxpath_disconnect;
my_xpath_module.xDestroy = &vxpath_destroy;
my_xpath_module.xOpen = &vxpath_open;
my_xpath_module.xClose = &vxpath_close;
my_xpath_module.xFilter = &vxpath_filter;
my_xpath_module.xNext = &vxpath_next;
my_xpath_module.xEof = &vxpath_eof;
my_xpath_module.xColumn = &vxpath_column;
my_xpath_module.xRowid = &vxpath_rowid;
my_xpath_module.xUpdate = &vxpath_update;
my_xpath_module.xBegin = &vxpath_begin;
my_xpath_module.xSync = &vxpath_sync;
my_xpath_module.xCommit = &vxpath_commit;
my_xpath_module.xRollback = &vxpath_rollback;
my_xpath_module.xFindFunction = NULL;
my_xpath_module.xRename = &vxpath_rename;
sqlite3_create_module_v2 (db, "VirtualXPath", &my_xpath_module, p_cache, 0);
return rc;
}
void vjs(sqlite3 *db) {
char *e;
int rc = sqlite3_create_module_v2(db, "vjs", &module, NULL, destructor);
rc = sqlite3_exec(db, "DROP TABLE javascript", NULL, NULL, &e);
rc = sqlite3_exec(db, "CREATE VIRTUAL TABLE javascript USING vjs", NULL, NULL, &e);
return;
}
int
sqlite3VirtualSpatialIndexInit (sqlite3 * db)
{
int rc = SQLITE_OK;
my_spidx_module.iVersion = 1;
my_spidx_module.xCreate = &vspidx_create;
my_spidx_module.xConnect = &vspidx_connect;
my_spidx_module.xBestIndex = &vspidx_best_index;
my_spidx_module.xDisconnect = &vspidx_disconnect;
my_spidx_module.xDestroy = &vspidx_destroy;
my_spidx_module.xOpen = &vspidx_open;
my_spidx_module.xClose = &vspidx_close;
my_spidx_module.xFilter = &vspidx_filter;
my_spidx_module.xNext = &vspidx_next;
my_spidx_module.xEof = &vspidx_eof;
my_spidx_module.xColumn = &vspidx_column;
my_spidx_module.xRowid = &vspidx_rowid;
my_spidx_module.xUpdate = &vspidx_update;
my_spidx_module.xBegin = &vspidx_begin;
my_spidx_module.xSync = &vspidx_sync;
my_spidx_module.xCommit = &vspidx_commit;
my_spidx_module.xRollback = &vspidx_rollback;
my_spidx_module.xFindFunction = NULL;
sqlite3_create_module_v2 (db, "VirtualSpatialIndex", &my_spidx_module, NULL,
0);
return rc;
}
/*
** 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.
*/
SQLITE_API int sqlite3_intarray_create(
sqlite3 *db,
const char *zName,
sqlite3_intarray **ppReturn
){
int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_VIRTUALTABLE
sqlite3_intarray *p;
*ppReturn = p = sqlite3_malloc64( 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);
}
#endif
return rc;
}
static int
spliteKnnInit (sqlite3 * db)
{
int rc = SQLITE_OK;
my_knn_module.iVersion = 1;
my_knn_module.xCreate = &vknn_create;
my_knn_module.xConnect = &vknn_connect;
my_knn_module.xBestIndex = &vknn_best_index;
my_knn_module.xDisconnect = &vknn_disconnect;
my_knn_module.xDestroy = &vknn_destroy;
my_knn_module.xOpen = &vknn_open;
my_knn_module.xClose = &vknn_close;
my_knn_module.xFilter = &vknn_filter;
my_knn_module.xNext = &vknn_next;
my_knn_module.xEof = &vknn_eof;
my_knn_module.xColumn = &vknn_column;
my_knn_module.xRowid = &vknn_rowid;
my_knn_module.xUpdate = &vknn_update;
my_knn_module.xBegin = &vknn_begin;
my_knn_module.xSync = &vknn_sync;
my_knn_module.xCommit = &vknn_commit;
my_knn_module.xRollback = &vknn_rollback;
my_knn_module.xFindFunction = NULL;
my_knn_module.xRename = &vknn_rename;
sqlite3_create_module_v2 (db, "VirtualKNN", &my_knn_module, NULL, 0);
return rc;
}
/*
** Register the CSV module with database handle db. This creates the
** virtual table module "csv".
*/
int sqlite3CsvInit(sqlite3 *db){
int rc = SQLITE_OK;
if( rc==SQLITE_OK ){
void *c = (void *)NULL;
rc = sqlite3_create_module_v2(db, "csv", &csvModule, c, 0);
}
return rc;
}
/* attach_connection DBCONN */
static int AttachConnectionObjCmd(void *clientdata,
Tcl_Interp *interp,
int objc,
Tcl_Obj * const *objv)
{
VTableInterpContext *vticP = (VTableInterpContext *)clientdata;
VTableDB *vtdbP;
sqlite3 *sqliteP;
int new_entry;
if (objc != 2) {
Tcl_WrongNumArgs(interp, 1, objv, " DBCONN");
return TCL_ERROR;
}
/* Map the db connection command to the connection pointer */
if (GetSqliteConnPtr(interp, Tcl_GetString(objv[1]), &sqliteP) != TCL_OK)
return TCL_ERROR;
/* Check if already registered the virtual table module for this conn. */
if (Tcl_FindHashEntry(&vticP->dbconns, sqliteP) != NULL)
return TCL_OK;
/* Need to register for this db conn */
vtdbP = VTDBNew();
Tcl_IncrRefCount(objv[1]);
vtdbP->dbcmd_objP = objv[1];
/* Find out the NULL value representation this DB is using */
if (InitNullValueForDB(interp, vtdbP)) {
VTDBUnref(vtdbP, 1);
return TCL_ERROR;
}
if (sqlite3_create_module_v2(sqliteP, PACKAGE_NAME, &sqlite_vtable_methods,
vtdbP, VTDBDetachSqliteCallback)
!= SQLITE_OK) {
VTDBUnref(vtdbP, 1);
return ReturnSqliteError(interp, sqliteP, NULL);
}
/* Now add to the table of connections for this interpreter */
Tcl_SetHashValue(Tcl_CreateHashEntry(&vticP->dbconns, sqliteP, &new_entry),
vtdbP);
/* Link up various structures */
vtdbP->sqliteP = sqliteP;
vtdbP->vticP = vticP;
VTICRef(vticP, 1); /* Since dbP refers to it. TBD - circular dependency? */
VTDBRef(vtdbP, 2); /* Hash table ref + ref from sqlite */
return TCL_OK;
}
int sqlite3_intarray_register(sqlite3 *db, sqlite3_intarray_module **ppReturn) {
int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_VIRTUALTABLE
sqlite3_intarray_module *p;
p = (sqlite3_intarray_module*)sqlite3_malloc(sizeof(*p));
if (!p) return SQLITE_NOMEM;
p->db = db;
rc = intarrayMapInit(&p->arrayMap);
if (rc != SQLITE_OK) return rc;
rc = sqlite3_create_module_v2(db, MODULE_NAME, &intarrayModule, p, sqlite3_module_free);
if (rc == SQLITE_OK) {
*ppReturn = p;
}
#endif
return rc;
}
int fs_create_module(sqlite3 *db, const char *path)
{
char *root = sqlite3_mprintf("%s", path);
return sqlite3_create_module_v2(db, "sqlitefs", &fs_module, root, sqlite3_free);
}
int recoverVtableInit(sqlite3 *db){
return sqlite3_create_module_v2(db, "recover", &recoverModule, NULL, 0);
}
