lsqlite3.c

/************************************************************************
* lsqlite3-s                                                            *
* Copyright (C) 2018-2023 Shmuel Zeigerman                              *
* All rights reserved.                                                  *
* Author    : Shmuel Zeigerman                                          *
* Library   : lsqlite3-s - an SQLite 3 database binding for Lua 5       *
*           : It is a modification of lsqlite3 library.                 *
*                                                                       *
* Permission is hereby granted, free of charge, to any person obtaining *
* a copy of this software and associated documentation files (the       *
* "Software"), to deal in the Software without restriction, including   *
* without limitation the rights to use, copy, modify, merge, publish,   *
* distribute, sublicense, and/or sell copies of the Software, and to    *
* permit persons to whom the Software is furnished to do so, subject to *
* the following conditions:                                             *
*                                                                       *
* The above copyright notice and this permission notice shall be        *
* included in all copies or substantial portions of the Software.       *
*                                                                       *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       *
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  *
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  *
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     *
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                *
************************************************************************/

/************************************************************************
* lsqlite3                                                              *
* Copyright (C) 2002-2016 Tiago Dionizio, Doug Currie                   *
* All rights reserved.                                                  *
* Author    : Tiago Dionizio <tiago.dionizio@ist.utl.pt>                *
* Author    : Doug Currie <doug.currie@alum.mit.edu>                    *
* Library   : lsqlite3 - an SQLite 3 database binding for Lua 5         *
*                                                                       *
* Permission is hereby granted, free of charge, to any person obtaining *
* a copy of this software and associated documentation files (the       *
* "Software"), to deal in the Software without restriction, including   *
* without limitation the rights to use, copy, modify, merge, publish,   *
* distribute, sublicense, and/or sell copies of the Software, and to    *
* permit persons to whom the Software is furnished to do so, subject to *
* the following conditions:                                             *
*                                                                       *
* The above copyright notice and this permission notice shall be        *
* included in all copies or substantial portions of the Software.       *
*                                                                       *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       *
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  *
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  *
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     *
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                *
************************************************************************/

#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define LUA_LIB
#include "lua.h"
#include "lauxlib.h"

#if LUA_VERSION_NUM > 501
/*
** Lua 5.2
*/
#define lua_strlen lua_rawlen
/* luaL_typerror always used with arg at ndx == NULL */
#define luaL_typerror(L,ndx,str) luaL_error(L,"bad argument %d (%s expected, got nil)",ndx,str)
/* luaL_register used once, so below expansion is OK for this case */
#define luaL_register(L,name,reg) luaL_setfuncs(L,reg,0)
/* luaL_openlib always used with name == NULL */
#define luaL_openlib(L,name,reg,nup) luaL_setfuncs(L,reg,nup)

#if LUA_VERSION_NUM > 502
/*
** Lua 5.3
*/
#define luaL_checkint(L,n)  ((int)luaL_checkinteger(L, (n)))
#endif
#endif

#include "sqlite3.h"

/* compile time features */
#if !defined(SQLITE_OMIT_PROGRESS_CALLBACK)
    #define SQLITE_OMIT_PROGRESS_CALLBACK 0
#endif
#if !defined(LSQLITE_OMIT_UPDATE_HOOK)
    #define LSQLITE_OMIT_UPDATE_HOOK 0
#endif
#if defined(LSQLITE_OMIT_OPEN_V2)
    #define SQLITE3_OPEN(filename,ppDb,flags) sqlite3_open(filename,ppDb)
#else
    #define SQLITE3_OPEN(filename,ppDb,flags) sqlite3_open_v2(filename,ppDb,flags,NULL)
#endif

typedef struct sdb sdb;
typedef struct sdb_vm sdb_vm;
typedef struct sdb_bu sdb_bu;
typedef struct sdb_func sdb_func;

/* prevent closing DB connection from a duplicate handle's GC handler */
enum {
    CM_CAN_CLOSE,          /* setting for main connection      */
    CM_NO_CLOSE_FROM_GC,   /* setting for duplicate connection */
    CM_CANNOT_CLOSE,       /* implementation detail */
};

/* to use as C user data so i know what function sqlite is calling */
struct sdb_func {
    /* references to associated lua values */
    int fn_step;
    int fn_finalize;
    int udata;

    sdb *db;
    char aggregate;

    sdb_func *next;
};

/* information about database */
struct sdb {
    /* associated lua state */
    lua_State *L;
    /* sqlite database handle */
    sqlite3 *db;

    /* sql functions stack usage */
    sdb_func *func;         /* top SQL function being called */

    /* references */
    int busy_cb;        /* busy callback */
    int busy_udata;

    int progress_cb;    /* progress handler */
    int progress_udata;

    int trace_cb;       /* trace callback */
    int trace_udata;

#if !defined(LSQLITE_OMIT_UPDATE_HOOK) || !LSQLITE_OMIT_UPDATE_HOOK

    int update_hook_cb; /* update_hook callback */
    int update_hook_udata;

    int commit_hook_cb; /* commit_hook callback */
    int commit_hook_udata;

    int rollback_hook_cb; /* rollback_hook callback */
    int rollback_hook_udata;

#endif
    int close_mark; /* behavior with regards to close attempt */
};

static const char *sqlite_meta      = ":sqlite3";
static const char *sqlite_vm_meta   = ":sqlite3:vm";
static const char *sqlite_bu_meta   = ":sqlite3:bu";
static const char *sqlite_ctx_meta  = ":sqlite3:ctx";
static const char *sqlite_blob_meta = ":sqlite3:blob";

/* Lua 5.3 introduced an integer type, but depending on the implementation, it could be 32
** or 64 bits (or something else?). This helper macro tries to do "the right thing."
*/

/* The trick lua_pushnumber(L,n); n=lua_tonumber(L,-1); is needed to bypass compiler optimizations */
#if LUA_VERSION_NUM > 502
#define PUSH_INT64(L,i64in,fallback) \
    do { \
        sqlite_int64 i64 = i64in; \
        lua_Integer i = (lua_Integer )i64; \
        if (i == i64) lua_pushinteger(L, i);\
        else { \
            lua_Number n = (lua_Number)i64; \
            lua_pushnumber(L, n); n = lua_tonumber(L, -1); lua_pop(L, 1); \
            if ((sqlite_int64)n == i64) lua_pushnumber(L, n); \
            else fallback; \
        } \
    } while (0)
#else
#define MAX52 (1LL << 52)
#define FIT52(v) ((v >= 0 && v < MAX52) || (v < 0 && v >= -MAX52))
#define PUSH_INT64(L,i64in,fallback) \
    do { \
        if (FIT52(i64in)) lua_pushnumber(L, i64in); \
        else fallback; \
    } while (0)
#endif

/* This function replaces lua_pushfstring(L, "%ll")
   as "%ll" is not listed as a valid conversion specifier
   in the Lua 5.1 reference manual.
*/
static void push_str64(lua_State *L, sqlite_int64 val)
{
    char buf[32];
#ifdef _WIN32
    sprintf(buf, "%I64d", val);
#else
    sprintf(buf, "%lld", val);
#endif
    lua_pushstring(L, buf);
}

/*
** =======================================================
** Database Virtual Machine Operations
** =======================================================
*/

static void vm_push_column(lua_State *L, sqlite3_stmt *vm, int idx) {
    switch (sqlite3_column_type(vm, idx)) {
        case SQLITE_INTEGER:
            PUSH_INT64(L, sqlite3_column_int64(vm, idx)
                     , lua_pushlstring(L, (const char*)sqlite3_column_text(vm, idx)
                                        , sqlite3_column_bytes(vm, idx)));
            break;
        case SQLITE_FLOAT:
            lua_pushnumber(L, sqlite3_column_double(vm, idx));
            break;
        case SQLITE_TEXT:
            lua_pushlstring(L, (const char*)sqlite3_column_text(vm, idx), sqlite3_column_bytes(vm, idx));
            break;
        case SQLITE_BLOB:
            lua_pushlstring(L, (const char*)sqlite3_column_blob(vm, idx), sqlite3_column_bytes(vm, idx));
            break;
        case SQLITE_NULL:
            lua_pushnil(L);
            break;
        default:
            lua_pushnil(L);
            break;
    }
}

/* virtual machine information */
struct sdb_vm {
    sdb *db;                /* associated database handle */
    sqlite3_stmt *vm;       /* virtual machine */

    /* sqlite3_step info */
    int columns;            /* number of columns in result */
    char has_values;        /* true when step succeeds */

    char temp;              /* temporary vm used in db:rows */
};

/* called with db,sql text on the lua stack */
static sdb_vm *newvm(lua_State *L, sdb *db) {
    sdb_vm *svm = (sdb_vm*)lua_newuserdata(L, sizeof(sdb_vm)); /* db sql svm_ud -- */

    luaL_getmetatable(L, sqlite_vm_meta);
    lua_setmetatable(L, -2);        /* set metatable */

    svm->db = db;
    svm->columns = 0;
    svm->has_values = 0;
    svm->vm = NULL;
    svm->temp = 0;

    /* add an entry on the database table: svm -> db to keep db live while svm is live */
    lua_pushlightuserdata(L, db);     /* db sql svm_ud db_lud -- */
    lua_rawget(L, LUA_REGISTRYINDEX); /* db sql svm_ud reg[db_lud] -- */
    lua_pushlightuserdata(L, svm);    /* db sql svm_ud reg[db_lud] svm_lud -- */
    lua_pushvalue(L, -5);             /* db sql svm_ud reg[db_lud] svm_lud db -- */
    lua_rawset(L, -3);                /* (reg[db_lud])[svm_lud] = db ; set the db for this vm */
    lua_pop(L, 1);                    /* db sql svm_ud -- */

    return svm;
}

static int cleanupvm(lua_State *L, sdb_vm *svm) {

    /* remove entry in database table - no harm if not present in the table */
    lua_pushlightuserdata(L, svm->db);
    lua_rawget(L, LUA_REGISTRYINDEX);
    lua_pushlightuserdata(L, svm);
    lua_pushnil(L);
    lua_rawset(L, -3);
    lua_pop(L, 1);

    svm->columns = 0;
    svm->has_values = 0;

    if (!svm->vm) return 0;

    lua_pushinteger(L, sqlite3_finalize(svm->vm));
    svm->vm = NULL;
    return 1;
}

static int stepvm(lua_State *L, sdb_vm *svm) {
    (void) L;
    return sqlite3_step(svm->vm);
}

static sdb_vm *lsqlite_getvm(lua_State *L, int index) {
    sdb_vm *svm = (sdb_vm*)luaL_checkudata(L, index, sqlite_vm_meta);
    if (svm == NULL) luaL_argerror(L, index, "bad sqlite virtual machine");
    return svm;
}

static sdb_vm *lsqlite_checkvm(lua_State *L, int index) {
    sdb_vm *svm = lsqlite_getvm(L, index);
    if (svm->vm == NULL) luaL_argerror(L, index, "attempt to use closed sqlite virtual machine");
    return svm;
}

static int dbvm_isopen(lua_State *L) {
    sdb_vm *svm = lsqlite_getvm(L, 1);
    lua_pushboolean(L, svm->vm != NULL ? 1 : 0);
    return 1;
}

static int dbvm_tostring(lua_State *L) {
    char buff[39];
    sdb_vm *svm = lsqlite_getvm(L, 1);
    if (svm->vm == NULL)
        strcpy(buff, "closed");
    else
        sprintf(buff, "%p", svm);
    lua_pushfstring(L, "sqlite virtual machine (%s)", buff);
    return 1;
}

static int dbvm_gc(lua_State *L) {
    sdb_vm *svm = lsqlite_getvm(L, 1);
    if (svm->vm != NULL)  /* ignore closed vms */
        cleanupvm(L, svm);
    return 0;
}

static int dbvm_step(lua_State *L) {
    int result;
    sdb_vm *svm = lsqlite_checkvm(L, 1);

    result = stepvm(L, svm);
    svm->has_values = result == SQLITE_ROW ? 1 : 0;
    svm->columns = sqlite3_data_count(svm->vm);

    lua_pushinteger(L, result);
    return 1;
}

static int dbvm_finalize(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    return cleanupvm(L, svm);
}

static int dbvm_reset(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_reset(svm->vm);
    lua_pushinteger(L, sqlite3_errcode(svm->db->db));
    return 1;
}

static void dbvm_check_contents(lua_State *L, sdb_vm *svm) {
    if (!svm->has_values) {
        luaL_error(L, "misuse of function");
    }
}

static void dbvm_check_index(lua_State *L, sdb_vm *svm, int index) {
    if (index < 0 || index >= svm->columns) {
        luaL_error(L, "index out of range [0..%d]", svm->columns - 1);
    }
}

static void dbvm_check_bind_index(lua_State *L, sdb_vm *svm, int index) {
    if (index < 1 || index > sqlite3_bind_parameter_count(svm->vm)) {
        luaL_error(L, "bind index out of range [1..%d]", sqlite3_bind_parameter_count(svm->vm));
    }
}

static int dbvm_last_insert_rowid(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    /* conversion warning: int64 -> luaNumber */
    sqlite_int64 rowid = sqlite3_last_insert_rowid(svm->db->db);
    PUSH_INT64(L, rowid, push_str64(L, rowid));
    return 1;
}

/*
** =======================================================
** Virtual Machine - generic info
** =======================================================
*/
static int dbvm_columns(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    lua_pushinteger(L, sqlite3_column_count(svm->vm));
    return 1;
}

/*
** =======================================================
** Virtual Machine - getters
** =======================================================
*/

static int dbvm_get_value(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checkint(L, 2);
    dbvm_check_contents(L, svm);
    dbvm_check_index(L, svm, index);
    vm_push_column(L, svm->vm, index);
    return 1;
}

static int dbvm_get_name(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checknumber(L, 2);
    dbvm_check_index(L, svm, index);
    lua_pushstring(L, sqlite3_column_name(svm->vm, index));
    return 1;
}

static int dbvm_get_type(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checknumber(L, 2);
    dbvm_check_index(L, svm, index);
    lua_pushstring(L, sqlite3_column_decltype(svm->vm, index));
    return 1;
}

static int dbvm_get_column_type(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checknumber(L, 2);
    dbvm_check_index(L, svm, index);
    lua_pushinteger(L, sqlite3_column_type(svm->vm, index));
    return 1;
}

