/*
** Connect to or create a dbpagevfs virtual table.
*/
static int dbpageConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
DbpageTable *pTab = 0;
int rc = SQLITE_OK;
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(pgno INTEGER PRIMARY KEY, data BLOB, schema HIDDEN)");
if( rc==SQLITE_OK ){
pTab = (DbpageTable *)sqlite3_malloc64(sizeof(DbpageTable));
if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
}
assert( rc==SQLITE_OK || pTab==0 );
if( rc==SQLITE_OK ){
memset(pTab, 0, sizeof(DbpageTable));
pTab->db = db;
}
*ppVtab = (sqlite3_vtab*)pTab;
return rc;
}
/*
** Table constructor for the intarray module.
*/
static int intarrayCreate(sqlite3 *db, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVtab, char **pzErr) {
int rc = SQLITE_NOMEM;
sqlite3_intarray_module *module = *((sqlite3_intarray_module**)&pAux);
intarray_vtab *table;
sqlite3_intarray *a;
if (!module || argc < 3) return INTARRAY_INTERNAL_ERROR;
a = intarrayMapFind(&module->arrayMap, argv[2]);
if (!a) {
*pzErr = sqlite3_mprintf("intarray %s is not created", argv[2]);
return SQLITE_ERROR;
}
table = (intarray_vtab*)sqlite3_malloc(sizeof(intarray_vtab));
if (!table) return rc;
rc = sqlite3_declare_vtab(db, "CREATE TABLE x(value INTEGER)");
if (rc != SQLITE_OK) {
sqlite3_free(table);
return rc;
}
memset(table, 0, sizeof(intarray_vtab));
table->intarray = a;
a->connectCount++;
*ppVtab = (sqlite3_vtab *)table;
return rc;
}
/*
** The explainConnect() method is invoked to create a new
** explain_vtab that describes the explain virtual table.
**
** Think of this routine as the constructor for explain_vtab objects.
**
** All this routine needs to do is:
**
** (1) Allocate the explain_vtab object and initialize all fields.
**
** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
** result set of queries against explain will look like.
*/
static int explainConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
explain_vtab *pNew;
int rc;
/* Column numbers */
#define EXPLN_COLUMN_ADDR 0 /* Instruction address */
#define EXPLN_COLUMN_OPCODE 1 /* Opcode */
#define EXPLN_COLUMN_P1 2 /* Operand 1 */
#define EXPLN_COLUMN_P2 3 /* Operand 2 */
#define EXPLN_COLUMN_P3 4 /* Operand 3 */
#define EXPLN_COLUMN_P4 5 /* Operand 4 */
#define EXPLN_COLUMN_P5 6 /* Operand 5 */
#define EXPLN_COLUMN_COMMENT 7 /* Comment */
#define EXPLN_COLUMN_SQL 8 /* SQL that is being explained */
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(addr,opcode,p1,p2,p3,p4,p5,comment,sql HIDDEN)");
if( rc==SQLITE_OK ){
pNew = sqlite3_malloc( sizeof(*pNew) );
*ppVtab = (sqlite3_vtab*)pNew;
if( pNew==0 ) return SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
pNew->db = db;
}
return rc;
}
static int vt_create( sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **pp_vt,
char **pzErr )
{
int rc = SQLITE_OK;
vtab* p_vt;
/* Allocate the sqlite3_vtab/vtab structure itself */
p_vt = (vtab*)sqlite3_malloc(sizeof(*p_vt));
if (p_vt == NULL)
{
return SQLITE_NOMEM;
}
p_vt->db = db;
apr_pool_create(&p_vt->pool, NULL);
/* Declare the vtable's structure */
rc = sqlite3_declare_vtab(db, ddl);
/* Success. Set *pp_vt and return */
*pp_vt = &p_vt->base;
return SQLITE_OK;
}
/*
** The memstatConnect() method is invoked to create a new
** memstat_vtab that describes the memstat virtual table.
**
** Think of this routine as the constructor for memstat_vtab objects.
**
** All this routine needs to do is:
**
** (1) Allocate the memstat_vtab object and initialize all fields.
**
** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
** result set of queries against memstat will look like.
*/
static int memstatConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
memstat_vtab *pNew;
int rc;
/* Column numbers */
#define MSV_COLUMN_NAME 0 /* Name of quantity being measured */
#define MSV_COLUMN_SCHEMA 1 /* schema name */
#define MSV_COLUMN_VALUE 2 /* Current value */
#define MSV_COLUMN_HIWTR 3 /* Highwater mark */
rc = sqlite3_declare_vtab(db,"CREATE TABLE x(name,schema,value,hiwtr)");
if( rc==SQLITE_OK ){
pNew = sqlite3_malloc( sizeof(*pNew) );
*ppVtab = (sqlite3_vtab*)pNew;
if( pNew==0 ) return SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
pNew->db = db;
}
return rc;
}
static int weblog_connect( sqlite3 *db, void *udp, int argc,
const char *const *argv, sqlite3_vtab **vtab, char **errmsg )
{
weblog_vtab *v = NULL;
const char *filename = argv[3];
FILE *ftest;
if ( argc != 4 ) return SQLITE_ERROR;
*vtab = NULL;
*errmsg = NULL;
/* test to see if filename is valid */
ftest = fopen( filename, "r" );
if ( ftest == NULL ) return SQLITE_ERROR;
fclose( ftest );
/* alloccate structure and set data */
v = sqlite3_malloc( sizeof( weblog_vtab ) );
if ( v == NULL ) return SQLITE_NOMEM;
((sqlite3_vtab*)v)->zErrMsg = NULL; /* need to init this */
v->filename = sqlite3_mprintf( "%s", filename );
if ( v->filename == NULL ) {
sqlite3_free( v );
return SQLITE_NOMEM;
}
v->db = db;
sqlite3_declare_vtab( db, weblog_sql );
*vtab = (sqlite3_vtab*)v;
return SQLITE_OK;
}
/*
** This function does all the work for both the xConnect and xCreate methods.
** These tables have no persistent representation of their own, so xConnect
** and xCreate are identical operations.
**
** argv[0]: module name
** argv[1]: database name
** argv[2]: table name
** argv[3]: first argument (tokenizer name)
*/
static int fts3tokConnectMethod(
sqlite3 *db, /* Database connection */
void *pHash, /* Hash table of tokenizers */
int argc, /* Number of elements in argv array */
const char * const *argv, /* xCreate/xConnect argument array */
sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
char **pzErr /* OUT: sqlite3_malloc'd error message */
){
Fts3tokTable *pTab;
const sqlite3_tokenizer_module *pMod = 0;
sqlite3_tokenizer *pTok = 0;
int rc;
char **azDequote = 0;
int nDequote;
rc = sqlite3_declare_vtab(db, FTS3_TOK_SCHEMA);
if( rc!=SQLITE_OK ) return rc;
nDequote = argc-3;
rc = fts3tokDequoteArray(nDequote, &argv[3], &azDequote);
if( rc==SQLITE_OK ){
const char *zModule;
if( nDequote<1 ){
zModule = "simple";
}else{
zModule = azDequote[0];
}
rc = fts3tokQueryTokenizer((Fts3Hash*)pHash, zModule, &pMod, pzErr);
}
assert( (rc==SQLITE_OK)==(pMod!=0) );
if( rc==SQLITE_OK ){
const char * const *azArg = (const char * const *)&azDequote[1];
rc = pMod->xCreate((nDequote>1 ? nDequote-1 : 0), azArg, &pTok);
}
if( rc==SQLITE_OK ){
pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable));
if( pTab==0 ){
rc = SQLITE_NOMEM;
}
}
if( rc==SQLITE_OK ){
memset(pTab, 0, sizeof(Fts3tokTable));
pTab->pMod = pMod;
pTab->pTok = pTok;
*ppVtab = &pTab->base;
}else{
if( pTok ){
pMod->xDestroy(pTok);
}
}
sqlite3_free(azDequote);
return rc;
}
/*
** The vtablogConnect() method is invoked to create a new
** vtablog_vtab that describes the vtablog virtual table.
**
** Think of this routine as the constructor for vtablog_vtab objects.
**
** All this routine needs to do is:
**
** (1) Allocate the vtablog_vtab object and initialize all fields.
**
** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
** result set of queries against vtablog will look like.
*/
static int vtablogConnectCreate(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr,
int isCreate
){
static int nInst = 0;
vtablog_vtab *pNew;
int i;
int rc;
int iInst = ++nInst;
char *zSchema = 0;
char *zNRow = 0;
printf("vtablog%s(tab=%d):\n", isCreate ? "Create" : "Connect", iInst);
printf(" argc=%d\n", argc);
for(i=0; i<argc; i++){
printf(" argv[%d] = ", i);
if( argv[i] ){
printf("[%s]\n", argv[i]);
}else{
printf("NULL\n");
}
}
for(i=3; i<argc; i++){
const char *z = argv[i];
if( vtablog_string_parameter(pzErr, "schema", z, &zSchema) ){
return SQLITE_ERROR;
}
if( vtablog_string_parameter(pzErr, "rows", z, &zNRow) ){
return SQLITE_ERROR;
}
}
if( zSchema==0 ){
*pzErr = sqlite3_mprintf("no schema defined");
return SQLITE_ERROR;
}
rc = sqlite3_declare_vtab(db, zSchema);
if( rc==SQLITE_OK ){
pNew = sqlite3_malloc( sizeof(*pNew) );
*ppVtab = (sqlite3_vtab*)pNew;
if( pNew==0 ) return SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
pNew->nRow = 10;
if( zNRow ) pNew->nRow = atoi(zNRow);
pNew->iInst = iInst;
}
return rc;
}
int fs_create(sqlite3 *db, void *pAux, int argc, const char *const *argv, sqlite3_vtab **ppVTab, char **pzErr)
{
fs_vtab *pvtab = (fs_vtab*)sqlite3_malloc(sizeof(fs_vtab));
if (!pvtab)
return SQLITE_NOMEM;
pvtab->base.zErrMsg = NULL;
pvtab->db = db;
pvtab->path = sqlite3_mprintf("%s", argc > 3 ? argv[3] : (char*)pAux);
*ppVTab = &pvtab->base;
return sqlite3_declare_vtab(db, fs_ddl);
}
/*
** This function does all the work for both the xConnect and xCreate methods.
** These tables have no persistent representation of their own, so xConnect
** and xCreate are identical operations.
*/
static int fts3auxConnectMethod(
sqlite3 *db, /* Database connection */
void *pUnused, /* Unused */
int argc, /* Number of elements in argv array */
const char * const *argv, /* xCreate/xConnect argument array */
sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
char **pzErr /* OUT: sqlite3_malloc'd error message */
){
char const *zDb; /* Name of database (e.g. "main") */
char const *zFts3; /* Name of fts3 table */
int nDb; /* Result of strlen(zDb) */
int nFts3; /* Result of strlen(zFts3) */
int nByte; /* Bytes of space to allocate here */
int rc; /* value returned by declare_vtab() */
Fts3auxTable *p; /* Virtual table object to return */
UNUSED_PARAMETER(pUnused);
/* The user should specify a single argument - the name of an fts3 table. */
if( argc!=4 ){
*pzErr = sqlite3_mprintf(
"wrong number of arguments to fts4aux constructor"
);
return SQLITE_ERROR;
}
zDb = argv[1];
nDb = strlen(zDb);
zFts3 = argv[3];
nFts3 = strlen(zFts3);
rc = sqlite3_declare_vtab(db, FTS3_TERMS_SCHEMA);
if( rc!=SQLITE_OK ) return rc;
nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
p = (Fts3auxTable *)sqlite3_malloc(nByte);
if( !p ) return SQLITE_NOMEM;
memset(p, 0, nByte);
p->pFts3Tab = (Fts3Table *)&p[1];
p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
p->pFts3Tab->db = db;
p->pFts3Tab->nIndex = 1;
memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
*ppVtab = (sqlite3_vtab *)p;
return SQLITE_OK;
}
static int
vknn_create (sqlite3 * db, void *pAux, int argc, const char *const *argv,
sqlite3_vtab ** ppVTab, char **pzErr)
{
/* creates the virtual table for R*Tree KNN metahandling */
VirtualKnnPtr p_vt;
char *buf;
char *vtable;
char *xname;
if (pAux)
pAux = pAux; /* unused arg warning suppression */
if (argc == 3)
{
vtable = gaiaDequotedSql ((char *) argv[2]);
}
else
{
*pzErr =
sqlite3_mprintf
("[VirtualKNN module] CREATE VIRTUAL: illegal arg list {void}\n");
return SQLITE_ERROR;
}
p_vt = (VirtualKnnPtr) sqlite3_malloc (sizeof (VirtualKnn));
if (!p_vt)
return SQLITE_NOMEM;
p_vt->db = db;
p_vt->pModule = &my_knn_module;
p_vt->nRef = 0;
p_vt->zErrMsg = NULL;
p_vt->knn_ctx = vknn_create_context ();
/* preparing the COLUMNs for this VIRTUAL TABLE */
xname = gaiaDoubleQuotedSql (vtable);
buf = sqlite3_mprintf ("CREATE TABLE \"%s\" (f_table_name TEXT, "
"f_geometry_column TEXT, ref_geometry BLOB, max_items INTEGER, "
"pos INTEGER, fid INTEGER, distance DOUBLE)", xname);
free (xname);
free (vtable);
if (sqlite3_declare_vtab (db, buf) != SQLITE_OK)
{
sqlite3_free (buf);
*pzErr =
sqlite3_mprintf
("[VirtualKNN module] CREATE VIRTUAL: invalid SQL statement \"%s\"",
buf);
return SQLITE_ERROR;
}
sqlite3_free (buf);
*ppVTab = (sqlite3_vtab *) p_vt;
return SQLITE_OK;
}
static int
vspidx_create (sqlite3 * db, void *pAux, int argc, const char *const *argv,
sqlite3_vtab ** ppVTab, char **pzErr)
{
/* creates the virtual table for R*Tree SpatialIndex metahandling */
VirtualSpatialIndexPtr p_vt;
char buf[1024];
char vtable[1024];
char xname[1024];
if (pAux)
pAux = pAux; /* unused arg warning suppression */
if (argc == 3)
{
strcpy (vtable, argv[2]);
vspidx_dequote (vtable);
}
else
{
*pzErr =
sqlite3_mprintf
("[VirtualSpatialIndex module] CREATE VIRTUAL: illegal arg list {void}\n");
return SQLITE_ERROR;
}
p_vt =
(VirtualSpatialIndexPtr) sqlite3_malloc (sizeof (VirtualSpatialIndex));
if (!p_vt)
return SQLITE_NOMEM;
p_vt->db = db;
p_vt->pModule = &my_spidx_module;
p_vt->nRef = 0;
p_vt->zErrMsg = NULL;
/* preparing the COLUMNs for this VIRTUAL TABLE */
strcpy (buf, "CREATE TABLE ");
strcpy (xname, vtable);
vspidx_double_quoted_sql (xname);
strcat (buf, xname);
strcat (buf,
" (f_table_name TEXT, f_geometry_column TEXT, search_frame BLOB)");
if (sqlite3_declare_vtab (db, buf) != SQLITE_OK)
{
*pzErr =
sqlite3_mprintf
("[VirtualSpatialIndex module] CREATE VIRTUAL: invalid SQL statement \"%s\"",
buf);
return SQLITE_ERROR;
}
*ppVTab = (sqlite3_vtab *) p_vt;
return SQLITE_OK;
}
int exe_xCreate(sqlite3* db, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char **pzErr) {
static char query[] = "CREATE TABLE exe(pid INT, exe TEXT)";
exe_table_t *table = (exe_table_t*) malloc(sizeof(exe_table_t));
memset(table,0,sizeof(exe_table_t));
if(!table) {
return SQLITE_ERROR;
}
table->content = vec_new(sizeof(exe_t),10);
*ppVTab = (sqlite3_vtab*) table;
int rc = sqlite3_declare_vtab(db, query);
if (rc != SQLITE_OK) {
return rc;
}
return SQLITE_OK;
}
int xCreate(sqlite3 *db,
void *pAux,
int argc,
const char *const *argv,
sqlite3_vtab **ppVtab,
char **pzErr) {
auto *pVtab = new VirtualTable;
if (!pVtab || argc == 0 || argv[0] == nullptr) {
delete pVtab;
return SQLITE_NOMEM;
}
memset(pVtab, 0, sizeof(VirtualTable));
pVtab->content = new VirtualTableContent;
pVtab->instance = (SQLiteDBInstance *)pAux;
// Create a TablePlugin Registry call, expect column details as the response.
PluginResponse response;
pVtab->content->name = std::string(argv[0]);
// Get the table column information.
auto status = Registry::call(
"table", pVtab->content->name, {{"action", "columns"}}, response);
if (!status.ok() || response.size() == 0) {
delete pVtab->content;
delete pVtab;
return SQLITE_ERROR;
}
// Generate an SQL create table statement from the retrieved column details.
auto statement =
"CREATE TABLE " + pVtab->content->name + columnDefinition(response);
int rc = sqlite3_declare_vtab(db, statement.c_str());
if (rc != SQLITE_OK || !status.ok() || response.size() == 0) {
delete pVtab->content;
delete pVtab;
return (rc != SQLITE_OK) ? rc : SQLITE_ERROR;
}
// Keep a local copy of the column details in the VirtualTableContent struct.
// This allows introspection into the column type without additional calls.
for (const auto &column : response) {
pVtab->content->columns.push_back(
std::make_pair(column.at("name"), columnTypeName(column.at("type"))));
}
*ppVtab = (sqlite3_vtab *)pVtab;
return rc;
}
/*
** Connect to or create a statvfs virtual table.
*/
static int statConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
StatTable *pTab;
pTab = (StatTable *)sqlite3_malloc(sizeof(StatTable));
memset(pTab, 0, sizeof(StatTable));
pTab->db = db;
sqlite3_declare_vtab(db, VTAB_SCHEMA);
*ppVtab = &pTab->base;
return SQLITE_OK;
}
/* Methods for the tclvar module */
static int tclvarConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
tclvar_vtab *pVtab;
static const char zSchema[] =
"CREATE TABLE whatever(name TEXT, arrayname TEXT, value TEXT)";
pVtab = sqlite3MallocZero( sizeof(*pVtab) );
if( pVtab==0 ) return SQLITE_NOMEM;
*ppVtab = &pVtab->base;
pVtab->interp = (Tcl_Interp *)pAux;
sqlite3_declare_vtab(db, zSchema);
return SQLITE_OK;
}
/* Current interface:
** argv[0] - module name
** argv[1] - database name
** argv[2] - table name
** argv[3] - tokenizer name (optional, a sensible default is provided)
** argv[4..] - passed to tokenizer (optional based on tokenizer)
**/
static int fulltextConnect(sqlite3 *db, void *pAux, int argc, char **argv,
sqlite3_vtab **ppVTab){
int rc;
fulltext_vtab *v;
sqlite3_tokenizer_module *m = NULL;
assert( argc>=3 );
v = (fulltext_vtab *) malloc(sizeof(fulltext_vtab));
/* sqlite will initialize v->base */
v->db = db;
v->zName = string_dup(argv[2]);
v->pTokenizer = NULL;
if( argc==3 ){
get_simple_tokenizer_module(&m);
} else {
/* TODO(shess) For now, add new tokenizers as else if clauses. */
if( !strcmp(argv[3], "simple") ){
get_simple_tokenizer_module(&m);
} else {
assert( "unrecognized tokenizer"==NULL );
}
}
/* TODO(shess) Since tokenization impacts the index, the parameters
** to the tokenizer need to be identical when a persistent virtual
** table is re-created. One solution would be a meta-table to track
** such information in the database. Then we could verify that the
** information is identical on subsequent creates.
*/
/* TODO(shess) Why isn't argv already (const char **)? */
rc = m->xCreate(argc-3, (const char **) (argv+3), &v->pTokenizer);
if( rc!=SQLITE_OK ) return rc;
v->pTokenizer->pModule = m;
/* TODO: verify the existence of backing tables foo_content, foo_term */
rc = sqlite3_declare_vtab(db, "create table x(content text)");
if( rc!=SQLITE_OK ) return rc;
memset(v->pFulltextStatements, 0, sizeof(v->pFulltextStatements));
*ppVTab = &v->base;
return SQLITE_OK;
}
//_____________________________________________________________________________
static int xConnect(sqlite3 *db, void *pAux, int argc, const char * const *argv,
sqlite3_vtab **ppVTab, char **c)
{
int rc;
/// @todo - no local bufs
char buf[1024];
*buf = '\0';
strcat(buf, "CREATE TABLE ");
strcat(buf, argv[1]);
strcat(buf, ".");
strcat(buf, argv[2]);
strcat(buf, " (ones INTEGER, twos INTEGER)");
rc = sqlite3_declare_vtab(db, buf);
*ppVTab = (sqlite3_vtab *)sqlite3_malloc(sizeof(sqlite3_vtab));
(**ppVTab).pModule = &module;
(**ppVTab).zErrMsg = 0;
// - vtab instance data would be here
return SQLITE_OK;
}
static int intarrayCreate(
sqlite3 *db,
void *pAux,
int argc,
const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
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;
}
/*
** 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_malloc64(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;
}
/*
** Table constructor for the schema module.
*/
static int schemaCreate(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
int rc = SQLITE_NOMEM;
schema_vtab *pVtab = MALLOC(sizeof(schema_vtab));
if( pVtab ){
memset(pVtab, 0, sizeof(schema_vtab));
pVtab->db = db;
#ifndef SQLITE_OMIT_VIRTUALTABLE
rc = sqlite3_declare_vtab(db, SCHEMA);
#endif
}
*ppVtab = (sqlite3_vtab *)pVtab;
return rc;
}
/*
** Connect to or create a dbpagevfs virtual table.
*/
static int dbpageConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
DbpageTable *pTab = 0;
int rc = SQLITE_OK;
int iDb;
if( argc>=4 ){
Token nm;
sqlite3TokenInit(&nm, (char*)argv[3]);
iDb = sqlite3FindDb(db, &nm);
if( iDb<0 ){
*pzErr = sqlite3_mprintf("no such schema: %s", argv[3]);
return SQLITE_ERROR;
}
}else{
iDb = 0;
}
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(pgno INTEGER PRIMARY KEY, data BLOB, schema HIDDEN)");
if( rc==SQLITE_OK ){
pTab = (DbpageTable *)sqlite3_malloc64(sizeof(DbpageTable));
if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
}
assert( rc==SQLITE_OK || pTab==0 );
if( rc==SQLITE_OK ){
Btree *pBt = db->aDb[iDb].pBt;
memset(pTab, 0, sizeof(DbpageTable));
pTab->db = db;
pTab->iDb = iDb;
pTab->pPager = pBt ? sqlite3BtreePager(pBt) : 0;
}
*ppVtab = (sqlite3_vtab*)pTab;
return rc;
}
/*
** Call sqlite3_declare_vtab() based on the contents of the configuration
** object passed as the only argument. Return SQLITE_OK if successful, or
** an SQLite error code if an error occurs.
*/
int sqlite3Fts5ConfigDeclareVtab(Fts5Config *pConfig){
int i;
int rc = SQLITE_OK;
char *zSql;
zSql = sqlite3Fts5Mprintf(&rc, "CREATE TABLE x(");
for(i=0; zSql && i<pConfig->nCol; i++){
const char *zSep = (i==0?"":", ");
zSql = sqlite3Fts5Mprintf(&rc, "%z%s%Q", zSql, zSep, pConfig->azCol[i]);
}
zSql = sqlite3Fts5Mprintf(&rc, "%z, %Q HIDDEN, %s HIDDEN)",
zSql, pConfig->zName, FTS5_RANK_NAME
);
assert( zSql || rc==SQLITE_NOMEM );
if( zSql ){
rc = sqlite3_declare_vtab(pConfig->db, zSql);
sqlite3_free(zSql);
}
return rc;
}
static int fulltextConnect(sqlite3 *db, void *pAux, int argc, char **argv,
sqlite3_vtab **ppVTab){
int rc;
fulltext_vtab *v;
sqlite3_tokenizer_module *m = NULL;
assert( argc>=3 );
v = (fulltext_vtab *) malloc(sizeof(fulltext_vtab));
v->db = db;
v->zName = string_dup(argv[2]);
v->pTokenizer = NULL;
if( argc==3 ){
get_simple_tokenizer_module(&m);
} else {
if( !strcmp(argv[3], "simple") ){
get_simple_tokenizer_module(&m);
} else {
assert( "unrecognized tokenizer"==NULL );
}
}
rc = m->xCreate(argc-3, (const char **) (argv+3), &v->pTokenizer);
if( rc!=SQLITE_OK ) return rc;
v->pTokenizer->pModule = m;
rc = sqlite3_declare_vtab(db, "create table x(content text)");
if( rc!=SQLITE_OK ) return rc;
memset(v->pFulltextStatements, 0, sizeof(v->pFulltextStatements));
*ppVTab = &v->base;
return SQLITE_OK;
}
static int echoDeclareVtab(
echo_vtab *pVtab,
sqlite3 *db
){
int rc = SQLITE_OK;
if( pVtab->zTableName ){
sqlite3_stmt *pStmt = 0;
rc = sqlite3_prepare(db,
"SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
-1, &pStmt, 0);
if( rc==SQLITE_OK ){
sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
if( sqlite3_step(pStmt)==SQLITE_ROW ){
int rc2;
const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
rc = sqlite3_declare_vtab(db, zCreateTable);
rc2 = sqlite3_finalize(pStmt);
if( rc==SQLITE_OK ){
rc = rc2;
}
} else {
rc = sqlite3_finalize(pStmt);
if( rc==SQLITE_OK ){
rc = SQLITE_ERROR;
}
}
if( rc==SQLITE_OK ){
rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
}
if( rc==SQLITE_OK ){
rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
}
}
}
return rc;
}
/*
** Connect to or create a statvfs virtual table.
*/
static int statConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
StatTable *pTab = 0;
int rc = SQLITE_OK;
int iDb;
if( argc>=4 ){
Token nm;
sqlite3TokenInit(&nm, (char*)argv[3]);
iDb = sqlite3FindDb(db, &nm);
if( iDb<0 ){
*pzErr = sqlite3_mprintf("no such database: %s", argv[3]);
return SQLITE_ERROR;
}
}else{
iDb = 0;
}
rc = sqlite3_declare_vtab(db, VTAB_SCHEMA);
if( rc==SQLITE_OK ){
pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable));
if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
}
assert( rc==SQLITE_OK || pTab==0 );
if( rc==SQLITE_OK ){
memset(pTab, 0, sizeof(StatTable));
pTab->db = db;
pTab->iDb = iDb;
}
*ppVtab = (sqlite3_vtab*)pTab;
return rc;
}
static int sesqlite_connect(sqlite3 *db, void *udp, int argc,
const char * const *argv, sqlite3_vtab **vtab, char **errmsg) {
sesqlite_vtab *v = NULL;
sqlite3_stmt **appStmt[N_STATEMENT];
int rc, i;
*vtab = NULL;
*errmsg = NULL;
if (argc != 3)
return SQLITE_ERROR;
if (sqlite3_declare_vtab(db, sesqlite_sql) != SQLITE_OK) {
return SQLITE_ERROR;
}
v = sqlite3_malloc(sizeof(sesqlite_vtab)); /* alloc our custom vtab */
*vtab = (sqlite3_vtab*) v;
if (v == NULL)
return SQLITE_NOMEM;
v->db = db; /* stash this for later */
(*vtab)->zErrMsg = NULL; /* initalize this */
return SQLITE_OK;
}
/*
** The templatevtabConnect() method is invoked to create a new
** template virtual table.
**
** Think of this routine as the constructor for templatevtab_vtab objects.
**
** All this routine needs to do is:
**
** (1) Allocate the templatevtab_vtab object and initialize all fields.
**
** (2) Tell SQLite (via the sqlite3_declare_vtab() interface) what the
** result set of queries against the virtual table will look like.
*/
static int templatevtabConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
templatevtab_vtab *pNew;
int rc;
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(a,b)"
);
/* For convenience, define symbolic names for the index to each column. */
#define TEMPLATEVTAB_A 0
#define TEMPLATEVTAB_B 1
if( rc==SQLITE_OK ){
pNew = sqlite3_malloc( sizeof(*pNew) );
*ppVtab = (sqlite3_vtab*)pNew;
if( pNew==0 ) return SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
}
return rc;
}
static int
vxpath_create (sqlite3 * db, void *pAux, int argc, const char *const *argv,
sqlite3_vtab ** ppVTab, char **pzErr)
{
/* creates the virtual table for XPath */
VirtualXPathPtr p_vt;
char *vtable = NULL;
char *table = NULL;
char *column = NULL;
char *xname;
char *sql;
int okTable = 0;
int okCol = 0;
if (argc == 5)
{
vtable = gaiaDequotedSql ((char *) argv[2]);
table = gaiaDequotedSql ((char *) argv[3]);
column = gaiaDequotedSql ((char *) argv[4]);
}
else
{
*pzErr =
sqlite3_mprintf
("[VirtualXPath module] CREATE VIRTUAL: illegal arg list {void}\n");
return SQLITE_ERROR;
}
vxpath_check (db, table, column, &okTable, &okCol);
if (!okTable || !okCol)
goto illegal;
xname = gaiaDoubleQuotedSql (vtable);
sql = sqlite3_mprintf ("CREATE TABLE \"%s\" (pkid INTEGER, sub INTEGER, "
"parent TEXT, node TEXT, attribute TEXT, "
"value TEXT, xpath_expr TEXT)", xname);
free (xname);
if (sqlite3_declare_vtab (db, sql) != SQLITE_OK)
{
sqlite3_free (sql);
*pzErr =
sqlite3_mprintf
("[VirtualXPath module] CREATE VIRTUAL: invalid SQL statement \"%s\"",
sql);
goto error;
}
sqlite3_free (sql);
p_vt = (VirtualXPathPtr) sqlite3_malloc (sizeof (VirtualXPath));
if (!p_vt)
return SQLITE_NOMEM;
p_vt->db = db;
p_vt->p_cache = pAux;
if (p_vt->p_cache == NULL)
spatialite_e ("VirtualXPath WARNING - no XML cache is available !!!\n");
p_vt->nRef = 0;
p_vt->zErrMsg = NULL;
p_vt->table = table;
p_vt->column = column;
*ppVTab = (sqlite3_vtab *) p_vt;
free (vtable);
return SQLITE_OK;
illegal:
/* something is going the wrong way */
if (!okTable == 0)
*pzErr =
sqlite3_mprintf
("[VirtualXPath module] table \"%s\" doesn't exists\n", table);
else if (!okCol)
*pzErr =
sqlite3_mprintf
("[VirtualXPath module] table \"%s\" exists, but has no \"%s\" column\n",
table, column);
error:
return SQLITE_ERROR;
}
/*
** xConnect/xCreate method for the amatch module. Arguments are:
**
** argv[0] -> module name ("approximate_match")
** argv[1] -> database name
** argv[2] -> table name
** argv[3...] -> arguments
*/
static int amatchConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
int rc = SQLITE_OK; /* Return code */
amatch_vtab *pNew = 0; /* New virtual table */
const char *zModule = argv[0];
const char *zDb = argv[1];
const char *zVal;
int i;
(void)pAux;
*ppVtab = 0;
pNew = sqlite3_malloc( sizeof(*pNew) );
if( pNew==0 ) return SQLITE_NOMEM;
rc = SQLITE_NOMEM;
memset(pNew, 0, sizeof(*pNew));
pNew->db = db;
pNew->zClassName = sqlite3_mprintf("%s", zModule);
if( pNew->zClassName==0 ) goto amatchConnectError;
pNew->zDb = sqlite3_mprintf("%s", zDb);
if( pNew->zDb==0 ) goto amatchConnectError;
pNew->zSelf = sqlite3_mprintf("%s", argv[2]);
if( pNew->zSelf==0 ) goto amatchConnectError;
for(i=3; i<argc; i++){
zVal = amatchValueOfKey("vocabulary_table", argv[i]);
if( zVal ){
sqlite3_free(pNew->zVocabTab);
pNew->zVocabTab = amatchDequote(zVal);
if( pNew->zVocabTab==0 ) goto amatchConnectError;
continue;
}
zVal = amatchValueOfKey("vocabulary_word", argv[i]);
if( zVal ){
sqlite3_free(pNew->zVocabWord);
pNew->zVocabWord = amatchDequote(zVal);
if( pNew->zVocabWord==0 ) goto amatchConnectError;
continue;
}
zVal = amatchValueOfKey("vocabulary_language", argv[i]);
if( zVal ){
sqlite3_free(pNew->zVocabLang);
pNew->zVocabLang = amatchDequote(zVal);
if( pNew->zVocabLang==0 ) goto amatchConnectError;
continue;
}
zVal = amatchValueOfKey("edit_distances", argv[i]);
if( zVal ){
sqlite3_free(pNew->zCostTab);
pNew->zCostTab = amatchDequote(zVal);
if( pNew->zCostTab==0 ) goto amatchConnectError;
continue;
}
*pzErr = sqlite3_mprintf("unrecognized argument: [%s]\n", argv[i]);
amatchFree(pNew);
*ppVtab = 0;
return SQLITE_ERROR;
}
rc = SQLITE_OK;
if( pNew->zCostTab==0 ){
*pzErr = sqlite3_mprintf("no edit_distances table specified");
rc = SQLITE_ERROR;
}else{
rc = amatchLoadRules(db, pNew, pzErr);
}
if( rc==SQLITE_OK ){
rc = sqlite3_declare_vtab(db,
"CREATE TABLE x(word,distance,language,"
"command HIDDEN,nword HIDDEN)"
);
#define AMATCH_COL_WORD 0
#define AMATCH_COL_DISTANCE 1
#define AMATCH_COL_LANGUAGE 2
#define AMATCH_COL_COMMAND 3
#define AMATCH_COL_NWORD 4
}
if( rc!=SQLITE_OK ){
amatchFree(pNew);
}
*ppVtab = &pNew->base;
return rc;
amatchConnectError:
amatchFree(pNew);
return rc;
}