static int dbvm_get_column_text(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checknumber(L, 2);
    dbvm_check_index(L, svm, index);
    lua_pushlstring(L, (const char*)sqlite3_column_text(svm->vm, index),
        sqlite3_column_bytes(svm->vm, index));
    return 1;
}

static int dbvm_get_column_int(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checknumber(L, 2);
    dbvm_check_index(L, svm, index);
    lua_pushinteger(L, sqlite3_column_int(svm->vm, index));
    return 1;
}

static int dbvm_get_values(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = svm->columns;
    int n;
    dbvm_check_contents(L, svm);

    lua_createtable(L, columns, 0);
    for (n = 0; n < columns;) {
        vm_push_column(L, vm, n++);
        lua_rawseti(L, -2, n);
    }
    return 1;
}

static int dbvm_get_names(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = sqlite3_column_count(vm); /* valid as soon as statement prepared */
    int n;

    lua_createtable(L, columns, 0);
    for (n = 0; n < columns;) {
        lua_pushstring(L, sqlite3_column_name(vm, n++));
        lua_rawseti(L, -2, n);
    }
    return 1;
}

static int dbvm_get_types(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = sqlite3_column_count(vm); /* valid as soon as statement prepared */
    int n;

    lua_createtable(L, columns, 0);
    for (n = 0; n < columns;) {
        lua_pushstring(L, sqlite3_column_decltype(vm, n++));
        lua_rawseti(L, -2, n);
    }
    return 1;
}

static int dbvm_get_uvalues(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = svm->columns;
    int n;
    dbvm_check_contents(L, svm);

    lua_checkstack(L, columns);
    for (n = 0; n < columns; ++n)
        vm_push_column(L, vm, n);
    return columns;
}

static int dbvm_get_unames(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = sqlite3_column_count(vm); /* valid as soon as statement prepared */
    int n;

    lua_checkstack(L, columns);
    for (n = 0; n < columns; ++n)
        lua_pushstring(L, sqlite3_column_name(vm, n));
    return columns;
}

static int dbvm_get_utypes(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = sqlite3_column_count(vm); /* valid as soon as statement prepared */
    int n;

    lua_checkstack(L, columns);
    for (n = 0; n < columns; ++n)
        lua_pushstring(L, sqlite3_column_decltype(vm, n));
    return columns;
}

static int dbvm_get_named_values(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = svm->columns;
    int n;
    dbvm_check_contents(L, svm);

    lua_createtable(L, 0, columns);
    for (n = 0; n < columns; ++n) {
        lua_pushstring(L, sqlite3_column_name(vm, n));
        vm_push_column(L, vm, n);
        lua_rawset(L, -3);
    }
    return 1;
}

static int dbvm_get_named_types(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int columns = sqlite3_column_count(vm);
    int n;

    lua_createtable(L, 0, columns);
    for (n = 0; n < columns; ++n) {
        lua_pushstring(L, sqlite3_column_name(vm, n));
        lua_pushstring(L, sqlite3_column_decltype(vm, n));
        lua_rawset(L, -3);
    }
    return 1;
}

/*
** =======================================================
** Virtual Machine - Bind
** =======================================================
*/

static int dbvm_bind_index(lua_State *L, sqlite3_stmt *vm, int index, int lindex) {
    switch (lua_type(L, lindex)) {
        case LUA_TSTRING:
            return sqlite3_bind_text(vm, index, lua_tostring(L, lindex), lua_strlen(L, lindex), SQLITE_TRANSIENT);
        case LUA_TNUMBER:
#if LUA_VERSION_NUM > 502
            if (lua_isinteger(L, lindex))
                return sqlite3_bind_int64(vm, index, lua_tointeger(L, lindex));
#endif
            return sqlite3_bind_double(vm, index, lua_tonumber(L, lindex));
        case LUA_TBOOLEAN:
            return sqlite3_bind_int(vm, index, lua_toboolean(L, lindex) ? 1 : 0);
        case LUA_TNONE:
        case LUA_TNIL:
            return sqlite3_bind_null(vm, index);
        default:
            luaL_error(L, "index (%d) - invalid data type for bind (%s)", index, lua_typename(L, lua_type(L, lindex)));
            return SQLITE_MISUSE; /*!*/
    }
}


static int dbvm_bind_parameter_count(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    lua_pushinteger(L, sqlite3_bind_parameter_count(svm->vm));
    return 1;
}

static int dbvm_bind_parameter_name(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checknumber(L, 2);
    dbvm_check_bind_index(L, svm, index);
    lua_pushstring(L, sqlite3_bind_parameter_name(svm->vm, index));
    return 1;
}

static int dbvm_bind(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int index = luaL_checkint(L, 2);
    int result;

    dbvm_check_bind_index(L, svm, index);
    result = dbvm_bind_index(L, vm, index, 3);

    lua_pushinteger(L, result);
    return 1;
}

static int dbvm_bind_blob(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checkint(L, 2);
    const char *value = luaL_checkstring(L, 3);
    int len = lua_strlen(L, 3);

    lua_pushinteger(L, sqlite3_bind_blob(svm->vm, index, value, len, SQLITE_TRANSIENT));
    return 1;
}

static int dbvm_bind_zeroblob(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    int index = luaL_checkint(L, 2);
    int size = luaL_checkint(L, 3);

    lua_pushinteger(L, sqlite3_bind_zeroblob(svm->vm, index, size));
    return 1;
}

static int dbvm_bind_values(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int top = lua_gettop(L);
    int result, n;

    if (top - 1 != sqlite3_bind_parameter_count(vm))
        luaL_error(L,
            "incorrect number of parameters to bind (%d given, %d to bind)",
            top - 1,
            sqlite3_bind_parameter_count(vm)
        );

    for (n = 2; n <= top; ++n) {
        if ((result = dbvm_bind_index(L, vm, n - 1, n)) != SQLITE_OK) {
            lua_pushinteger(L, result);
            return 1;
        }
    }

    lua_pushinteger(L, SQLITE_OK);
    return 1;
}

static int dbvm_bind_names(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm = svm->vm;
    int count = sqlite3_bind_parameter_count(vm);
    const char *name;
    int result, n;
    luaL_checktype(L, 2, LUA_TTABLE);

    for (n = 1; n <= count; ++n) {
        name = sqlite3_bind_parameter_name(vm, n);
        if (name && (name[0] == ':' || name[0] == '$')) {
            lua_pushstring(L, ++name);
            lua_gettable(L, 2);
            result = dbvm_bind_index(L, vm, n, -1);
            lua_pop(L, 1);
        }
        else {
            lua_pushinteger(L, n);
            lua_gettable(L, 2);
            result = dbvm_bind_index(L, vm, n, -1);
            lua_pop(L, 1);
        }

        if (result != SQLITE_OK) {
            lua_pushinteger(L, result);
            return 1;
        }
    }

    lua_pushinteger(L, SQLITE_OK);
    return 1;
}

/*
** =======================================================
** Database (internal management)
** =======================================================
*/

/*
** When creating database handles, always creates a `closed' database handle
** before opening the actual database; so, if there is a memory error, the
** database is not left opened.
**
** Creates a new 'table' and leaves it in the stack
*/
static sdb *newdb (lua_State *L, int close_mark) {
    sdb *db = (sdb*)lua_newuserdata(L, sizeof(sdb));
    db->L = L;
    db->db = NULL;  /* database handle is currently `closed' */
    db->func = NULL;
    db->close_mark = close_mark;

    db->busy_cb =
    db->busy_udata =
    db->progress_cb =
    db->progress_udata =
    db->trace_cb =
    db->trace_udata =
#if !defined(LSQLITE_OMIT_UPDATE_HOOK) || !LSQLITE_OMIT_UPDATE_HOOK
    db->update_hook_cb =
    db->update_hook_udata =
    db->commit_hook_cb =
    db->commit_hook_udata =
    db->rollback_hook_cb =
    db->rollback_hook_udata =
#endif
     LUA_NOREF;

    luaL_getmetatable(L, sqlite_meta);
    lua_setmetatable(L, -2);        /* set metatable */

    /* to keep track of 'open' virtual machines */
    lua_pushlightuserdata(L, db);
    lua_newtable(L);
    lua_rawset(L, LUA_REGISTRYINDEX);

    return db;
}

static int cleanupdb(lua_State *L, sdb *db) {
    sdb_func *func;
    sdb_func *func_next;
    int top;
    int result;

    /* free associated virtual machines */
    lua_pushlightuserdata(L, db);
    lua_rawget(L, LUA_REGISTRYINDEX);

    /* close all used handles */
    top = lua_gettop(L);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
        sdb_vm *svm = (sdb_vm*) lua_touserdata(L, -2); /* key: vm; val: sql text */
        cleanupvm(L, svm);

        lua_settop(L, top);
        lua_pushnil(L);
    }

    lua_pop(L, 1); /* pop vm table */

    /* remove entry in lua registry table */
    lua_pushlightuserdata(L, db);
    lua_pushnil(L);
    lua_rawset(L, LUA_REGISTRYINDEX);

    /* 'free' all references */
    luaL_unref(L, LUA_REGISTRYINDEX, db->busy_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->busy_udata);
    luaL_unref(L, LUA_REGISTRYINDEX, db->progress_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->progress_udata);
    luaL_unref(L, LUA_REGISTRYINDEX, db->trace_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->trace_udata);
#if !defined(LSQLITE_OMIT_UPDATE_HOOK) || !LSQLITE_OMIT_UPDATE_HOOK
    luaL_unref(L, LUA_REGISTRYINDEX, db->update_hook_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->update_hook_udata);
    luaL_unref(L, LUA_REGISTRYINDEX, db->commit_hook_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->commit_hook_udata);
    luaL_unref(L, LUA_REGISTRYINDEX, db->rollback_hook_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->rollback_hook_udata);
#endif

    /* close database */
    if (db->close_mark != CM_CANNOT_CLOSE)
        result = sqlite3_close(db->db);
    else
        result = SQLITE_OK;
    db->db = NULL;

    /* free associated memory with created functions */
    func = db->func;
    while (func) {
        func_next = func->next;
        luaL_unref(L, LUA_REGISTRYINDEX, func->fn_step);
        luaL_unref(L, LUA_REGISTRYINDEX, func->fn_finalize);
        luaL_unref(L, LUA_REGISTRYINDEX, func->udata);
        free(func);
        func = func_next;
    }
    db->func = NULL;
    return result;
}

static sdb *lsqlite_getdb(lua_State *L, int index) {
    sdb *db = (sdb*)luaL_checkudata(L, index, sqlite_meta);
    if (db == NULL) luaL_typerror(L, index, "sqlite database");
    return db;
}

static sdb *lsqlite_checkdb(lua_State *L, int index) {
    sdb *db = lsqlite_getdb(L, index);
    if (db->db == NULL) luaL_argerror(L, index, "attempt to use closed sqlite database");
    return db;
}


/*
** =======================================================
** User Defined Functions - Context Methods
** =======================================================
*/
typedef struct {
    sqlite3_context *ctx;
    int ud;
} lcontext;

static lcontext *lsqlite_make_context(lua_State *L) {
    lcontext *ctx = (lcontext*)lua_newuserdata(L, sizeof(lcontext));
    luaL_getmetatable(L, sqlite_ctx_meta);
    lua_setmetatable(L, -2);
    ctx->ctx = NULL;
    ctx->ud = LUA_NOREF;
    return ctx;
}

static lcontext *lsqlite_getcontext(lua_State *L, int index) {
    lcontext *ctx = (lcontext*)luaL_checkudata(L, index, sqlite_ctx_meta);
    if (ctx == NULL) luaL_typerror(L, index, "sqlite context");
    return ctx;
}

static lcontext *lsqlite_checkcontext(lua_State *L, int index) {
    lcontext *ctx = lsqlite_getcontext(L, index);
    if (ctx->ctx == NULL) luaL_argerror(L, index, "invalid sqlite context");
    return ctx;
}

static int lcontext_tostring(lua_State *L) {
    char buff[39];
    lcontext *ctx = lsqlite_getcontext(L, 1);
    if (ctx->ctx == NULL)
        strcpy(buff, "closed");
    else
        sprintf(buff, "%p", ctx->ctx);
    lua_pushfstring(L, "sqlite function context (%s)", buff);
    return 1;
}

static void lcontext_check_aggregate(lua_State *L, lcontext *ctx) {
    sdb_func *func = (sdb_func*)sqlite3_user_data(ctx->ctx);
    if (!func->aggregate) {
        luaL_error(L, "attempt to call aggregate method from scalar function");
    }
}

static int lcontext_user_data(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    sdb_func *func = (sdb_func*)sqlite3_user_data(ctx->ctx);
    lua_rawgeti(L, LUA_REGISTRYINDEX, func->udata);
    return 1;
}

static int lcontext_get_aggregate_context(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    lcontext_check_aggregate(L, ctx);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ctx->ud);
    return 1;
}

static int lcontext_set_aggregate_context(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    lcontext_check_aggregate(L, ctx);
    lua_settop(L, 2);
    luaL_unref(L, LUA_REGISTRYINDEX, ctx->ud);
    ctx->ud = luaL_ref(L, LUA_REGISTRYINDEX);
    return 0;
}

static int lcontext_aggregate_count(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    lcontext_check_aggregate(L, ctx);
    lua_pushinteger(L, sqlite3_aggregate_count(ctx->ctx));
    return 1;
}

#if 0
void *sqlite3_get_auxdata(sqlite3_context*, int);
void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*));
#endif

static int lcontext_result(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    switch (lua_type(L, 2)) {
        case LUA_TNUMBER:
#if LUA_VERSION_NUM > 502
            if (lua_isinteger(L, 2))
                sqlite3_result_int64(ctx->ctx, luaL_checkinteger(L, 2));
            else
#endif
            sqlite3_result_double(ctx->ctx, luaL_checknumber(L, 2));
            break;
        case LUA_TSTRING:
            sqlite3_result_text(ctx->ctx, luaL_checkstring(L, 2), lua_strlen(L, 2), SQLITE_TRANSIENT);
            break;
        case LUA_TNIL:
        case LUA_TNONE:
            sqlite3_result_null(ctx->ctx);
            break;
        default:
            luaL_error(L, "invalid result type %s", lua_typename(L, 2));
            break;
    }

    return 0;
}

static int lcontext_result_blob(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    const char *blob = luaL_checkstring(L, 2);
    int size = lua_strlen(L, 2);
    sqlite3_result_blob(ctx->ctx, (const void*)blob, size, SQLITE_TRANSIENT);
    return 0;
}

static int lcontext_result_double(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    double d = luaL_checknumber(L, 2);
    sqlite3_result_double(ctx->ctx, d);
    return 0;
}

static int lcontext_result_error(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    const char *err = luaL_checkstring(L, 2);
    int size = lua_strlen(L, 2);
    sqlite3_result_error(ctx->ctx, err, size);
    return 0;
}

static int lcontext_result_int(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    int i = luaL_checkint(L, 2);
    sqlite3_result_int(ctx->ctx, i);
    return 0;
}

static int lcontext_result_null(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    sqlite3_result_null(ctx->ctx);
    return 0;
}

static int lcontext_result_text(lua_State *L) {
    lcontext *ctx = lsqlite_checkcontext(L, 1);
    const char *text = luaL_checkstring(L, 2);
    int size = lua_strlen(L, 2);
    sqlite3_result_text(ctx->ctx, text, size, SQLITE_TRANSIENT);
    return 0;
}

/*
** =======================================================
** Database Methods
** =======================================================
*/

static int db_isopen(lua_State *L) {
    sdb *db = lsqlite_getdb(L, 1);
    lua_pushboolean(L, db->db != NULL ? 1 : 0);
    return 1;
}

static int db_last_insert_rowid(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    /* conversion warning: int64 -> luaNumber */
    sqlite_int64 rowid = sqlite3_last_insert_rowid(db->db);
    PUSH_INT64(L, rowid, push_str64(L, rowid));
    return 1;
}

static int db_changes(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushinteger(L, sqlite3_changes(db->db));
    return 1;
}

static int db_total_changes(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushinteger(L, sqlite3_total_changes(db->db));
    return 1;
}

static int db_errcode(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushinteger(L, sqlite3_errcode(db->db));
    return 1;
}

static int db_errmsg(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushstring(L, sqlite3_errmsg(db->db));
    return 1;
}

static int db_extended_errcode(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushinteger(L, sqlite3_extended_errcode(db->db));
    return 1;
}

static int db_extended_result_codes(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    int turn_on = luaL_checkinteger(L, 2);
    lua_pushinteger(L, sqlite3_extended_result_codes(db->db, turn_on));
    return 1;
}

static int db_interrupt(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    sqlite3_interrupt(db->db);
    return 0;
}

#if (SQLITE_VERSION_NUMBER >= 3007010)
static int db_db_filename(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    const char *db_name = luaL_checkstring(L, 2);
    /* sqlite3_db_filename may return NULL, in that case Lua pushes nil... */
    lua_pushstring(L, sqlite3_db_filename(db->db, db_name));
    return 1;
}
#endif

/*
** Registering SQL functions:
*/

static void db_push_value(lua_State *L, sqlite3_value *value) {
    switch (sqlite3_value_type(value)) {
        case SQLITE_TEXT:
            lua_pushlstring(L, (const char*)sqlite3_value_text(value), sqlite3_value_bytes(value));
            break;

        case SQLITE_INTEGER:
            PUSH_INT64(L, sqlite3_value_int64(value)
                        , lua_pushlstring(L, (const char*)sqlite3_value_text(value)
                                            , sqlite3_value_bytes(value)));
            break;

        case SQLITE_FLOAT:
            lua_pushnumber(L, sqlite3_value_double(value));
            break;

        case SQLITE_BLOB:
            lua_pushlstring(L, (const char*)sqlite3_value_blob(value), sqlite3_value_bytes(value));
            break;

        case SQLITE_NULL:
            lua_pushnil(L);
            break;

        default:
            /* things done properly (SQLite + Lua SQLite)
            ** this should never happen */
            lua_pushnil(L);
            break;
    }
}

/*
** callback functions used when calling registered sql functions
*/

/* scalar function to be called
** callback params: context, values... */
static void db_sql_normal_function(sqlite3_context *context, int argc, sqlite3_value **argv) {
    sdb_func *func = (sdb_func*)sqlite3_user_data(context);
    lua_State *L = func->db->L;
    int n;
    lcontext *ctx;

    int top = lua_gettop(L);

    /* ensure there is enough space in the stack */
    lua_checkstack(L, argc + 3);

    lua_rawgeti(L, LUA_REGISTRYINDEX, func->fn_step);   /* function to call */

    if (!func->aggregate) {
        ctx = lsqlite_make_context(L); /* push context - used to set results */
    }
    else {
        /* reuse context userdata value */
        void *p = sqlite3_aggregate_context(context, 1);
        /* i think it is OK to use assume that using a light user data
        ** as an entry on LUA REGISTRY table will be unique */
        lua_pushlightuserdata(L, p);
        lua_rawget(L, LUA_REGISTRYINDEX);       /* context table */

        if (lua_isnil(L, -1)) { /* not yet created? */
            lua_pop(L, 1);
            ctx = lsqlite_make_context(L);
            lua_pushlightuserdata(L, p);
            lua_pushvalue(L, -2);
            lua_rawset(L, LUA_REGISTRYINDEX);
        }
        else
            ctx = lsqlite_getcontext(L, -1);
    }

    /* push params */
    for (n = 0; n < argc; ++n) {
        db_push_value(L, argv[n]);
    }

    /* set context */
    ctx->ctx = context;

    if (lua_pcall(L, argc + 1, 0, 0)) {
        const char *errmsg = lua_tostring(L, -1);
        int size = lua_strlen(L, -1);
        sqlite3_result_error(context, errmsg, size);
    }

    /* invalidate context */
    ctx->ctx = NULL;

    if (!func->aggregate) {
        luaL_unref(L, LUA_REGISTRYINDEX, ctx->ud);
    }

    lua_settop(L, top);
}

static void db_sql_finalize_function(sqlite3_context *context) {
    sdb_func *func = (sdb_func*)sqlite3_user_data(context);
    lua_State *L = func->db->L;
    void *p = sqlite3_aggregate_context(context, 1); /* minimal mem usage */
    lcontext *ctx;
    int top = lua_gettop(L);

    lua_rawgeti(L, LUA_REGISTRYINDEX, func->fn_finalize);   /* function to call */

    /* i think it is OK to use assume that using a light user data
    ** as an entry on LUA REGISTRY table will be unique */
    lua_pushlightuserdata(L, p);
    lua_rawget(L, LUA_REGISTRYINDEX);       /* context table */

    if (lua_isnil(L, -1)) { /* not yet created? - shouldn't happen in finalize function */
        lua_pop(L, 1);
        ctx = lsqlite_make_context(L);
        lua_pushlightuserdata(L, p);
        lua_pushvalue(L, -2);
        lua_rawset(L, LUA_REGISTRYINDEX);
    }
    else
        ctx = lsqlite_getcontext(L, -1);

    /* set context */
    ctx->ctx = context;

    if (lua_pcall(L, 1, 0, 0)) {
        sqlite3_result_error(context, lua_tostring(L, -1), -1);
    }

    /* invalidate context */
    ctx->ctx = NULL;

    /* cleanup context */
    luaL_unref(L, LUA_REGISTRYINDEX, ctx->ud);
    /* remove it from registry */
    lua_pushlightuserdata(L, p);
    lua_pushnil(L);
    lua_rawset(L, LUA_REGISTRYINDEX);

    lua_settop(L, top);
}

/*
** Register a normal function
** Params: db, function name, number arguments, [ callback | step, finalize], user data
** Returns: true on sucess
**
** Normal function:
** Params: context, params
**
** Aggregate function:
** Params of step: context, params
** Params of finalize: context
*/
static int db_register_function(lua_State *L, int aggregate) {
    sdb *db = lsqlite_checkdb(L, 1);
    const char *name;
    int args;
    int result;
    sdb_func *func;

    /* safety measure */
    if (aggregate) aggregate = 1;

    name = luaL_checkstring(L, 2);
    args = luaL_checkint(L, 3);
    luaL_checktype(L, 4, LUA_TFUNCTION);
    if (aggregate) luaL_checktype(L, 5, LUA_TFUNCTION);

    /* maybe an alternative way to allocate memory should be used/avoided */
    func = (sdb_func*)malloc(sizeof(sdb_func));
    if (func == NULL) {
        luaL_error(L, "out of memory");
    }

    result = sqlite3_create_function(
        db->db, name, args, SQLITE_UTF8, func,
        aggregate ? NULL : db_sql_normal_function,
        aggregate ? db_sql_normal_function : NULL,
        aggregate ? db_sql_finalize_function : NULL
    );

    if (result == SQLITE_OK) {
        /* safety measures for userdata field to be present in the stack */
        lua_settop(L, 5 + aggregate);

        /* save registered function in db function list */
        func->db = db;
        func->aggregate = aggregate;
        func->next = db->func;
        db->func = func;

        /* save the setp/normal function callback */
        lua_pushvalue(L, 4);
        func->fn_step = luaL_ref(L, LUA_REGISTRYINDEX);
        /* save user data */
        lua_pushvalue(L, 5+aggregate);
        func->udata = luaL_ref(L, LUA_REGISTRYINDEX);

        if (aggregate) {
            lua_pushvalue(L, 5);
            func->fn_finalize = luaL_ref(L, LUA_REGISTRYINDEX);
        }
        else
            func->fn_finalize = LUA_NOREF;
    }
    else {
        /* free allocated memory */
        free(func);
    }

    lua_pushboolean(L, result == SQLITE_OK ? 1 : 0);
    return 1;
}

static int db_create_function(lua_State *L) {
    return db_register_function(L, 0);
}

static int db_create_aggregate(lua_State *L) {
    return db_register_function(L, 1);
}

/* create_collation; contributed by Thomas Lauer
*/

typedef struct {
    lua_State *L;
    int ref;
} scc;

static int collwrapper(scc *co,int l1,const void *p1,
                        int l2,const void *p2) {
    int res=0;
    lua_State *L=co->L;
    lua_rawgeti(L,LUA_REGISTRYINDEX,co->ref);
    lua_pushlstring(L,(const char*)p1,l1);
    lua_pushlstring(L,(const char*)p2,l2);
    if (lua_pcall(L,2,1,0)==0) res=(int)lua_tonumber(L,-1);
    lua_pop(L,1);
    return res;
}

static void collfree(scc *co) {
    if (co) {
        luaL_unref(co->L,LUA_REGISTRYINDEX,co->ref);
        free(co);
    }
}

static int db_create_collation(lua_State *L) {
    sdb *db=lsqlite_checkdb(L,1);
    const char *collname=luaL_checkstring(L,2);
    scc *co=NULL;
    int (*collfunc)(scc *,int,const void *,int,const void *)=NULL;
    lua_settop(L,3); /* default args to nil, and exclude extras */
    if (lua_isfunction(L,3)) collfunc=collwrapper;
    else if (!lua_isnil(L,3))
        luaL_error(L,"create_collation: function or nil expected");
    if (collfunc != NULL) {
        co=(scc *)malloc(sizeof(scc)); /* userdata is a no-no as it
                                          will be garbage-collected */
        if (co) {
            co->L=L;
            /* lua_settop(L,3) above means we don't need: lua_pushvalue(L,3); */
            co->ref=luaL_ref(L,LUA_REGISTRYINDEX);
        }
        else luaL_error(L,"create_collation: could not allocate callback");
    }
    sqlite3_create_collation_v2(db->db, collname, SQLITE_UTF8,
        (void *)co,
        (int(*)(void*,int,const void*,int,const void*))collfunc,
        (void(*)(void*))collfree);
    return 0;
}

/* Thanks to Wolfgang Oertl...
*/
static int db_load_extension(lua_State *L) {
    sdb *db=lsqlite_checkdb(L,1);
    const char *extname=luaL_optstring(L,2,NULL);
    const char *entrypoint=luaL_optstring(L,3,NULL);
    int result;
    char *errmsg = NULL;

    if (extname == NULL) {
        result = sqlite3_enable_load_extension(db->db,0); /* disable extension loading */
    }
    else {
        sqlite3_enable_load_extension(db->db,1); /* enable extension loading */
        result = sqlite3_load_extension(db->db,extname,entrypoint,&errmsg);
    }

    if (result == SQLITE_OK) {
        lua_pushboolean(L,1);
        return 1;
    }

    lua_pushboolean(L,0); /* so, assert(load_extension(...)) works */
    lua_pushstring(L,errmsg);
    sqlite3_free(errmsg);
    return 2;
}

/*
** trace callback:
** Params: database, callback function, userdata
**
** callback function:
** Params: userdata, sql
*/
static void db_trace_callback(void *user, const char *sql) {
    sdb *db = (sdb*)user;
    lua_State *L = db->L;
    int top = lua_gettop(L);

    /* setup lua callback call */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->trace_cb);    /* get callback */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->trace_udata); /* get callback user data */
    lua_pushstring(L, sql); /* traced sql statement */

    /* call lua function */
    lua_pcall(L, 2, 0, 0);
    /* ignore any error generated by this function */

    lua_settop(L, top);
}

static int db_trace(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);

    if (lua_gettop(L) < 2 || lua_isnil(L, 2)) {
        luaL_unref(L, LUA_REGISTRYINDEX, db->trace_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->trace_udata);

        db->trace_cb =
        db->trace_udata = LUA_NOREF;

        /* clear trace handler */
        sqlite3_trace(db->db, NULL, NULL);
    }
    else {
        luaL_checktype(L, 2, LUA_TFUNCTION);

        /* make sure we have an userdata field (even if nil) */
        lua_settop(L, 3);

        luaL_unref(L, LUA_REGISTRYINDEX, db->trace_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->trace_udata);

        db->trace_udata = luaL_ref(L, LUA_REGISTRYINDEX);
        db->trace_cb = luaL_ref(L, LUA_REGISTRYINDEX);

        /* set trace handler */
        sqlite3_trace(db->db, db_trace_callback, db);
    }

    return 0;
}

#if !defined(LSQLITE_OMIT_UPDATE_HOOK) || !LSQLITE_OMIT_UPDATE_HOOK

/*
** update_hook callback:
** Params: database, callback function, userdata
**
** callback function:
** Params: userdata, {one of SQLITE_INSERT, SQLITE_DELETE, or SQLITE_UPDATE},
**          database name, table name (containing the affected row), rowid of the row
*/
static void db_update_hook_callback(void *user, int op, char const *dbname, char const *tblname, sqlite3_int64 rowid) {
    sdb *db = (sdb*)user;
    lua_State *L = db->L;
    int top = lua_gettop(L);

    /* setup lua callback call */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->update_hook_cb);    /* get callback */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->update_hook_udata); /* get callback user data */
    lua_pushinteger(L, op);
    lua_pushstring(L, dbname); /* update_hook database name */
    lua_pushstring(L, tblname); /* update_hook database name */

    PUSH_INT64(L, rowid, push_str64(L, rowid));

    /* call lua function */
    lua_pcall(L, 5, 0, 0);
    /* ignore any error generated by this function */

    lua_settop(L, top);
}

static int db_update_hook(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);

    if (lua_gettop(L) < 2 || lua_isnil(L, 2)) {
        luaL_unref(L, LUA_REGISTRYINDEX, db->update_hook_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->update_hook_udata);

        db->update_hook_cb =
        db->update_hook_udata = LUA_NOREF;

        /* clear update_hook handler */
        sqlite3_update_hook(db->db, NULL, NULL);
    }
    else {
        luaL_checktype(L, 2, LUA_TFUNCTION);

        /* make sure we have an userdata field (even if nil) */
        lua_settop(L, 3);

        luaL_unref(L, LUA_REGISTRYINDEX, db->update_hook_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->update_hook_udata);

        db->update_hook_udata = luaL_ref(L, LUA_REGISTRYINDEX);
        db->update_hook_cb = luaL_ref(L, LUA_REGISTRYINDEX);

        /* set update_hook handler */
        sqlite3_update_hook(db->db, db_update_hook_callback, db);
    }

    return 0;
}

/*
** commit_hook callback:
** Params: database, callback function, userdata
**
** callback function:
** Params: userdata
** Returned value: Return false or nil to continue the COMMIT operation normally.
**  return true (non false, non nil), then the COMMIT is converted into a ROLLBACK.
*/
static int db_commit_hook_callback(void *user) {
    sdb *db = (sdb*)user;
    lua_State *L = db->L;
    int top = lua_gettop(L);
    int rollback = 0;

    /* setup lua callback call */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->commit_hook_cb);    /* get callback */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->commit_hook_udata); /* get callback user data */

    /* call lua function */
    if (!lua_pcall(L, 1, 1, 0))
        rollback = lua_toboolean(L, -1); /* use result if there was no error */

    lua_settop(L, top);
    return rollback;
}

static int db_commit_hook(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);

    if (lua_gettop(L) < 2 || lua_isnil(L, 2)) {
        luaL_unref(L, LUA_REGISTRYINDEX, db->commit_hook_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->commit_hook_udata);

        db->commit_hook_cb =
        db->commit_hook_udata = LUA_NOREF;

        /* clear commit_hook handler */
        sqlite3_commit_hook(db->db, NULL, NULL);
    }
    else {
        luaL_checktype(L, 2, LUA_TFUNCTION);

        /* make sure we have an userdata field (even if nil) */
        lua_settop(L, 3);

        luaL_unref(L, LUA_REGISTRYINDEX, db->commit_hook_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->commit_hook_udata);

        db->commit_hook_udata = luaL_ref(L, LUA_REGISTRYINDEX);
        db->commit_hook_cb = luaL_ref(L, LUA_REGISTRYINDEX);

        /* set commit_hook handler */
        sqlite3_commit_hook(db->db, db_commit_hook_callback, db);
    }

    return 0;
}

/*
** rollback hook callback:
** Params: database, callback function, userdata
**
** callback function:
** Params: userdata
*/
static void db_rollback_hook_callback(void *user) {
    sdb *db = (sdb*)user;
    lua_State *L = db->L;
    int top = lua_gettop(L);

    /* setup lua callback call */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->rollback_hook_cb);    /* get callback */
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->rollback_hook_udata); /* get callback user data */

    /* call lua function */
    lua_pcall(L, 1, 0, 0);
    /* ignore any error generated by this function */

    lua_settop(L, top);
}

static int db_rollback_hook(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);

    if (lua_gettop(L) < 2 || lua_isnil(L, 2)) {
        luaL_unref(L, LUA_REGISTRYINDEX, db->rollback_hook_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->rollback_hook_udata);

        db->rollback_hook_cb =
        db->rollback_hook_udata = LUA_NOREF;

        /* clear rollback_hook handler */
        sqlite3_rollback_hook(db->db, NULL, NULL);
    }
    else {
        luaL_checktype(L, 2, LUA_TFUNCTION);

        /* make sure we have an userdata field (even if nil) */
        lua_settop(L, 3);

        luaL_unref(L, LUA_REGISTRYINDEX, db->rollback_hook_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->rollback_hook_udata);

        db->rollback_hook_udata = luaL_ref(L, LUA_REGISTRYINDEX);
        db->rollback_hook_cb = luaL_ref(L, LUA_REGISTRYINDEX);

        /* set rollback_hook handler */
        sqlite3_rollback_hook(db->db, db_rollback_hook_callback, db);
    }

    return 0;
}

#endif /* #if !defined(LSQLITE_OMIT_UPDATE_HOOK) || !LSQLITE_OMIT_UPDATE_HOOK */

#if !defined(SQLITE_OMIT_PROGRESS_CALLBACK) || !SQLITE_OMIT_PROGRESS_CALLBACK

/*
** progress handler:
** Params: database, number of opcodes, callback function, userdata
**
** callback function:
** Params: userdata
** returns: 0 to return immediatly and return SQLITE_ABORT, non-zero to continue
*/
static int db_progress_callback(void *user) {
    int result = 1; /* abort by default */
    sdb *db = (sdb*)user;
    lua_State *L = db->L;
    int top = lua_gettop(L);

    lua_rawgeti(L, LUA_REGISTRYINDEX, db->progress_cb);
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->progress_udata);

    /* call lua function */
    if (!lua_pcall(L, 1, 1, 0))
        result = lua_toboolean(L, -1);

    lua_settop(L, top);
    return result;
}

static int db_progress_handler(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);

    if (lua_gettop(L) < 2 || lua_isnil(L, 2)) {
        luaL_unref(L, LUA_REGISTRYINDEX, db->progress_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->progress_udata);

        db->progress_cb =
        db->progress_udata = LUA_NOREF;

        /* clear busy handler */
        sqlite3_progress_handler(db->db, 0, NULL, NULL);
    }
    else {
        int nop = luaL_checkint(L, 2);  /* number of opcodes */
        luaL_checktype(L, 3, LUA_TFUNCTION);

        /* make sure we have an userdata field (even if nil) */
        lua_settop(L, 4);

        luaL_unref(L, LUA_REGISTRYINDEX, db->progress_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->progress_udata);

        db->progress_udata = luaL_ref(L, LUA_REGISTRYINDEX);
        db->progress_cb = luaL_ref(L, LUA_REGISTRYINDEX);

        /* set progress callback */
        sqlite3_progress_handler(db->db, nop, db_progress_callback, db);
    }

    return 0;
}

#else /* #if !defined(SQLITE_OMIT_PROGRESS_CALLBACK) || !SQLITE_OMIT_PROGRESS_CALLBACK */

static int db_progress_handler(lua_State *L) {
    lua_pushliteral(L, "progress callback support disabled at compile time");
    lua_error(L);
    return 0;
}

#endif /* #if !defined(SQLITE_OMIT_PROGRESS_CALLBACK) || !SQLITE_OMIT_PROGRESS_CALLBACK */

/* Online Backup API */
#if 0
sqlite3_backup *sqlite3_backup_init(
  sqlite3 *pDest,                        /* Destination database handle */
  const char *zDestName,                 /* Destination database name */
  sqlite3 *pSource,                      /* Source database handle */
  const char *zSourceName                /* Source database name */
);
int sqlite3_backup_step(sqlite3_backup *p, int nPage);
int sqlite3_backup_finish(sqlite3_backup *p);
int sqlite3_backup_remaining(sqlite3_backup *p);
int sqlite3_backup_pagecount(sqlite3_backup *p);
#endif

struct sdb_bu {
    sqlite3_backup *bu;     /* backup structure */
};

static int cleanupbu(lua_State *L, sdb_bu *sbu) {

    if (!sbu->bu) return 0; /* already finished */

    /* remove table from registry */
    lua_pushlightuserdata(L, sbu->bu);
    lua_pushnil(L);
    lua_rawset(L, LUA_REGISTRYINDEX);

    lua_pushinteger(L, sqlite3_backup_finish(sbu->bu));
    sbu->bu = NULL;

    return 1;
}

static int lsqlite_backup_init(lua_State *L) {

    sdb *target_db = lsqlite_checkdb(L, 1);
    const char *target_nm = luaL_checkstring(L, 2);
    sdb *source_db = lsqlite_checkdb(L, 3);
    const char *source_nm = luaL_checkstring(L, 4);

    sqlite3_backup *bu = sqlite3_backup_init(target_db->db, target_nm, source_db->db, source_nm);

    if (NULL != bu) {
        sdb_bu *sbu = (sdb_bu*)lua_newuserdata(L, sizeof(sdb_bu));

        luaL_getmetatable(L, sqlite_bu_meta);
        lua_setmetatable(L, -2);        /* set metatable */
        sbu->bu = bu;

        /* create table from registry */
        /* to prevent referenced databases from being garbage collected while bu is live */
        lua_pushlightuserdata(L, bu);
        lua_createtable(L, 2, 0);
        /* add source and target dbs to table at indices 1 and 2 */
        lua_pushvalue(L, 1); /* target db */
        lua_rawseti(L, -2, 1);
        lua_pushvalue(L, 3); /* source db */
        lua_rawseti(L, -2, 2);
        /* put table in registry with key lightuserdata bu */
        lua_rawset(L, LUA_REGISTRYINDEX);

        return 1;
    }
    else {
        return 0;
    }
}

static sdb_bu *lsqlite_getbu(lua_State *L, int index) {
    sdb_bu *sbu = (sdb_bu*)luaL_checkudata(L, index, sqlite_bu_meta);
    if (sbu == NULL) luaL_typerror(L, index, "sqlite database backup");
    return sbu;
}

static sdb_bu *lsqlite_checkbu(lua_State *L, int index) {
    sdb_bu *sbu = lsqlite_getbu(L, index);
    if (sbu->bu == NULL) luaL_argerror(L, index, "attempt to use closed sqlite database backup");
    return sbu;
}

static int dbbu_gc(lua_State *L) {
    sdb_bu *sbu = lsqlite_getbu(L, 1);
    if (sbu->bu != NULL) {
        cleanupbu(L, sbu);
        lua_pop(L, 1);
    }
    /* else ignore if already finished */
    return 0;
}

static int dbbu_step(lua_State *L) {
    sdb_bu *sbu = lsqlite_checkbu(L, 1);
    int nPage = luaL_checkint(L, 2);
    lua_pushinteger(L, sqlite3_backup_step(sbu->bu, nPage));
    return 1;
}

static int dbbu_remaining(lua_State *L) {
    sdb_bu *sbu = lsqlite_checkbu(L, 1);
    lua_pushinteger(L, sqlite3_backup_remaining(sbu->bu));
    return 1;
}

static int dbbu_pagecount(lua_State *L) {
    sdb_bu *sbu = lsqlite_checkbu(L, 1);
    lua_pushinteger(L, sqlite3_backup_pagecount(sbu->bu));
    return 1;
}

static int dbbu_finish(lua_State *L) {
    sdb_bu *sbu = lsqlite_checkbu(L, 1);
    return cleanupbu(L, sbu);
}

/* end of Online Backup API */

/*
** busy handler:
** Params: database, callback function, userdata
**
** callback function:
** Params: userdata, number of tries
** returns: 0 to return immediatly and return SQLITE_BUSY, non-zero to try again
*/
static int db_busy_callback(void *user, int tries) {
    int retry = 0; /* abort by default */
    sdb *db = (sdb*)user;
    lua_State *L = db->L;
    int top = lua_gettop(L);

    lua_rawgeti(L, LUA_REGISTRYINDEX, db->busy_cb);
    lua_rawgeti(L, LUA_REGISTRYINDEX, db->busy_udata);
    lua_pushinteger(L, tries);

    /* call lua function */
    if (!lua_pcall(L, 2, 1, 0))
        retry = lua_toboolean(L, -1);

    lua_settop(L, top);
    return retry;
}

static int db_busy_handler(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);

    if (lua_gettop(L) < 2 || lua_isnil(L, 2)) {
        luaL_unref(L, LUA_REGISTRYINDEX, db->busy_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->busy_udata);

        db->busy_cb =
        db->busy_udata = LUA_NOREF;

        /* clear busy handler */
        sqlite3_busy_handler(db->db, NULL, NULL);
    }
    else {
        luaL_checktype(L, 2, LUA_TFUNCTION);
        /* make sure we have an userdata field (even if nil) */
        lua_settop(L, 3);

        luaL_unref(L, LUA_REGISTRYINDEX, db->busy_cb);
        luaL_unref(L, LUA_REGISTRYINDEX, db->busy_udata);

        db->busy_udata = luaL_ref(L, LUA_REGISTRYINDEX);
        db->busy_cb = luaL_ref(L, LUA_REGISTRYINDEX);

        /* set busy handler */
        sqlite3_busy_handler(db->db, db_busy_callback, db);
    }

    return 0;
}

static int db_busy_timeout(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    int timeout = luaL_checkint(L, 2);
    sqlite3_busy_timeout(db->db, timeout);

    /* if there was a timeout callback registered, it is now
    ** invalid/useless. free any references we may have */
    luaL_unref(L, LUA_REGISTRYINDEX, db->busy_cb);
    luaL_unref(L, LUA_REGISTRYINDEX, db->busy_udata);
    db->busy_cb =
    db->busy_udata = LUA_NOREF;

    return 0;
}

/*
** Params: db, sql, callback, user
** returns: code [, errmsg]
**
** Callback:
** Params: user, number of columns, values, names
** Returns: 0 to continue, other value will cause abort
*/
static int db_exec_callback(void* user, int columns, char **data, char **names) {
    int result = SQLITE_ABORT; /* abort by default */
    lua_State *L = (lua_State*)user;
    int n;

    int top = lua_gettop(L);

    lua_pushvalue(L, 3); /* function to call */
    lua_pushvalue(L, 4); /* user data */
    lua_pushinteger(L, columns); /* total number of rows in result */

    /* column values */
    lua_pushvalue(L, 6);
    for (n = 0; n < columns;) {
        lua_pushstring(L, data[n++]);
        lua_rawseti(L, -2, n);
    }

    /* columns names */
    lua_pushvalue(L, 5);
    if (lua_isnil(L, -1)) {
        lua_pop(L, 1);
        lua_createtable(L, columns, 0);
        lua_pushvalue(L, -1);
        lua_replace(L, 5);
        for (n = 0; n < columns;) {
            lua_pushstring(L, names[n++]);
            lua_rawseti(L, -2, n);
        }
    }

    /* call lua function */
    if (!lua_pcall(L, 4, 1, 0)) {

#if LUA_VERSION_NUM > 502
        if (lua_isinteger(L, -1))
            result = lua_tointeger(L, -1);
        else
#endif
        if (lua_isnumber(L, -1))
            result = lua_tonumber(L, -1);
    }

    lua_settop(L, top);
    return result;
}

static int db_exec(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    const char *sql = luaL_checkstring(L, 2);
    int result;
    char *errmsg = NULL;

    if (!lua_isnoneornil(L, 3)) {
        /* stack:
        **  3: callback function
        **  4: userdata
        **  5: column names
        **  6: reusable column values
        */
        luaL_checktype(L, 3, LUA_TFUNCTION);
        lua_settop(L, 4);   /* 'trap' userdata - nil extra parameters */
        lua_pushnil(L);     /* column names not known at this point */
        lua_newtable(L);    /* column values table */

        result = sqlite3_exec(db->db, sql, db_exec_callback, L, &errmsg);
    }
    else {
        /* no callbacks */
        result = sqlite3_exec(db->db, sql, NULL, NULL, &errmsg);
    }

    lua_pushinteger(L, result);
    if (errmsg) {
      lua_pushstring(L, errmsg);
      sqlite3_free(errmsg);
    }
    else
      lua_pushnil(L);

    return 2;
}

/*
** Params: db, sql
** returns: code, compiled length or error message
*/
static int db_prepare(lua_State *L) {
    int result;
    sdb *db = lsqlite_checkdb(L, 1);
    const char *sql = luaL_checkstring(L, 2);
    int sql_len = lua_strlen(L, 2);
    int offset = luaL_optinteger(L, 3, 0);
    const char *sqltail;
    sqlite3_stmt *vm;

    offset = offset<0 ? 0 : offset>sql_len ? sql_len : offset;
    result = sqlite3_prepare_v2(db->db, sql+offset, sql_len-offset+1, &vm, &sqltail);
    if (result == SQLITE_OK && vm != NULL)
        newvm(L, db)->vm = vm;
    else
        lua_pushnil(L);
    lua_pushinteger(L, result);
    lua_pushinteger(L, sqltail - sql);
    return 3;
}

static int db_do_next_row(lua_State *L, int packed) {
    int result;
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    sqlite3_stmt *vm;
    int columns;
    int i;

    result = stepvm(L, svm);
    vm = svm->vm; /* stepvm may change svm->vm if re-prepare is needed */
    svm->has_values = result == SQLITE_ROW ? 1 : 0;
    svm->columns = columns = sqlite3_data_count(vm);

    if (result == SQLITE_ROW) {
        if (packed) {
            if (packed == 1) {
                lua_createtable(L, columns, 0);
                for (i = 0; i < columns;) {
                    vm_push_column(L, vm, i);
                    lua_rawseti(L, -2, ++i);
                }
            }
            else {
                lua_createtable(L, 0, columns);
                for (i = 0; i < columns; ++i) {
                    lua_pushstring(L, sqlite3_column_name(vm, i));
                    vm_push_column(L, vm, i);
                    lua_rawset(L, -3);
                }
            }
            return 1;
        }
        else {
            lua_checkstack(L, columns);
            for (i = 0; i < columns; ++i)
                vm_push_column(L, vm, i);
            return svm->columns;
        }
    }

    if (svm->temp) {
        /* finalize and check for errors */
        result = sqlite3_finalize(vm);
        svm->vm = NULL;
        cleanupvm(L, svm);
    }
    else if (result == SQLITE_DONE) {
        result = sqlite3_reset(vm);
    }

    if (result != SQLITE_OK) {
        lua_pushstring(L, sqlite3_errmsg(svm->db->db));
        lua_error(L);
    }
    return 0;
}

static int db_next_row(lua_State *L) {
    return db_do_next_row(L, 0);
}

static int db_next_packed_row(lua_State *L) {
    return db_do_next_row(L, 1);
}

static int db_next_named_row(lua_State *L) {
    return db_do_next_row(L, 2);
}

static int dbvm_do_rows(lua_State *L, int(*f)(lua_State *)) {
    /* sdb_vm *svm =  */
    lsqlite_checkvm(L, 1);
    lua_pushvalue(L,1);
    lua_pushcfunction(L, f);
    lua_insert(L, -2);
    return 2;
}

static int dbvm_rows(lua_State *L) {
    return dbvm_do_rows(L, db_next_packed_row);
}

static int dbvm_nrows(lua_State *L) {
    return dbvm_do_rows(L, db_next_named_row);
}

static int dbvm_urows(lua_State *L) {
    return dbvm_do_rows(L, db_next_row);
}

static int dbvm_sql(lua_State *L) {
    sdb_vm *svm = lsqlite_checkvm(L, 1);
    lua_pushstring(L, sqlite3_sql(svm->vm));
    return 1;
}

static int db_do_rows(lua_State *L, int(*f)(lua_State *)) {
    sdb *db = lsqlite_checkdb(L, 1);
    const char *sql = luaL_checkstring(L, 2);
    sdb_vm *svm;
    lua_settop(L,2); /* db,sql is on top of stack for call to newvm */
    svm = newvm(L, db);
    svm->temp = 1;

    if (sqlite3_prepare_v2(db->db, sql, -1, &svm->vm, NULL) != SQLITE_OK) {
        lua_pushstring(L, sqlite3_errmsg(svm->db->db));
        if (cleanupvm(L, svm) == 1)
            lua_pop(L, 1); /* this should not happen since sqlite3_prepare_v2 will not set ->vm on error */
        lua_error(L);
    }

    lua_pushcfunction(L, f);
    lua_insert(L, -2);
    return 2;
}

static int db_rows(lua_State *L) {
    return db_do_rows(L, db_next_packed_row);
}

static int db_nrows(lua_State *L) {
    return db_do_rows(L, db_next_named_row);
}

/* unpacked version of db:rows */
static int db_urows(lua_State *L) {
    return db_do_rows(L, db_next_row);
}

static int db_tostring(lua_State *L) {
    char buff[32];
    sdb *db = lsqlite_getdb(L, 1);
    if (db->db == NULL)
        strcpy(buff, "closed");
    else
        sprintf(buff, "%p", lua_touserdata(L, 1));
    lua_pushfstring(L, "sqlite database (%s)", buff);
    return 1;
}

static int db_close(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushinteger(L, cleanupdb(L, db));
    return 1;
}

static int db_close_vm(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    /* cleanup temporary only tables? */
    int temp = lua_toboolean(L, 2);

    /* free associated virtual machines */
    lua_pushlightuserdata(L, db);
    lua_rawget(L, LUA_REGISTRYINDEX);

    /* close all used handles */
    lua_pushnil(L);
    while (lua_next(L, -2)) {
        sdb_vm *svm = (sdb_vm*) lua_touserdata(L, -2); /* key: vm; val: sql text */

        if ((!temp || svm->temp) && svm->vm)
        {
            sqlite3_finalize(svm->vm);
            svm->vm = NULL;
        }

        /* leave key in the stack */
        lua_pop(L, 1);
    }
    return 0;
}

/* From: Wolfgang Oertl
When using lsqlite3 in a multithreaded environment, each thread has a separate Lua
environment, but full userdata structures can't be passed from one thread to another.
This is possible with lightuserdata, however. See: lsqlite_open_ptr().
*/
static int db_get_ptr(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    lua_pushlightuserdata(L, db->db);
    return 1;
}

static int db_gc(lua_State *L) {
    sdb *db = lsqlite_getdb(L, 1);
    if (db->db != NULL) { /* ignore closed databases */
        if (db->close_mark == CM_NO_CLOSE_FROM_GC)
            db->close_mark = CM_CANNOT_CLOSE;
        cleanupdb(L, db);
    }
    return 0;
}

/* sqlite3_table_column_metadata binding
*/
static int db_column_metadata(lua_State *L) {
    int NotNull=0, PrimaryKey=0, Autoinc=0;
    char const *zDataType=NULL, *zCollSeq=NULL;
    sdb *db = lsqlite_getdb(L, 1);
    const char *zDbName = luaL_optstring(L, 2, NULL);
    const char *zTableName = luaL_checkstring(L, 3);
    const char *zColumnName = luaL_optstring(L, 4, NULL);

    int res = sqlite3_table_column_metadata(db->db, zDbName, zTableName,
        zColumnName, &zDataType, &zCollSeq, &NotNull, &PrimaryKey, &Autoinc);
    lua_pushinteger(L, res);
    lua_pushstring(L, zDataType);
    lua_pushstring(L, zCollSeq);
    lua_pushboolean(L, NotNull ? 1:0);
    lua_pushboolean(L, PrimaryKey ? 1:0);
    lua_pushboolean(L, Autoinc ? 1:0);
    return 6;
}

/*
** =======================================================
** General library functions
** =======================================================
*/

static int lsqlite_version(lua_State *L) {
    lua_pushstring(L, sqlite3_libversion());
    return 1;
}

static int lsqlite_complete(lua_State *L) {
    const char *sql = luaL_checkstring(L, 1);
    lua_pushboolean(L, sqlite3_complete(sql));
    return 1;
}

#ifndef _WIN32
static int lsqlite_temp_directory(lua_State *L) {
    const char *oldtemp = sqlite3_temp_directory;

    if (!lua_isnone(L, 1)) {
        const char *temp = luaL_optstring(L, 1, NULL);
        if (sqlite3_temp_directory) {
            sqlite3_free((char*)sqlite3_temp_directory);
        }
        if (temp) {
            sqlite3_temp_directory = sqlite3_mprintf("%s", temp);
        }
        else {
            sqlite3_temp_directory = NULL;
        }
    }
    lua_pushstring(L, oldtemp);
    return 1;
}
#endif

static int lsqlite_do_open(lua_State *L, const char *filename, int flags) {
    sdb *db = newdb(L, CM_CAN_CLOSE); /* create and leave in stack */

    if (SQLITE3_OPEN(filename, &db->db, flags) == SQLITE_OK) {
        /* database handle already in the stack - return it */
        return 1;
    }

    /* failed to open database */
    lua_pushnil(L);                             /* push nil */
    lua_pushinteger(L, sqlite3_errcode(db->db));
    lua_pushstring(L, sqlite3_errmsg(db->db));  /* push error message */

    /* clean things up */
    cleanupdb(L, db);

    /* return */
    return 3;
}

static int lsqlite_open(lua_State *L) {
    const char *filename = luaL_checkstring(L, 1);
    int flags = luaL_optinteger(L, 2, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
    return lsqlite_do_open(L, filename, flags);
}

static int lsqlite_open_memory(lua_State *L) {
    return lsqlite_do_open(L, ":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
}

/* From: Wolfgang Oertl
When using lsqlite3 in a multithreaded environment, each thread has a separate Lua
environment, but full userdata structures can't be passed from one thread to another.
This is possible with lightuserdata, however. See: db_get_ptr().
*/
static int lsqlite_open_ptr(lua_State *L) {
    sqlite3 *db_ptr;
    sdb *db;
    int rc;
    int close_mark;

    luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
    db_ptr = (sqlite3*) lua_touserdata(L, 1);
    close_mark = lua_toboolean(L, 2) ? CM_NO_CLOSE_FROM_GC : CM_CAN_CLOSE;
    /* This is the only API function that runs sqlite3SafetyCheck regardless of
     * SQLITE_ENABLE_API_ARMOR and does almost nothing (without an SQL
     * statement) */
    rc = sqlite3_exec(db_ptr, NULL, NULL, NULL, NULL);
    if (rc != SQLITE_OK)
        luaL_argerror(L, 1, "not a valid SQLite3 pointer");

    db = newdb(L, close_mark); /* create and leave in stack */
    db->db = db_ptr;
    return 1;
}

static int lsqlite_newindex(lua_State *L) {
    lua_pushliteral(L, "attempt to change readonly table");
    lua_error(L);
    return 0;
}

#ifndef LSQLITE_VERSION
/* should be defined in rockspec, but just in case... */
#define LSQLITE_VERSION "unknown"
#endif

/* Version number of this library
*/
static int lsqlite_lversion(lua_State *L) {
    lua_pushstring(L, LSQLITE_VERSION);
    return 1;
}

#if (SQLITE_VERSION_NUMBER >= 3007017)
/* sqlite3_strglob binding
*/
static int lsqlite_strglob(lua_State *L) {
    const char* zStr = luaL_checkstring(L, 1);
    const char* zGlob = luaL_checkstring(L, 2);
    lua_pushboolean(L, sqlite3_strglob(zGlob, zStr) == 0);
    return 1;
}
#endif

#if (SQLITE_VERSION_NUMBER >= 3010000)
/* sqlite3_strlike binding
*/
static int lsqlite_strlike(lua_State *L) {
    const char* zStr = luaL_checkstring(L, 1);
    const char* zGlob = luaL_checkstring(L, 2);
    const char* zEsc = luaL_optstring(L, 3, "");
    lua_pushboolean(L, sqlite3_strlike(zGlob, zStr, zEsc[0]) == 0);
    return 1;
}
#endif

/*
*/
static int db_open_blob(lua_State *L) {
    sdb *db = lsqlite_checkdb(L, 1);
    const char *zDb = luaL_optstring(L, 2, "main");
    const char *zTable = luaL_checkstring(L, 3);
    const char *zColumn = luaL_checkstring(L, 4);
    sqlite3_int64 iRow = (sqlite3_int64)luaL_checknumber(L, 5);
    int flags = luaL_optinteger(L, 6, 0);
    sqlite3_blob **ppBlob = (sqlite3_blob**)lua_newuserdata(L, sizeof(sqlite3_blob*));
    int ret = sqlite3_blob_open(db->db, zDb, zTable, zColumn, iRow, flags, ppBlob);
    if (ret == SQLITE_OK) {
        luaL_getmetatable(L, sqlite_blob_meta);
        lua_setmetatable(L, -2);
        return 1;
    }
    else {
        lua_pushnil(L);
        lua_pushinteger(L, ret);
        return 2;
    }
}

static sqlite3_blob **blob_getblob(lua_State *L, int index) {
    return (sqlite3_blob**)luaL_checkudata(L, index, sqlite_blob_meta);
}

static sqlite3_blob **blob_checkblob(lua_State *L, int index) {
    sqlite3_blob **pBlob = blob_getblob(L, index);
    if (*pBlob == NULL) luaL_argerror(L, index, "attempt to use closed blob handle");
    return pBlob;
}

static int blob_tostring(lua_State *L) {
    sqlite3_blob **ppBlob = blob_getblob(L, 1);
    if (*ppBlob)
        lua_pushfstring(L, "blob handle (%p)", *ppBlob);
    else
        lua_pushstring(L, "blob handle (closed)");
    return 1;
}

static int blob_close(lua_State *L) {
    sqlite3_blob **ppBlob = blob_checkblob(L, 1);
    int ret = sqlite3_blob_close(*ppBlob);
    *ppBlob = NULL;
    if (ret == SQLITE_OK) {
        lua_pushboolean(L, 1);
        return 1;
    }
    else {
        lua_pushnil(L);
        lua_pushinteger(L, ret);
        return 2;
    }
}

static int blob_gc(lua_State *L) {
    sqlite3_blob **ppBlob = blob_getblob(L, 1);
    sqlite3_blob_close(*ppBlob);
    *ppBlob = NULL;
    return 0;
}

static int blob_bytes(lua_State *L) {
    lua_pushinteger(L, sqlite3_blob_bytes(*blob_checkblob(L, 1)));
    return 1;
}

static int blob_read(lua_State *L) {
    int ret;
    void *buf;
    sqlite3_blob **ppBlob = blob_checkblob(L, 1);
    lua_Integer N = luaL_checkinteger(L, 2);
    lua_Integer iOffset = luaL_checkinteger(L, 3);
    if (N < 0) N = 0;
    if ((buf = malloc(N)) == NULL)
        return luaL_error(L, "insufficient memory");
    ret = sqlite3_blob_read(*ppBlob, buf, (int)N, (int)iOffset);
    if (ret == SQLITE_OK) {
        lua_pushlstring(L, (const char*)buf, N);
        free(buf);
        return 1;
    }
    else {
        free(buf);
        lua_pushnil(L);
        lua_pushinteger(L, ret);
        return 2;
    }
}

static int blob_write(lua_State *L) {
    int ret;
    size_t N;
    sqlite3_blob **ppBlob = blob_checkblob(L, 1);
    const char *str = luaL_checklstring(L, 2, &N);
    lua_Integer iOffset = luaL_checkinteger(L, 3);
    ret = sqlite3_blob_write(*ppBlob, str, (int)N, (int)iOffset);
    if (ret == SQLITE_OK) {
        lua_pushboolean(L, 1);
        return 1;
    }
    else {
        lua_pushnil(L);
        lua_pushinteger(L, ret);
        return 2;
    }
}

static int blob_reopen(lua_State *L) {
    sqlite3_blob **ppBlob = blob_checkblob(L, 1);
    sqlite3_int64 row = (sqlite3_int64)luaL_checknumber(L, 2);
    int ret = sqlite3_blob_reopen(*ppBlob, row);
    if (ret == SQLITE_OK) {
        lua_pushboolean(L, 1);
        return 1;
    }
    else {
        lua_pushnil(L);
        lua_pushinteger(L, ret);
        return 2;
    }
}

/*
** =======================================================
** The Virtual Table Mechanism
** (needs SQLite >= 3.26.0)
** =======================================================
*/

#if (SQLITE_VERSION_NUMBER >= 3026000)

/* module client data */
typedef struct {
    lua_State *L;
    sqlite3_module *module;
} module_client_data;

/* An instance of the virtual table */
typedef struct {
    sqlite3_vtab base; /* Base class. Must be first */
    lua_State *L;
} vtab_ext;

/* Virtual Table Cursor Object */
typedef struct {
    sqlite3_vtab_cursor base; /* Virtual table of this cursor */
    lua_State *L;
} cursor_ext;

static void SetVtabErrorMessage(vtab_ext *vtab)
{
    sqlite3_free(vtab->base.zErrMsg);
    vtab->base.zErrMsg = sqlite3_mprintf("%s", lua_tostring(vtab->L, -1));
}

static int GetNumField(lua_State *L, const char *field, double *num)
{
    int ret = 0;
    lua_getfield(L, -1, field);
    if (lua_type(L, -1) == LUA_TNUMBER) {
        *num = lua_tonumber(L, -1);
        ret = 1;
    }
    lua_pop(L, 1);
    return ret;
}

static int GetIntField(lua_State *L, const char *field, sqlite_int64 *num)
{
    int ret = 0;
    lua_getfield(L, -1, field);
    if (lua_type(L, -1) == LUA_TNUMBER) {
        *num = lua_tointeger(L, -1);
        ret = 1;
    }
    lua_pop(L, 1);
    return ret;
}

static int GetModuleFunc(lua_State *L, void* regkey, const char* funcname, char **pzErr)
{
    int top = lua_gettop(L);
    lua_pushlightuserdata(L, regkey);
    lua_rawget(L, LUA_REGISTRYINDEX);                    /* +1 */
    if (lua_istable(L, -1)) {
        lua_getfield(L, -1, funcname);                   /* +2 */
        if (lua_isfunction(L, -1)) {
            lua_remove(L, -2);                           /* +1 */
            return 1;
        }
    }
    if (pzErr)
      *pzErr = sqlite3_mprintf("function '%s' not found", funcname);
    lua_settop(L, top);  /* +0 */
    return 0;
}

static int GetModuleFunc2(vtab_ext *VT, const char *funcname)
{
    lua_State *L = VT->L;
    int top = lua_gettop(L);
    lua_pushlightuserdata(L, (void*)VT->base.pModule);
    lua_rawget(L, LUA_REGISTRYINDEX);
    if (lua_istable(L, -1)) {
        lua_getfield(L, -1, funcname);                   /* +2 */
        if (lua_isfunction(L, -1)) {
            lua_remove(L, -2);                           /* +1 */
            return 1;
        }
    }
    lua_settop(L, top);  /* +0 */
    return 0;
}

static int CreateOrConnect(
    const char *funcname,
    sqlite3 *db, void *pAux, int argc, const char* const* argv, sqlite3_vtab **ppVTab, char **pzErr)
{
    int ret = SQLITE_ERROR;
    module_client_data* client_data = (module_client_data*) pAux;
    lua_State *L = client_data->L;
    if (GetModuleFunc(L, client_data->module, funcname, pzErr)) {  /* +1 */
        int i;
        sdb* Sdb = newdb(L, CM_NO_CLOSE_FROM_GC); /* +2; convert raw db to userdata db */
        Sdb->db = db;
        lua_pushvalue(L, -2);                     /* +3; push function */
        lua_pushvalue(L, -2);                     /* +4; push db; prevent garbage collection */
        lua_createtable(L, argc, 0);              /* +5; push arguments */
        for (i=0; i<argc; i++) {
            lua_pushstring(L, argv[i]);
            lua_rawseti(L, -2, i+1);
        }
        if (0 == lua_pcall(L, 2, 2, 0)) {          /* +4 */
            if (lua_type(L,-2) != LUA_TNIL && lua_type(L,-1) == LUA_TSTRING) {
                vtab_ext* VT = (vtab_ext*)sqlite3_malloc(sizeof(vtab_ext));
                memset(VT, 0, sizeof(vtab_ext));
                VT->L = L;
                lua_pushlightuserdata(L, VT);      /* +5; keep "virtual Lua table" in the registry */
                lua_pushvalue(L, -3);              /* +6 */
                lua_rawset(L, LUA_REGISTRYINDEX);  /* +4 */
                *ppVTab = (sqlite3_vtab*) VT;
                sqlite3_declare_vtab(db, lua_tostring(L,-1));
                ret = SQLITE_OK;
            }
            else
                *pzErr = sqlite3_mprintf("%s(): invalid return values", funcname);
            lua_pop(L, 2);                         /* +2 */
        }
        else {
            *pzErr = sqlite3_mprintf("%s", lua_tostring(L, -1));
            lua_pop(L, 1);                         /* +2 */
        }
        lua_pop(L, 2);                             /* +0 */
    }
    return ret;
}

static int TableFunction1(const char *funcname, sqlite3_vtab *pVTab)
{
    int ret = SQLITE_ERROR;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    if (GetModuleFunc2(VT, funcname))
    {
        lua_pushlightuserdata(L, VT);      /* +2 */
        lua_rawget(L, LUA_REGISTRYINDEX);  /* +2 */
        if (0 == lua_pcall(L, 1, 1, 0)) {
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

static int TableFunction2(const char *funcname, sqlite3_vtab *pVTab, int savepoint)
{
    int ret = SQLITE_ERROR;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    if (GetModuleFunc2(VT, funcname))
    {
        lua_pushlightuserdata(L, VT);      /* +2 */
        lua_rawget(L, LUA_REGISTRYINDEX);  /* +2 */
        lua_pushinteger(L, savepoint);     /* +3 */
        if (0 == lua_pcall(L, 2, 1, 0)) {
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xCreate = function (db, args)
    @param db   : database handler (a userdata)
    @param args : array of arguments (a table)
    @return1 : representation of a virtual table (usually a Lua table)
    @return2 : SQL statement "CREATE TABLE ..." (a string)
*/
static int xCreate(sqlite3 *db, void *pAux, int argc, const char* const* argv,
             sqlite3_vtab **ppVTab, char **pzErr)
{
    return CreateOrConnect("xCreate", db, pAux, argc, argv, ppVTab, pzErr);
}

/*
  mod.xConnect = function (db, args)
    @param db   : database handler (a userdata)
    @param args : array of arguments (a table)
    @return1 : representation of a virtual table (usually a Lua table)
    @return2 : SQL statement "CREATE TABLE ..." (a string)
*/
static int xConnect(sqlite3 *db, void *pAux, int argc, const char* const* argv,
             sqlite3_vtab **ppVTab, char **pzErr)
{
    return CreateOrConnect("xConnect", db, pAux, argc, argv, ppVTab, pzErr);
}

/*
  mod.xBestIndex = function (vtable, aConstraint, aOrderBy) return { estimatedCost=1e6 } end
    @param vtable      : virtual table, Lua representation
    @param aConstraint : a table
    @param aOrderBy    : a table
    @return            : a table
*/
static int xBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info* pIdxInfo)
{
    int ret = SQLITE_ERROR;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    double dnum;
    sqlite_int64 inum;
    if (GetModuleFunc2(VT, "xBestIndex")) /* +1 */
    {
        int i;
        lua_pushlightuserdata(L, VT);
        lua_rawget(L, LUA_REGISTRYINDEX); /* +2 */

        lua_newtable(L); /* +3; aConstraint array */
        for (i=0; i<pIdxInfo->nConstraint; i++)
        {
            lua_newtable(L);
            lua_pushinteger(L, pIdxInfo->aConstraint[i].iColumn);
            lua_setfield(L, -2, "iColumn");
            lua_pushinteger(L, pIdxInfo->aConstraint[i].op);
            lua_setfield(L, -2, "op");
            lua_pushboolean(L, pIdxInfo->aConstraint[i].usable);
            lua_setfield(L, -2, "usable");
            lua_rawseti(L, -2, i+1);
        }

        lua_newtable(L); /* +4; aOrderBy array */
        for (i=0; i<pIdxInfo->nOrderBy; i++)
        {
            lua_newtable(L);
            lua_pushinteger(L, pIdxInfo->aOrderBy[i].iColumn);
            lua_setfield(L, -2, "iColumn");
            lua_pushboolean(L, pIdxInfo->aOrderBy[i].desc);
            lua_setfield(L, -2, "desc");
            lua_rawseti(L, -2, i+1);
        }

        if (0 == lua_pcall(L, 3, 1, 0))  /* +1 in both cases */
        {
            if (lua_istable(L, -1))
            {
                lua_getfield(L, -1, "aConstraintUsage"); /* Lua code may reuse aConstraint arg */
                if (lua_istable(L, -1)) {                /* to avoid creation of a few tables  */
                    for (i=0; i<pIdxInfo->nConstraint; i++) {
                        lua_rawgeti(L, -1, i+1);
                        if (lua_istable(L, -1)) {
                            if (GetIntField(L, "argvIndex", &inum))
                                pIdxInfo->aConstraintUsage->argvIndex = (int)inum;
                            lua_getfield(L, -1, "omit");
                            pIdxInfo->aConstraintUsage->omit = lua_toboolean(L, -1);
                            lua_pop(L, 1);
                        }
                        lua_pop(L, -1);
                    }
                }
                lua_pop (L, 1);

                if (GetIntField(L, "idxNum", &inum))
                    pIdxInfo->idxNum = (int)inum;

                lua_getfield(L, -1, "idxStr");
                if (lua_type(L, -1) == LUA_TSTRING) {
                    size_t len;
                    const char *p = lua_tolstring(L, -1, &len);
                    pIdxInfo->idxStr = (char*)sqlite3_malloc(len+1);
                    pIdxInfo->needToFreeIdxStr = 1;
                    memcpy(pIdxInfo->idxStr, p, len+1);
                }
                lua_pop (L, 1);

                if (GetIntField(L, "orderByConsumed", &inum))
                    pIdxInfo->orderByConsumed = (int)inum;

                if (GetNumField(L, "estimatedCost", &dnum))
                    pIdxInfo->estimatedCost = dnum;

                if (sqlite3_libversion_number() >= 3008002) {
                    if (GetIntField(L, "estimatedRows", &inum))
                        pIdxInfo->estimatedRows = inum;
                }
                if (sqlite3_libversion_number() >= 3009000) {
                    if (GetIntField(L, "idxFlags", &inum))
                        pIdxInfo->idxFlags = (int)inum;
                }
                if (sqlite3_libversion_number() >= 3010000) {
                    if (GetIntField(L, "colUsed", &inum))
                        pIdxInfo->colUsed = (sqlite3_uint64)inum;
                }

                ret = SQLITE_OK;
            }
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xDisconnect = function (vtable) ...... return 0 end
    @param vtable : virtual table, Lua representation
    @return       : integer
*/
static int xDisconnect(sqlite3_vtab *pVTab)
{
    return TableFunction1("xDisconnect", pVTab);
}

/*
  mod.xDestroy = function (vtable) ......  return 0 end
    @param vtable : virtual table, Lua representation
    @return       : integer
*/
static int xDestroy(sqlite3_vtab *pVTab)
{
    int ret = SQLITE_OK;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    if (GetModuleFunc2(VT, "xDestroy"))
    {
        lua_pushlightuserdata(L, VT);
        lua_rawget(L, LUA_REGISTRYINDEX);
        if (0 == lua_pcall(L, 1, 1, 0)) {
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    if (ret == SQLITE_OK) {
        lua_pushlightuserdata(L, VT);
        lua_pushnil(L);
        lua_rawset(L, LUA_REGISTRYINDEX);
        sqlite3_free(VT);
    }
    return ret;
}

/*
  mod.xOpen = function(vtable) return { vtable=vtable; ...... } end
    @param vtable : virtual table, Lua representation
    @return       : cursor, Lua representation
*/
static int xOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor)
{
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    if (GetModuleFunc2(VT, "xOpen"))      /* +1 */
    {
        lua_pushlightuserdata(L, VT);     /* +2 */
        lua_rawget(L, LUA_REGISTRYINDEX); /* +2 */
        if (0 == lua_pcall(L, 1, 1, 0))   /* +1 */
        {
            cursor_ext* CE = (cursor_ext*)sqlite3_malloc(sizeof(cursor_ext));
            memset(CE, 0, sizeof(cursor_ext));
            CE->L = L;
            lua_pushlightuserdata(L, CE);      /* +2; keep Lua cursor in the registry */
            lua_pushvalue(L, -2);              /* +3 */
            lua_rawset(L, LUA_REGISTRYINDEX);  /* +1 */
            lua_pop(L, 1);                     /* +0 */
            *ppCursor = (sqlite3_vtab_cursor*) CE;
            return SQLITE_OK;
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return SQLITE_ERROR;
}

/*
  mod.xClose = function(cursor) ......  return 0 end
    @param cursor : cursor, Lua representation
    @return       : integer
*/
static int xClose(sqlite3_vtab_cursor *pCursor)
{
    int ret = SQLITE_OK;
    cursor_ext *CE = (cursor_ext*) pCursor;
    vtab_ext *VT = (vtab_ext*) pCursor->pVtab;
    lua_State *L = CE->L;
    if (GetModuleFunc2(VT, "xClose"))
    {
        lua_pushlightuserdata(L, CE);
        lua_rawget(L, LUA_REGISTRYINDEX);
        if (0 == lua_pcall(L, 1, 1, 0)) {
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    if (ret == SQLITE_OK) {
        lua_pushlightuserdata(L, CE);
        lua_pushnil(L);
        lua_rawset(L, LUA_REGISTRYINDEX);
        sqlite3_free(CE);
    }
    return ret;
}

/*
  mod.xFilter = function(cursor, idxNum, idxStr, argc) ......  return 0 end
    @param cursor : cursor, Lua representation
    @param idxNum : search index
    @param idxStr : search index
    @param argc   : argument counter
    @param argv   : arguments (a table)
    @return       : integer
*/
static int xFilter(sqlite3_vtab_cursor *pCursor, int idxNum, const char *idxStr,
              int argc, sqlite3_value **argv)
{
    int ret = SQLITE_ERROR;
    cursor_ext *CE = (cursor_ext*) pCursor;
    vtab_ext *VT = (vtab_ext*) pCursor->pVtab;
    lua_State *L = CE->L;
    if (GetModuleFunc2(VT, "xFilter"))
    {
        int index;
        lua_pushlightuserdata(L, CE);
        lua_rawget(L, LUA_REGISTRYINDEX);  /* +2 */
        lua_pushinteger(L, idxNum);        /* +3 */
        lua_pushstring(L, idxStr);         /* +4 */
        lua_pushinteger(L, argc);          /* +5 */
        lua_newtable(L);                   /* +6 */
        for (index=0; index<argc; index++) {
            db_push_value(L, argv[index]);
            lua_rawseti(L, -2, index+1);
        }
        if (0 == lua_pcall(L, 5, 1, 0)) {  /* +1 */
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xNext = function(cursor) ...... return 0 end
    @param cursor : cursor, Lua representation
    @return       : integer
*/
static int xNext(sqlite3_vtab_cursor *pCursor)
{
    int ret = SQLITE_ERROR;
    cursor_ext *CE = (cursor_ext*) pCursor;
    vtab_ext *VT = (vtab_ext*) pCursor->pVtab;
    lua_State *L = CE->L;
    if (GetModuleFunc2((vtab_ext*)pCursor->pVtab, "xNext"))
    {
        lua_pushlightuserdata(L, CE);
        lua_rawget(L, LUA_REGISTRYINDEX);
        if (0 == lua_pcall(L, 1, 1, 0)) {
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xEof = function(cursor) ...... return true end
    @param cursor : cursor, Lua representation
    @return       : boolean
*/
static int xEof(sqlite3_vtab_cursor *pCursor)
{
    int ret = 1; /* default is true to avoid hanging */
    cursor_ext *CE = (cursor_ext*) pCursor;
    vtab_ext *VT = (vtab_ext*) pCursor->pVtab;
    lua_State *L = CE->L;
    if (GetModuleFunc2((vtab_ext*)pCursor->pVtab, "xEof"))
    {
        lua_pushlightuserdata(L, CE);
        lua_rawget(L, LUA_REGISTRYINDEX);
        if (0 == lua_pcall(L, 1, 1, 0))
            ret = lua_toboolean(L, -1);
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

enum {
    T_BLOB   =1,
    T_DOUBLE =2,
    T_INT    =3,
    T_INT64  =4,
    T_NULL   =5,
    T_TEXT   =6,
};

/*
  mod.xColumn = function(cursor, colnum)
    @param cursor : cursor, Lua representation
    @param colnum : column number
    @return1      : value type (integer)
    @return2      : value
*/
static int xColumn(sqlite3_vtab_cursor *pCursor, sqlite3_context *context, int nColNum)
{
    if (sqlite3_vtab_nochange(context))
        return SQLITE_OK;
    else {
        int ret = SQLITE_ERROR;
        cursor_ext *CE = (cursor_ext*) pCursor;
        vtab_ext *VT = (vtab_ext*) pCursor->pVtab;
        lua_State *L = CE->L;
        if (GetModuleFunc2(VT, "xColumn"))
        {
            lua_pushlightuserdata(L, CE);
            lua_rawget(L, LUA_REGISTRYINDEX);
            lua_pushinteger(L, nColNum);
            if (0 == lua_pcall(L, 2, 2, 0)) {
                sqlite3_int64 i64;
                size_t len;
                const char *str;
                switch(lua_tointeger(L, -2)) {
                    case T_BLOB:
                        if (lua_type(L, -1) == LUA_TSTRING) {
                            str = lua_tolstring(L, -1, &len);
                            sqlite3_result_blob(context, str, len, NULL);
                        }
                        break;
                    case T_DOUBLE:
                        sqlite3_result_double(context, lua_tonumber(L, -1));
                        break;
                    case T_INT:
                        sqlite3_result_int(context, lua_tointeger(L, -1));
                        break;
                    case T_INT64:
                        i64 = (sqlite3_int64)lua_tonumber(L, -1); /* possible data loss? */
                        sqlite3_result_int64(context, i64);
                        break;
                    case T_TEXT:
                        if (lua_type(L, -1) == LUA_TSTRING) {
                            str = lua_tolstring(L, -1, &len);
                            sqlite3_result_text(context, str, len, NULL);
                        }
                        break;
                    default:
                    case T_NULL:
                        sqlite3_result_null(context);
                        break;
                }
                lua_pop(L, 2);
                ret = SQLITE_OK;
            }
            else {
                SetVtabErrorMessage(VT);
                lua_pop(L, 1);
            }
        }
        return ret;
    }
}

/*
  mod.xRowid = function(cursor)
    @param cursor : cursor, Lua representation
    @return       : rowid (number) on success; nil on failure
*/
static int xRowid(sqlite3_vtab_cursor *pCursor, sqlite3_int64 *pRowid)
{
    int ret = SQLITE_ERROR;
    vtab_ext *VT = (vtab_ext*) pCursor->pVtab;
    cursor_ext *CE = (cursor_ext*) pCursor;
    lua_State *L = CE->L;
    if (GetModuleFunc2(VT, "xRowid")) {
        lua_pushlightuserdata(L, CE);
        lua_rawget(L, LUA_REGISTRYINDEX);
        if (0 == lua_pcall(L, 1, 1, 0)) {
            if (lua_type(L, -1) == LUA_TNUMBER) {
                *pRowid = (sqlite3_int64)lua_tonumber(L, -1);
                ret = SQLITE_OK;
            }
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xUpdate = function(vtable, rowid1, rowid2, argc, args)
    @param vtable : virtual table, Lua representation
    @param rowid1 : either number or nil
    @param rowid2 : either number or nil
    @param argc   : number of items in the following table or nil
    @param args   : arguments (either nil or array with length = number of columns),
                    Note: if some argument argN==false then its value should stay unchanged.
    @return1      : boolean
    @return2      : either number (rowid) or nil
*/
static int xUpdate(sqlite3_vtab *pVTab, int argc, sqlite3_value **argv, sqlite3_int64 *pRowid)
{
    int ret = SQLITE_ERROR;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    int top = lua_gettop(L);
    if (GetModuleFunc2(VT, "xUpdate"))
    {
        int index;
        lua_pushlightuserdata(L, VT);              /* +2 */
        lua_rawget(L, LUA_REGISTRYINDEX);          /* +2 */
        for (index=0; index<2; index++) {
            if (index < argc)
                db_push_value(L, argv[index]);
            else
                lua_pushnil(L);
        }                                          /* +4 */
        if (argc > 2) {
            lua_pushinteger(L, argc-2);            /* +5 */
            for (index=2; index<argc; index++) {
                sqlite3_value *arg = argv[index];
                if (index == 2)
                    lua_newtable(L);               /* +6 */
                if (sqlite3_value_nochange(arg))
                    lua_pushboolean(L, 0);     /* convention: false means "unchanged" */
                else
                    db_push_value(L, arg);
                lua_rawseti(L, -2, index-1);
            }
        }
        index = (argc <= 2) ? 3 : 5;
        if (0 == lua_pcall(L, index, 2, 0)) {
            if (lua_toboolean(L, -2)) {
                if (lua_type(L, -1) == LUA_TNUMBER)
                    *pRowid = (sqlite3_int64)lua_tonumber(L, -1); /* possible data loss */
                ret = SQLITE_OK;
            }
        }
        else
            SetVtabErrorMessage(VT);
    }
    lua_settop(L, top);
    return ret;
}

/*
  mod.xBegin = function(vtable)
    @param vtable : virtual table, Lua representation
    @return       : integer
*/
static int xBegin(sqlite3_vtab *pVTab)
{
    return TableFunction1("xBegin", pVTab);
}

/*
  mod.xSync = function(vtable)
    @param vtable : virtual table, Lua representation
    @return       : integer
*/
static int xSync(sqlite3_vtab *pVTab)
{
    return TableFunction1("xSync", pVTab);
}

/*
  mod.xCommit = function(vtable)
    @param vtable : virtual table, Lua representation
    @return       : integer
*/
static int xCommit(sqlite3_vtab *pVTab)
{
    return TableFunction1("xCommit", pVTab);
}

/*
  mod.xRollback = function(vtable)
    @param vtable : virtual table, Lua representation
    @return       : integer
*/
static int xRollback(sqlite3_vtab *pVTab)
{
    return TableFunction1("xRollback", pVTab);
}

/*
  NOT FINISHED.
*/
static int xFindFunction(sqlite3_vtab *pVTab, int nArg, const char *zName,
                     void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
                     void **ppArg)
{
    (void) pxFunc;
    (void) ppArg;

    int ret = 0;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    if (GetModuleFunc2(VT, "xFindFunction"))
    {
        lua_pushlightuserdata(L, VT);
        lua_rawget(L, LUA_REGISTRYINDEX);       /* +2 */
        lua_pushinteger(L, nArg);               /* +3 */
        lua_pushstring(L, zName);               /* +4 */
        if (0 == lua_pcall(L, 3, 1, 0)) {       /* +1 */
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xRename = function(vtable, zNew)
    @param vtable : virtual table, Lua representation
    @param vtable : new name (string)
    @return       : integer
*/
static int xRename(sqlite3_vtab *pVTab, const char *zNew)
{
    int ret = SQLITE_ERROR;
    vtab_ext *VT = (vtab_ext*) pVTab;
    lua_State *L = VT->L;
    if (GetModuleFunc2(VT, "xRename"))
    {
        lua_pushlightuserdata(L, VT);
        lua_rawget(L, LUA_REGISTRYINDEX);  /* +2 */
        lua_pushstring(L, zNew);           /* +3 */
        if (0 == lua_pcall(L, 2, 1, 0)) {  /* +1 */
            if (lua_type(L, -1) == LUA_TNUMBER)
                ret = lua_tointeger(L, -1);
        }
        else
            SetVtabErrorMessage(VT);
        lua_pop(L, 1);
    }
    return ret;
}

/*
  mod.xSavepoint = function(vtable, savepoint)
    @param vtable    : virtual table, Lua representation
    @param savepoint : integer
    @return          : integer
*/
static int xSavepoint(sqlite3_vtab *pVTab, int savepoint)
{
    return TableFunction2("xSavepoint", pVTab, savepoint);
}

/*
  mod.xRelease = function(vtable, savepoint)
    @param vtable    : virtual table, Lua representation
    @param savepoint : integer
    @return          : integer
*/
static int xRelease(sqlite3_vtab *pVTab, int savepoint)
{
    return TableFunction2("xRelease", pVTab, savepoint);
}

/*
  mod.xRollbackTo = function(vtable, savepoint)
    @param vtable    : virtual table, Lua representation
    @param savepoint : integer
    @return          : integer
*/
static int xRollbackTo(sqlite3_vtab *pVTab, int savepoint)
{
    return TableFunction2("xRollbackTo", pVTab, savepoint);
}

/*
  NOT FINISHED.
*/
static int xShadowName(const char *cc)
{
    (void) cc;
    return 0;
}

/*
  mod.DestroyModule = function()
    @return : nothing
*/
static void DestroyModule(void *data)
{
    module_client_data *client_data = (module_client_data*) data;
    lua_State *L = client_data->L;

    if (GetModuleFunc(L, client_data->module, "DestroyModule", NULL)) { /* use for debugging */
        if (0 != lua_pcall(L, 0, 0, 0))
            lua_pop(L, 1);
    }

    lua_pushlightuserdata(L, client_data->module); /* remove the module reference */
    lua_pushnil(L);
    lua_rawset(L, LUA_REGISTRYINDEX);
    lua_pushlightuserdata(L, L);        /* remove the thread reference */
    lua_pushnil(L);
    lua_rawset(L, LUA_REGISTRYINDEX);
    sqlite3_free(client_data->module);  /* free the module */
    sqlite3_free(client_data);          /* free the client data */
}

#define SETPOINTER(Name) {                 \
    lua_getfield(L, MODINDEX, #Name);      \
    if (lua_type(L, -1) == LUA_TFUNCTION)  \
        module->Name = Name;               \
    lua_pop(L, 1); }

/*
  -- This method is a binding of sqlite3_create_module() function.
  db:create_module(modname, modtable)
    @param db       : database connection (as created by sqlite3.open())
    @param modname  : module name; string
    @param modtable : table containing module's functions
    @return         : return value of sqlite3_create_module(); integer
*/
static int db_create_module(lua_State *L) {
    const int        MODINDEX = 3;
    int              ret;
    sqlite3_module * module;
    sdb            * Sdb;
    const char     * zName;
    module_client_data * client_data;

    Sdb = lsqlite_checkdb(L, 1);
    zName = luaL_checkstring(L, 2);
    luaL_checktype(L, MODINDEX, LUA_TTABLE);

    module = (sqlite3_module*) sqlite3_malloc(sizeof(sqlite3_module));
    memset(module, 0, sizeof(sqlite3_module));
    module->iVersion = 3;

    client_data = (module_client_data*) sqlite3_malloc(sizeof(module_client_data));
    client_data->module = module;
    client_data->L = L;

    lua_pushlightuserdata(L, module); /* for access from many callbacks */
    lua_pushvalue(L, MODINDEX);
    lua_rawset(L, LUA_REGISTRYINDEX);

    lua_pushlightuserdata(L, L); /* create a reference to the thread: */
    lua_pushthread(L);           /* the thread must not be GC'ed for as long as the module exists */
    lua_rawset(L, LUA_REGISTRYINDEX);

    /* Required methods, according to SQLite documentation */
    /* If some of them is NULL the application might crash */
    module->xConnect = xConnect;
    module->xBestIndex = xBestIndex;
    module->xDisconnect = xDisconnect;
    module->xDestroy = xDestroy;
    module->xOpen = xOpen;
    module->xClose = xClose;
    module->xFilter = xFilter;
    module->xNext = xNext;
    module->xEof = xEof;
    module->xColumn = xColumn;
    module->xRowid = xRowid;

    /* Optional methods */
    SETPOINTER(xCreate)
    SETPOINTER(xUpdate)
    SETPOINTER(xBegin)
    SETPOINTER(xSync)
    SETPOINTER(xCommit)
    SETPOINTER(xRollback)
    SETPOINTER(xFindFunction)
    SETPOINTER(xRename)
    SETPOINTER(xSavepoint)
    SETPOINTER(xRelease)
    SETPOINTER(xRollbackTo)
    SETPOINTER(xShadowName)

    ret = sqlite3_create_module_v2(Sdb->db, zName, module, client_data, DestroyModule);
    lua_pushinteger(L, ret);
    return 1;
}
#endif /* #if (SQLITE_VERSION_NUMBER >= 3026000) */

/*
** =======================================================
** Register functions
** =======================================================
*/

#define SC(s)   { #s, SQLITE_ ## s },
#define LSC(s)  { #s, LSQLITE_ ## s },

static const struct {
    const char* name;
    int value;
} sqlite_constants[] = {
    /* error codes */
    SC(OK)          SC(ERROR)       SC(INTERNAL)    SC(PERM)
    SC(ABORT)       SC(BUSY)        SC(LOCKED)      SC(NOMEM)
    SC(READONLY)    SC(INTERRUPT)   SC(IOERR)       SC(CORRUPT)
    SC(NOTFOUND)    SC(FULL)        SC(CANTOPEN)    SC(PROTOCOL)
    SC(EMPTY)       SC(SCHEMA)      SC(TOOBIG)      SC(CONSTRAINT)
    SC(MISMATCH)    SC(MISUSE)      SC(NOLFS)
    SC(FORMAT)      SC(NOTADB)

    /* sqlite_step specific return values */
    SC(RANGE)       SC(ROW)         SC(DONE)

    /* column types */
    SC(INTEGER)     SC(FLOAT)       SC(TEXT)        SC(BLOB)
    SC(NULL)

    /* Authorizer Action Codes */
    SC(CREATE_INDEX       )
    SC(CREATE_TABLE       )
    SC(CREATE_TEMP_INDEX  )
    SC(CREATE_TEMP_TABLE  )
    SC(CREATE_TEMP_TRIGGER)
    SC(CREATE_TEMP_VIEW   )
    SC(CREATE_TRIGGER     )
    SC(CREATE_VIEW        )
    SC(DELETE             )
    SC(DROP_INDEX         )
    SC(DROP_TABLE         )
    SC(DROP_TEMP_INDEX    )
    SC(DROP_TEMP_TABLE    )
    SC(DROP_TEMP_TRIGGER  )
    SC(DROP_TEMP_VIEW     )
    SC(DROP_TRIGGER       )
    SC(DROP_VIEW          )
    SC(INSERT             )
    SC(PRAGMA             )
    SC(READ               )
    SC(SELECT             )
    SC(TRANSACTION        )
    SC(UPDATE             )
    SC(ATTACH             )
    SC(DETACH             )
    SC(ALTER_TABLE        )
    SC(REINDEX            )
    SC(ANALYZE            )
    SC(CREATE_VTABLE      )
    SC(DROP_VTABLE        )
    SC(FUNCTION           )
    SC(SAVEPOINT          )

    /* file open flags */
    SC(OPEN_READONLY)
    SC(OPEN_READWRITE)
    SC(OPEN_CREATE)
    SC(OPEN_URI)
    SC(OPEN_MEMORY)
    SC(OPEN_NOMUTEX)
    SC(OPEN_FULLMUTEX)
    SC(OPEN_SHAREDCACHE)
    SC(OPEN_PRIVATECACHE)

    /* terminator */
    { NULL, 0 }
};

/* ======================================================= */

static const luaL_Reg dblib[] = {
    {"isopen",              db_isopen               },
    {"last_insert_rowid",   db_last_insert_rowid    },
    {"changes",             db_changes              },
    {"total_changes",       db_total_changes        },
    {"errcode",             db_errcode              },
    {"error_code",          db_errcode              },
    {"errmsg",              db_errmsg               },
    {"error_message",       db_errmsg               },
    {"extended_errcode",    db_extended_errcode     },
    {"extended_result_codes", db_extended_result_codes },
    {"interrupt",           db_interrupt            },
    {"open_blob",           db_open_blob            },
#if (SQLITE_VERSION_NUMBER >= 3007010)
    {"db_filename",         db_db_filename          },
#endif

    {"create_function",     db_create_function      },
    {"create_aggregate",    db_create_aggregate     },
    {"create_collation",    db_create_collation     },
    {"load_extension",      db_load_extension       },
#if (SQLITE_VERSION_NUMBER >= 3026000)
    {"create_module",       db_create_module        },
#endif

    {"trace",               db_trace                },
    {"progress_handler",    db_progress_handler     },
    {"busy_timeout",        db_busy_timeout         },
    {"busy_handler",        db_busy_handler         },
#if !defined(LSQLITE_OMIT_UPDATE_HOOK) || !LSQLITE_OMIT_UPDATE_HOOK
    {"update_hook",         db_update_hook          },
    {"commit_hook",         db_commit_hook          },
    {"rollback_hook",       db_rollback_hook        },
#endif

    {"prepare",             db_prepare              },
    {"rows",                db_rows                 },
    {"urows",               db_urows                },
    {"nrows",               db_nrows                },

    {"exec",                db_exec                 },
    {"execute",             db_exec                 },
    {"close",               db_close                },
    {"close_vm",            db_close_vm             },
    {"get_ptr",             db_get_ptr              },

    {"__tostring",          db_tostring             },
    {"__gc",                db_gc                   },
    {"column_metadata",     db_column_metadata      },

    {NULL, NULL}
};

static const luaL_Reg vmlib[] = {
    {"isopen",              dbvm_isopen             },

    {"step",                dbvm_step               },
    {"reset",               dbvm_reset              },
    {"finalize",            dbvm_finalize           },

    {"columns",             dbvm_columns            },

    {"bind",                dbvm_bind               },
    {"bind_values",         dbvm_bind_values        },
    {"bind_names",          dbvm_bind_names         },
    {"bind_blob",           dbvm_bind_blob          },
    {"bind_zeroblob",       dbvm_bind_zeroblob      },
    {"bind_parameter_count",dbvm_bind_parameter_count},
    {"bind_parameter_name", dbvm_bind_parameter_name},

    {"get_value",           dbvm_get_value          },
    {"get_values",          dbvm_get_values         },
    {"get_name",            dbvm_get_name           },
    {"get_names",           dbvm_get_names          },
    {"get_type",            dbvm_get_type           },
    {"get_types",           dbvm_get_types          },
    {"get_column_type",     dbvm_get_column_type    },
    {"get_column_text",     dbvm_get_column_text    },
    {"get_column_int",      dbvm_get_column_int     },
    {"get_uvalues",         dbvm_get_uvalues        },
    {"get_unames",          dbvm_get_unames         },
    {"get_utypes",          dbvm_get_utypes         },
    {"sql",                 dbvm_sql                },

    {"get_named_values",    dbvm_get_named_values   },
    {"get_named_types",     dbvm_get_named_types    },

    {"rows",                dbvm_rows               },
    {"urows",               dbvm_urows              },
    {"nrows",               dbvm_nrows              },

    {"last_insert_rowid",   dbvm_last_insert_rowid  },

    /* compatibility names (added by request) */
    {"idata",               dbvm_get_values         },
    {"inames",              dbvm_get_names          },
    {"itypes",              dbvm_get_types          },
    {"data",                dbvm_get_named_values   },
    {"type",                dbvm_get_named_types    },

    {"__tostring",          dbvm_tostring           },
    {"__gc",                dbvm_gc                 },

    { NULL, NULL }
};

static const luaL_Reg ctxlib[] = {
    {"user_data",               lcontext_user_data              },

    {"get_aggregate_data",      lcontext_get_aggregate_context  },
    {"set_aggregate_data",      lcontext_set_aggregate_context  },
    {"aggregate_count",         lcontext_aggregate_count        },

    {"result",                  lcontext_result                 },
    {"result_null",             lcontext_result_null            },
    {"result_number",           lcontext_result_double          },
    {"result_double",           lcontext_result_double          },
    {"result_int",              lcontext_result_int             },
    {"result_text",             lcontext_result_text            },
    {"result_blob",             lcontext_result_blob            },
    {"result_error",            lcontext_result_error           },

    {"__tostring",              lcontext_tostring               },
    {NULL, NULL}
};

static const luaL_Reg dbbulib[] = {

    {"step",        dbbu_step       },
    {"remaining",   dbbu_remaining  },
    {"pagecount",   dbbu_pagecount  },
    {"finish",      dbbu_finish     },

/*  {"__tostring",  dbbu_tostring   }, */
    {"__gc",        dbbu_gc         },
    {NULL, NULL}
};

static const luaL_Reg bloblib[] = {
    {"__gc",        blob_gc         },
    {"__tostring",  blob_tostring   },
    {"bytes",       blob_bytes      },
    {"close",       blob_close      },
    {"read",        blob_read       },
    {"reopen",      blob_reopen     },
    {"write",       blob_write      },
    {NULL, NULL}
};

static const luaL_Reg sqlitelib[] = {
    {"lversion",        lsqlite_lversion        },
    {"version",         lsqlite_version         },
    {"complete",        lsqlite_complete        },
#ifndef _WIN32
    {"temp_directory",  lsqlite_temp_directory  },
#endif
    {"open",            lsqlite_open            },
    {"open_memory",     lsqlite_open_memory     },
    {"open_ptr",        lsqlite_open_ptr        },

    {"backup_init",     lsqlite_backup_init     },
#if (SQLITE_VERSION_NUMBER >= 3007017)
    {"strglob",         lsqlite_strglob         },
#endif
#if (SQLITE_VERSION_NUMBER >= 3010000)
    {"strlike",         lsqlite_strlike         },
#endif
    {"__newindex",      lsqlite_newindex        },
    {NULL, NULL}
};

static void create_meta(lua_State *L, const char *name, const luaL_Reg *lib) {
    luaL_newmetatable(L, name);
    lua_pushstring(L, "__index");
    lua_pushvalue(L, -2);               /* push metatable */
    lua_rawset(L, -3);                  /* metatable.__index = metatable */

    /* register metatable functions */
    luaL_openlib(L, NULL, lib, 0);

    /* remove metatable from stack */
    lua_pop(L, 1);
}

LUALIB_API int luaopen_lsqlite3(lua_State *L) {
    create_meta(L, sqlite_meta, dblib);
    create_meta(L, sqlite_vm_meta, vmlib);
    create_meta(L, sqlite_bu_meta, dbbulib);
    create_meta(L, sqlite_ctx_meta, ctxlib);
    create_meta(L, sqlite_blob_meta, bloblib);

    /* register (local) sqlite metatable */
    lua_newtable(L);
    luaL_register(L, NULL, sqlitelib);

    {
        int i = 0;
        /* add constants to global table */
        while (sqlite_constants[i].name) {
            lua_pushstring(L, sqlite_constants[i].name);
            lua_pushinteger(L, sqlite_constants[i].value);
            lua_rawset(L, -3);
            ++i;
        }
    }

    /* set sqlite's metatable to itself - set as readonly (__newindex) */
    lua_pushvalue(L, -1);
    lua_setmetatable(L, -2);

    return 1;
}