libluasqlite3.c

Go to the documentation of this file.

/*

lua-sqlite3 does not directly work for us. For one thing, we do not
want the user to be able to choose what database to open. The database
to access is our LogDb, and access to anything else is not to be
allowed. (ConfigDb database is not to be accessed directly at all.)

lua-sqlite3 ought to nonetheless be as good a starting point as any
for implementing the access we require.

LogDb access is also to be controlled quite carefully, and also, any
requirements for mutex access are to be implemented. Unfortunately, to
allow for interactive sessions, we cannot just go and lock the
database for the duration of any user session. Luckily, on Symbian we
presently have no need for MT, and Symbian's SQL Engine presumably
supports locking at the database level. And a proper SQLite library on
Linux should support locking. So there may be little that we have to
do when it comes to protection against concurrent modification, but
better keep this in mind.

Note that most of the lua-sqlite3 functions like to just return an
error code, and are meant to be used with a Lua wrapper, I suppose. We
do not intend to use any wrapper, and hence shall be changing this for
any functions that we are planning to use. We shall be creating Lua
VMs left and right, and we want that to stay fast.

 */

// This file is derived from lua-sqlite3-0.4.1, used under the following
// license.
//
/*
 *  Author: Michael Roth <mroth@nessie.de>
 *
 *  Copyright (c) 2004, 2005, 2006 Michael Roth <mroth@nessie.de>
 *
 *  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 "libluasqlite3.h"

#include "ac_app_context.h"
#include "ld_private.h"
#include "sqlite_cl2.h"

#include "lua.h"
#include "lauxlib.h"

#include <stdio.h>




#define IS_INT(n)   ( ( (lua_Number) ((int)(n)) )  == (n) )

#define CAST(type, arg)   ( (type)(arg) )

#define FUNC(name)    static int name (lua_State * L)



#define CB_DATA(ptr)    CAST(CB_Data *, (ptr))

#define KEY(ptr, id)    CAST( void*, CAST(char*,(ptr))+(id) )

#define KEY_KEY2VALUE_TABLE(p)  KEY((p), 1)
#define KEY_FUNCTION_TABLE(p) KEY((p), 2)
#define KEY_COLLATION_TABLE(p)  KEY((p), 3)
#define KEY_COLLNEEDED_DATA(p)  KEY((p), 4)
#define KEY_AUTHORIZER_DATA(p)  KEY((p), 5)
#define KEY_PROGRESS_DATA(p)  KEY((p), 6)
#define KEY_TRACE_DATA(p) KEY((p), 7)
#define KEY_BUSY_DATA(p)  KEY((p), 8)
#define KEY_COMMIT_DATA(p)  KEY((p), 9)

#define KEY_XFUNC(p)    KEY((p), 1)
#define KEY_XSTEP(p)    KEY((p), 2)
#define KEY_XFINAL(p)   KEY((p), 3)
#define KEY_XCOMPARE(p)   KEY((p), 1)
#define KEY_XNEEDED(p)    KEY((p), 1)
#define KEY_XAUTH(p)    KEY((p), 1)
#define KEY_XPROGRESS(p)  KEY((p), 1)
#define KEY_XTRACE(p)   KEY((p), 1)
#define KEY_XBUSY(p)    KEY((p), 1)
#define KEY_XCOMMIT(p)    KEY((p), 1)



typedef struct
{
  sqlite3 *   kr_db;
  lua_State *   L;
  int   key2value_pos;  /* Used by callback wrappers to find the key2value array on the lua stack */
} DB;


typedef struct
{
  DB * db;
  sqlite3_stmt * stmt;
} Stmt;


typedef struct
{
  DB * db;
} CB_Data;






static void push_private_table(lua_State * L, void * table_key);
static void delete_private_value(lua_State * L, void * value_key);

static CB_Data * new_cb_data(lua_State * L, DB * db);
static CB_Data * get_cb_data(lua_State * L, DB * db, void * data_key);
static CB_Data * get_named_cb_data(lua_State * L, DB * db, void * table_key, int name_pos);

#define get_function_cb_data(L, db, name_pos) get_named_cb_data((L), (db), KEY_FUNCTION_TABLE(db), name_pos)
#define get_collation_cb_data(L, db, name_pos)  get_named_cb_data((L), (db), KEY_COLLATION_TABLE(db), name_pos)
#define get_collneeded_cb_data(L, db)   get_cb_data((L), (db), KEY_COLLNEEDED_DATA(db))
#define get_authorizer_cb_data(L, db)   get_cb_data((L), (db), KEY_AUTHORIZER_DATA(db))
#define get_progress_cb_data(L, db)   get_cb_data((L), (db), KEY_PROGRESS_DATA(db))
#define get_trace_cb_data(L, db)    get_cb_data((L), (db), KEY_TRACE_DATA(db))
#define get_busy_cb_data(L, db)     get_cb_data((L), (db), KEY_BUSY_DATA(db))
#define get_commit_cb_data(L, db)   get_cb_data((L), (db), KEY_COMMIT_DATA(db))

static void register_callback(lua_State * L, DB * db, void * cb_key, int callback_pos);
static void init_callback_usage(lua_State * L, DB * db);
static void push_callback(lua_State * L, DB * db, void * cb_key);

static int pop_break_condition(lua_State * L);
static void push_nil_or_string(lua_State * L, const char * str);




static void push_private_table(lua_State * L, void * table_key)
{
  lua_pushlightuserdata(L, table_key);
  lua_rawget(L, LUA_REGISTRYINDEX);
  if (lua_isnil(L, -1))
  {
    lua_pop(L, 1);
    lua_newtable(L);
    lua_pushlightuserdata(L, table_key);
    lua_pushvalue(L, -2);
    lua_rawset(L, LUA_REGISTRYINDEX);
  }
}


static void delete_private_value(lua_State * L, void * value_key)
{
  lua_pushlightuserdata(L, value_key);
  lua_rawget(L, LUA_REGISTRYINDEX);
  if (!lua_isnil(L, -1))
  {
    lua_pushlightuserdata(L, value_key);
    lua_pushnil(L);
    lua_rawset(L, LUA_REGISTRYINDEX);
  }
  lua_pop(L, 1);
}


static CB_Data * new_cb_data(lua_State * L, DB * db)
{
  CB_Data * cb_data = lua_newuserdata(L, sizeof(CB_Data));
  cb_data->db = db;
  return cb_data;
}


static CB_Data * get_cb_data(lua_State * L, DB * db, void * data_key)
{
  CB_Data * cb_data;
  
  lua_pushlightuserdata(L, data_key);
  lua_rawget(L, LUA_REGISTRYINDEX);
  
  if (lua_isnil(L, -1))
  {
    lua_pushlightuserdata(L, data_key);
    cb_data = new_cb_data(L, db);
    lua_rawset(L, LUA_REGISTRYINDEX);
  }
  else
    cb_data = lua_touserdata(L, -1);
  
  lua_pop(L, 1);
  return cb_data;
}


static CB_Data * get_named_cb_data(lua_State * L, DB * db, void * table_key, int name_pos)
{
  CB_Data * cb_data;
  
  push_private_table(L, table_key);
  lua_pushvalue(L, name_pos);
  lua_rawget(L, -2);
  
  if (lua_isnil(L, -1))
  {
    lua_pushvalue(L, name_pos);
    cb_data = new_cb_data(L, db);
    lua_rawset(L, LUA_REGISTRYINDEX);
  }
  else
    cb_data = lua_touserdata(L, -1);
  
  lua_pop(L, 2);
  return cb_data;
}


static void register_callback(lua_State * L, DB * db, void * cb_key, int callback_pos)
{
  push_private_table(L, KEY_KEY2VALUE_TABLE(db));
  lua_pushlightuserdata(L, cb_key);
  lua_pushvalue(L, callback_pos);
  lua_rawset(L, -3);
  lua_pop(L, 1);
}


static void init_callback_usage(lua_State * L, DB * db)
{
  db->L = L;
  db->key2value_pos = 0;  /* lazy initialized in push_callback() */
}


static void push_callback(lua_State * L, DB * db, void * cb_key)
{
  if (db->key2value_pos == 0) /* lazy initializing of the key2value table */
  {
    push_private_table(L, KEY_KEY2VALUE_TABLE(db));
    db->key2value_pos = lua_gettop(L);
  }
  
  lua_pushlightuserdata(L, cb_key);
  lua_rawget(L, db->key2value_pos);
}


static int pop_break_condition(lua_State * L)
{
  int result;
  
  if (lua_isnil(L, -1))
    result = 0;
  else if (lua_isboolean(L, -1))
    result = lua_toboolean(L, -1);
  else if (lua_isnumber(L, -1))
    result = lua_tonumber(L, -1);
  else
    result = 1;
  
  lua_pop(L, 1);
  return result;
}


static void push_nil_or_string(lua_State * L, const char * str)
{
  if (str)
    lua_pushstring(L, str);
  else
    lua_pushnil(L);
}




/*
 *  Error Handling
 *  ==============
 *
 *  We try to work hard to be bullet proof. We even try to function 
 *  correctly in low memory situations.
 *  Usage errors of the API when detected raise an error also
 *  memory errors and such.
 *  Errors signaled from the sqlite library will result in the
 *  appropriate return codes.
 *
 */


static void report_error(lua_State * L, const char * msg)
{
  lua_settop(L, 0); /* Clear the stack to make sure, our error message will get a chance */
  lua_pushstring(L, msg);
  lua_error(L);
}



#define checkany(L, narg) ( luaL_checkany((L), (narg)) )
#define checkstr(L, narg) ( luaL_checklstring((L), (narg), 0) )
#define checknumber(L, narg)  ( luaL_checknumber((L), (narg)) )
#define checkint(L, narg) ( (int)   checknumber((L), (narg)) )
#define checkdouble(L, narg)  ( (double)  checknumber((L), (narg)) )

static void * checkudata(lua_State * L, int narg)
{
  if (!lua_isuserdata(L, narg))
    luaL_typerror(L, narg, "userdata");
  return lua_touserdata(L, narg);
}

#define checkcontext(L, narg) ( (sqlite3_context *) checkudata((L), (narg)) )
#define checkvalues(L, narg)  ( (sqlite3_value **)  checkudata((L), (narg)) )
#define checkstmt(L, narg)  ( (Stmt *)    checkudata((L), (narg)) )
#define checkdb(L, narg)  ( (DB *)    checkudata((L), (narg)) )

static sqlite3_stmt * checkstmt_stmt(lua_State * L, int narg)
{
  return checkstmt(L, narg)->stmt;
}

static sqlite3 * checkdb_sqlite3(lua_State * L, int narg)
{
  return checkdb(L, narg)->kr_db;
}

/*
static pthread_mutex_t* checkdb_mutex(lua_State * L, int narg)
{
  return &(checkdb(L, narg)->mutex);
}
*/

static int checknilornoneorfunc(lua_State * L, int narg)
{
  if (lua_isnil(L, narg) || lua_isnone(L, narg))
    return 0;
  if (lua_isfunction(L, narg))
    return 1;
  luaL_typerror(L, narg, "nil, none or function");
  return 0; /* never reached, make compiler happy... */
}






FUNC( l_sqlite3_bind_null )
{
  lua_pushnumber(L, sqlite3_bind_null(checkstmt_stmt(L, 1), checkint(L, 2)) );
  return 1;
}


FUNC( l_sqlite3_bind_text )
{
  lua_pushnumber(L, sqlite3_bind_text(checkstmt_stmt(L, 1), checkint(L, 2), checkstr(L, 3), lua_strlen(L, 3), SQLITE_TRANSIENT) );
  return 1;
}


FUNC( l_sqlite3_bind_blob )
{
  lua_pushnumber(L, sqlite3_bind_blob(checkstmt_stmt(L, 1), checkint(L, 2), checkstr(L, 3), lua_strlen(L, 3), SQLITE_TRANSIENT) );
  return 1;
}


FUNC( l_sqlite3_bind_int )
{
  lua_pushnumber(L, sqlite3_bind_int(checkstmt_stmt(L, 1), checkint(L, 2), checkint(L, 3)) );
  return 1;
}


FUNC( l_sqlite3_bind_double )
{
  lua_pushnumber(L, sqlite3_bind_double(checkstmt_stmt(L, 1), checkint(L, 2), checkdouble(L, 3)) );
  return 1;
}


FUNC( l_sqlite3_bind_number )
{
  sqlite3_stmt * stmt   = checkstmt_stmt(L, 1);
  int index     = checkint(L, 2);
  lua_Number number   = checknumber(L, 3);
  
  if (IS_INT(number))
    lua_pushnumber(L, sqlite3_bind_int(stmt, index, (int)number) );
  else
    lua_pushnumber(L, sqlite3_bind_double(stmt, index, (double)number) );
  
  return 1;
}


FUNC( l_sqlite3_bind )
{
  sqlite3_stmt * stmt = checkstmt_stmt(L, 1);
  int index   = checkint(L, 2);
  
  switch(lua_type(L, 3))
  {
    case LUA_TNONE:
    case LUA_TNIL:
      lua_pushnumber(L, sqlite3_bind_null(stmt, index) );
      break;
    
    case LUA_TNUMBER:
      {
        lua_Number number = lua_tonumber(L, 3);
        
        if (IS_INT(number))
          lua_pushnumber(L, sqlite3_bind_int(stmt, index, (int)number) );
        else
          lua_pushnumber(L, sqlite3_bind_double(stmt, index, (double)number) );
      }
      break;
    
    case LUA_TBOOLEAN:
      if (lua_toboolean(L, 3))
        lua_pushnumber(L, sqlite3_bind_int(stmt, index, 1) );
      else
        lua_pushnumber(L, sqlite3_bind_int(stmt, index, 0) );
      break;
    
    case LUA_TSTRING:
      lua_pushnumber(L, sqlite3_bind_text(stmt, index, lua_tostring(L, 3), lua_strlen(L, 3), SQLITE_TRANSIENT) );
      break;
    
    default:
      luaL_argerror(L, 3, "nil, boolean, number or string expected");
  }
  
  return 1;
}


FUNC( l_sqlite3_bind_parameter_count )
{
  lua_pushnumber(L, sqlite3_bind_parameter_count(checkstmt_stmt(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_bind_parameter_name )
{
  const char * name = sqlite3_bind_parameter_name(checkstmt_stmt(L, 1), checkint(L, 2));
  if (name)
    lua_pushstring(L, name);
  else
    lua_pushnil(L);
  return 1;
}


FUNC( l_sqlite3_bind_parameter_name_x )
{
  const char * name = sqlite3_bind_parameter_name(checkstmt_stmt(L, 1), checkint(L, 2));
  if (name && *name)
    lua_pushstring(L, name + 1);  /* Ignore leading '$' or ':' */
  else
    lua_pushnil(L);
  return 1;
}


FUNC( l_sqlite3_busy_timeout )
{
  DB * db = checkdb(L, 1);
  int timeout = checkint(L, 2);
  
  delete_private_value(L, KEY_BUSY_DATA(db));
  
  lua_pushnumber(L, sqlite3_busy_timeout(db->kr_db, timeout) );
  return 1;
}


FUNC( l_sqlite3_changes )
{
  lua_pushnumber(L, sqlite3_changes(checkdb_sqlite3(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_close )
{
  DB * db = checkdb(L, 1); // xxx the arg need not be popped, apparently
  
  delete_private_value(L, KEY_KEY2VALUE_TABLE(db));
  delete_private_value(L, KEY_FUNCTION_TABLE(db));
  delete_private_value(L, KEY_COLLATION_TABLE(db));
  delete_private_value(L, KEY_COLLNEEDED_DATA(db));
  delete_private_value(L, KEY_AUTHORIZER_DATA(db));
  delete_private_value(L, KEY_PROGRESS_DATA(db));
  delete_private_value(L, KEY_TRACE_DATA(db));
  delete_private_value(L, KEY_BUSY_DATA(db));
  delete_private_value(L, KEY_COMMIT_DATA(db));

  // I suppose Lua will GC the actual DB struct.
  return 0;
}


typedef const char * (*column_text_blob_t)(sqlite3_stmt *, int);

static int l_sqlite3_column_text_or_blob(lua_State * L, column_text_blob_t column_text_blob)
{
  sqlite3_stmt * stmt =  checkstmt_stmt(L, 1);
  int column    = checkint(L, 2);
  
  lua_pushlstring(L,  column_text_blob(stmt, column), sqlite3_column_bytes(stmt, column));
  return 1;
}

FUNC( l_sqlite3_column_blob )
{
  return l_sqlite3_column_text_or_blob(L, (column_text_blob_t)sqlite3_column_blob);
}

FUNC( l_sqlite3_column_text )
{
  return l_sqlite3_column_text_or_blob(L, (column_text_blob_t)sqlite3_column_text); /* FIXME: remove cast when API changes!!! */
}


FUNC( l_sqlite3_column_int )
{
  lua_pushnumber(L, sqlite3_column_int(checkstmt_stmt(L, 1), checkint(L, 2)) );
  return 1;
}


FUNC( l_sqlite3_column_double )
{
  lua_pushnumber(L, sqlite3_column_double(checkstmt_stmt(L, 1), checkint(L, 2)) );
  return 1;
}


FUNC( l_sqlite3_column_number )
{
  sqlite3_stmt * stmt = checkstmt_stmt(L, 1);
  int column    = checkint(L, 2);
  
  if ( sqlite3_column_type(stmt, column) == SQLITE_INTEGER )
    lua_pushnumber(L, sqlite3_column_int(stmt, column) );
  else
    lua_pushnumber(L,sqlite3_column_double(stmt, column) );
  
  return 1;
}



  
static void push_column(lua_State * L, sqlite3_stmt * stmt, int column)
{
  switch(sqlite3_column_type(stmt, column))
  {
    case SQLITE_NULL:
      lua_pushnil(L);
      break;
    
    case SQLITE_INTEGER:
      lua_pushnumber(L, sqlite3_column_int(stmt, column));
      break;
    
    case SQLITE_FLOAT:
      lua_pushnumber(L, sqlite3_column_double(stmt, column));
      break;
    
    case SQLITE_TEXT:
      lua_pushlstring(L, (const char*)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column));
      break;
    
    case SQLITE_BLOB:
      lua_pushlstring(L, sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column));
      break;
    
    default:
      lua_pushboolean(L, 0);
  }
}


FUNC( l_sqlite3_column )
{
  push_column(L, checkstmt_stmt(L, 1), checkint(L, 2));
  return 1;
}


/*
 * mode: 0 = direct, 1 = integer, 2 = alphanumeric
 */
static int l_sqlite3_row_mode(lua_State * L, int mode)
{
  /* Old code / Just a reminder / To be removed: 
  ** checkargs(L, 1, 2, CHECK_PTR, CHECK_NILTABLE, 0);
  */
  
  sqlite3_stmt * stmt = checkstmt_stmt(L, 1);
  int num_columns = sqlite3_data_count(stmt); /* Maybe wrong state, so don't use sqlite3_column_count */
  int index;
  
  /* XXX Should really be cleaned up... Fixme! */
  
  if (mode == 0)
    lua_checkstack(L, num_columns);
  else
    if (!lua_istable(L, -1))
      lua_newtable(L);
  
  for (index=0; index<num_columns; index++)
    switch(mode)
    {
      case 0: /* direct mode */
        push_column(L, stmt, index);
        break;
      
      case 1: /* integer mode */
        push_column(L, stmt, index);
        lua_rawseti(L, -2, index+1);
        break;
      
      case 2: /* alphanumeric mode */
        lua_pushstring(L, sqlite3_column_name(stmt, index));
        push_column(L, stmt, index);
        lua_rawset(L, -3);
        break;
      
      default:
        report_error(L, "libluasqlite3: Internal error in sqlite3_row_mode");
    }
  
  if (mode)
    return 1;
  else
    return num_columns;
}

FUNC( l_sqlite3_drow )
{
  return l_sqlite3_row_mode(L, 0);
}

FUNC( l_sqlite3_irow )
{
  return l_sqlite3_row_mode(L, 1);
}

FUNC( l_sqlite3_arow )
{
  return l_sqlite3_row_mode(L, 2);
}


FUNC( l_sqlite3_column_type )
{
  lua_pushnumber(L, sqlite3_column_type(checkstmt_stmt(L, 1), checkint(L, 2)) );
  return 1;
}


FUNC( l_sqlite3_column_count )
{
  lua_pushnumber(L, sqlite3_column_count(checkstmt_stmt(L, 1)) );
  return 1;
}



static int l_sqlite3_column_info(lua_State * L, const char * (*info_func)(sqlite3_stmt*,int) )
{
  const char * info = info_func(checkstmt_stmt(L, 1), checkint(L, 2));
  
  if (info)
    lua_pushstring(L, info);
  else
    lua_pushstring(L, "");
  
  return 1;
}

FUNC( l_sqlite3_column_decltype )
{
  return l_sqlite3_column_info(L, sqlite3_column_decltype);
}

FUNC( l_sqlite3_column_name )
{
  return l_sqlite3_column_info(L, sqlite3_column_name);
}


FUNC( l_sqlite3_complete )
{
  lua_pushboolean(L, sqlite3_complete(checkstr(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_data_count )
{
  lua_pushnumber(L, sqlite3_data_count(checkstmt_stmt(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_errcode )
{
  lua_pushnumber(L, sqlite3_errcode(checkdb_sqlite3(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_errmsg )
{
  lua_pushstring(L, sqlite3_errmsg(checkdb_sqlite3(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_finalize )
{
  lua_pushnumber(L, sqlite3_finalize(checkstmt_stmt(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_interrupt )
{
  sqlite3_interrupt(checkdb_sqlite3(L, 1));
  return 0;
}


FUNC( l_sqlite3_last_insert_rowid )
{
  lua_pushnumber(L, sqlite3_last_insert_rowid(checkdb_sqlite3(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_open )
{
  sqlite3 * sqlite3   = ac_global_LogDb->db;
  DB * db = (DB *) lua_newuserdata(L, sizeof(DB));
  db->kr_db = sqlite3;
  return 1; /* database */
}


FUNC( l_sqlite3_prepare )
{
  /* XXX This piece of code is not so nice. This piece should be redone... */
  
  DB * db     = checkdb(L, 1);
  const char * sql    = checkstr(L, 2);
  int sql_size      = lua_strlen(L, 2);
  const char * leftover   = 0;
  sqlite3_stmt * sqlite3_stmt   = 0;
  int error, leftover_size;
  Stmt * stmt;
  
  init_callback_usage(L, db);   /* Needed by trace handler... FIXME: maybe to be removed... */
  
  error = sqlite3_prepare(db->kr_db, sql, sql_size, &sqlite3_stmt, &leftover);
  
  leftover_size = leftover ? sql + sql_size - leftover : 0;
  
  lua_pushnumber(L, error);
  
  stmt = lua_newuserdata(L, sizeof(Stmt));
  stmt->db = checkdb(L, 1);
  stmt->stmt = sqlite3_stmt;
  
  if (leftover_size > 0)
    lua_pushlstring(L, leftover, leftover_size);
  else
    lua_pushnil(L);
  
  return 3; /* error code, statement, left over */
}


FUNC( l_sqlite3_reset )
{
  lua_pushnumber(L, sqlite3_reset(checkstmt_stmt(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_step )
{
  Stmt * stmt = checkstmt(L, 1);
  init_callback_usage(L, stmt->db);
  lua_pushnumber(L, sqlite3_step(stmt->stmt) );
  return 1;
}


FUNC( l_sqlite3_total_changes )
{
  lua_pushnumber(L, sqlite3_total_changes(checkdb_sqlite3(L, 1)) );
  return 1;
}



static int exec_callback_wrapper(void * cb_data, int num_columns, char ** values, char ** names)
{
  int index;
  lua_State * L = (lua_State *) cb_data;
  
  lua_pushvalue(L, 3);  /* Callback function, resulting stack position 4 */
  lua_newtable(L);  /* Value array, resulting stack position 5 */
  lua_newtable(L);  /* Names array, resulting stack position 6 */
  
  for(index=0; index<num_columns; index++)
  {
    lua_pushstring(L, values[index]); /* Value */
    lua_rawseti(L, 5, index+1);   /* C-index are 0 based, Lua index are 1 based... */
    
    lua_pushstring(L, names[index]);  /* Name */
    lua_rawseti(L, 6, index+1);
  }
  
  if ( lua_pcall(L, 2, 1, 0) )    /* In: 2 arrays, Out: result code, On error: leave */
  {
    lua_pop(L, 1);      /* delete error message */
    return 1;
  }
  
  return pop_break_condition(L);
}

FUNC( l_sqlite3_exec )
{
  DB * db   = checkdb(L, 1);
  sqlite3_callback cb;
  void * cb_data;
  
  if ( checknilornoneorfunc(L, 3) )
  {
    cb = exec_callback_wrapper;
    cb_data = L;
  }
  else
  {
    cb      = 0;
    cb_data = 0;
  }
  
  init_callback_usage(L, db);
  
  lua_pushnumber(L, sqlite3_exec(db->kr_db, checkstr(L, 2), cb, cb_data, 0) );
  return 1;
}



static void func_callback_wrapper(int which, sqlite3_context * ctx, int num_args, sqlite3_value ** values)
{
  CB_Data * cb_data = sqlite3_user_data(ctx);
  DB *    db  = cb_data->db;
  lua_State *   L = db->L;
  
  switch(which)
  {
    case 0: push_callback(L, db, KEY_XFUNC(cb_data)); break;
    case 1: push_callback(L, db, KEY_XSTEP(cb_data)); break;
    case 2: push_callback(L, db, KEY_XFINAL(cb_data)); break;
  }
  
  if (lua_isnil(L, -1))
  {
    lua_pop(L, 1);
    fprintf(stderr, "libluasqlite3: func_callback_wrapper: Warning: function is null\n");
    return;
  }
  
  lua_pushlightuserdata(L, ctx);
  
  if (values)
  {
    lua_pushnumber(L, num_args);
    lua_pushlightuserdata(L, values);
  }
  
  if (lua_pcall(L, values ? 3 : 1, 0, 0))
  {
    fprintf(stderr, "libluasqlite3: func_callback_wrapper: Warning: user function error: %s\n", lua_tostring(L, -1));
    sqlite3_result_error(ctx, lua_tostring(L, -1), lua_strlen(L, -1));
    lua_pop(L, 1);
  }
}

static void xfunc_callback_wrapper(sqlite3_context * ctx, int num_args, sqlite3_value ** values)
{
  func_callback_wrapper(0, ctx, num_args, values);
}

static void xstep_callback_wrapper(sqlite3_context * ctx, int num_args, sqlite3_value ** values)
{
  func_callback_wrapper(1, ctx, num_args, values);
}

static void xfinal_callback_wrapper(sqlite3_context * ctx)
{
  func_callback_wrapper(2, ctx, 0, 0);
}

FUNC( l_sqlite3_create_function )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_function_cb_data(L, db, 2);
  
  void (*xfunc)(sqlite3_context *, int, sqlite3_value **) = 0;
  void (*xstep)(sqlite3_context *, int, sqlite3_value **) = 0;
  void (*xfinal)(sqlite3_context *) = 0;
  
  if ( checknilornoneorfunc(L, 4) )
    xfunc = xfunc_callback_wrapper;
  else
    xfunc = 0;
  
  if ( checknilornoneorfunc(L, 5) )
    xstep = xstep_callback_wrapper;
  else
    xstep = 0;
  
  if ( checknilornoneorfunc(L, 6) )
    xfinal = xfinal_callback_wrapper;
  else
    xfinal = 0;
  
  register_callback(L, db, KEY_XFUNC(cb_data), 4);
  register_callback(L, db, KEY_XSTEP(cb_data), 5);
  register_callback(L, db, KEY_XFINAL(cb_data), 6);
  
  lua_pushnumber(L,
    sqlite3_create_function (
      db->kr_db,
      checkstr(L, 2),
      checkint(L, 3),
      SQLITE_UTF8,
      cb_data,
      xfunc,
      xstep,
      xfinal ));
  
  return 1;
}


static int xcompare_callback_wrapper(void * cb_data, int len_a, const void * str_a, int len_b, const void * str_b)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State * L  = db->L;
  int result;
  
  push_callback(L, db, KEY_XCOMPARE(cb_data));
  lua_pushlstring(L, str_a, len_a);
  lua_pushlstring(L, str_b, len_b);
  
  if ( lua_pcall(L, 2, 1, 0) )
    result = 0;     /* No way to signal errors to sqlite */
  else
    result = (int) lua_tonumber(L, -1);
  
  lua_pop(L, 1);
  return result;
}

FUNC( l_sqlite3_create_collation )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_collation_cb_data(L, db, 2);
  
  int (*xcompare)(void *, int, const void *, int, const void *);
  
  if ( checknilornoneorfunc(L, 3) )
    xcompare = xcompare_callback_wrapper;
  else
    xcompare = 0;
  
  register_callback(L, db, KEY_XCOMPARE(cb_data), 3);
  
  lua_pushnumber(L, sqlite3_create_collation(
                db->kr_db, checkstr(L, 2), SQLITE_UTF8, cb_data, xcompare) );
  return 1;
}


static void xneeded_callback_wrapper(void * cb_data, sqlite3 * sqlite3, int eTextRep, const char * collation_name)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State *   L  = db->L;

  (void)sqlite3;
  (void)eTextRep;
  
  push_callback(L, db, KEY_XNEEDED(cb_data));
  lua_pushstring(L, collation_name);
  
  if (lua_pcall(L, 1, 0, 0))
    lua_pop(L, 1);
}

FUNC( l_sqlite3_collation_needed )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_collneeded_cb_data(L, db);
  
  void (*xneeded)(void *, sqlite3 *, int eTextRep, const char *);
  
  if ( checknilornoneorfunc(L, 2) )
    xneeded = xneeded_callback_wrapper;
  else
    xneeded = 0;
  
  register_callback(L, db, KEY_XNEEDED(cb_data), 2);
  
  lua_pushnumber(L, sqlite3_collation_needed(db->kr_db, cb_data, xneeded) );
  return 1;
}




static void xtrace_callback_wrapper(void * cb_data, const char * str)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State * L  = db->L;
  
  push_callback(L, db, KEY_XTRACE(cb_data));
  lua_pushstring(L, str);
  
  if ( lua_pcall(L, 1, 0, 0) )
    lua_pop(L, 1);    /* pop error message and delete it (errors are ignored) */
}

FUNC( l_sqlite3_trace )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_trace_cb_data(L, db);
  
  void (*xtrace)(void *, const char *);
  
  if ( checknilornoneorfunc(L, 2) )
    xtrace = xtrace_callback_wrapper;
  else
    xtrace = 0;
  
  register_callback(L, db, KEY_XTRACE(cb_data), 2);
  
  sqlite3_trace(db->kr_db, xtrace, cb_data);
  
  lua_pushnumber(L, SQLITE_OK);
  return 1;
}




FUNC( l_sqlite3_result_null )
{
  sqlite3_result_null(checkcontext(L, 1));
  return 0;
}


FUNC( l_sqlite3_result_error )
{
  sqlite3_result_error(checkcontext(L, 1), checkstr(L, 2), lua_strlen(L, 2));
  return 0;
}


FUNC( l_sqlite3_result_double )
{
  sqlite3_result_double(checkcontext(L, 1), checkdouble(L, 2));
  return 0;
}


FUNC( l_sqlite3_result_int )
{
  sqlite3_result_int(checkcontext(L, 1), checkint(L, 2));
  return 0;
}


FUNC( l_sqlite3_result_number )
{
  lua_Number number = checknumber(L, 2);
  
  if (IS_INT(number))
    sqlite3_result_int(checkcontext(L, 1), (int)number);
  else
    sqlite3_result_double(checkcontext(L, 1), (double)number);
  
  return 0;
}


FUNC( l_sqlite3_result_blob )
{
  sqlite3_result_blob(checkcontext(L, 1), checkstr(L, 2), lua_strlen(L, 2), SQLITE_TRANSIENT);
  return 0;
}


FUNC( l_sqlite3_result_text )
{
  sqlite3_result_text(checkcontext(L, 1), checkstr(L, 2), lua_strlen(L, 2), SQLITE_TRANSIENT);
  return 0;
}


FUNC( l_sqlite3_result_value )
{
  sqlite3_value ** values = checkvalues(L, 2);
  int index = checkint(L, 3);
  sqlite3_result_value(checkcontext(L, 1), values[index] );
  return 0;
}

FUNC( l_sqlite3_result )
{
  sqlite3_context * context = checkcontext(L, 1);
  
  switch(lua_type(L, 2))
  {
    case LUA_TNONE:
    case LUA_TNIL:
      sqlite3_result_null(context);
      break;
    
    case LUA_TNUMBER:
      {
        lua_Number number = lua_tonumber(L, 2);
        
        if (IS_INT(number))
          sqlite3_result_int(context, (int)number);
        else
          sqlite3_result_double(context, (double)number);
      }
      break;
    
    case LUA_TBOOLEAN:
      if (lua_toboolean(L, 2))
        sqlite3_result_int(context, 1);
      else
        sqlite3_result_int(context, 0);
      break;
    
    case LUA_TSTRING:
      sqlite3_result_text(context, lua_tostring(L, 2), lua_strlen(L, 2), SQLITE_TRANSIENT);
      break;
    
    default:
      report_error(L, "libluasqlite3: Api usage error: Invalid argument to l_sqlite3_result:");
  }
  
  return 0;
}


FUNC( l_sqlite3_aggregate_count )
{
  lua_pushnumber(L, sqlite3_aggregate_count(checkcontext(L, 1)) );
  return 1;
}


FUNC( l_sqlite3_aggregate_context )
{
  lua_pushlightuserdata(L, sqlite3_aggregate_context(checkcontext(L, 1), 1));
  return 1;
}


FUNC( l_sqlite3_value_int )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index = checkint(L, 2);
  lua_pushnumber(L, sqlite3_value_int(values[index]) );
  return 1;
}


FUNC( l_sqlite3_value_double )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index = checkint(L, 2);
  lua_pushnumber(L, sqlite3_value_double(values[index]) );
  return 1;
}


FUNC( l_sqlite3_value_number )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index = checkint(L, 2);
  sqlite3_value * value = values[index];
  if (sqlite3_value_type(value) == SQLITE_INTEGER)
    lua_pushnumber(L, sqlite3_value_int(value) );
  else
    lua_pushnumber(L, sqlite3_value_double(value) );
  return 1;
}


FUNC( l_sqlite3_value_blob )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index = checkint(L, 2);
  lua_pushlstring(L, sqlite3_value_blob(values[index]), sqlite3_value_bytes(values[index]) );
  return 1;
}


FUNC( l_sqlite3_value_text )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index = checkint(L, 2);
  lua_pushlstring(L, (const char*)sqlite3_value_text(values[index]), sqlite3_value_bytes(values[index]) );
  return 1;
}


FUNC( l_sqlite3_value )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index     = checkint(L, 2);
  sqlite3_value * value   = values[index];
  
  switch(sqlite3_value_type(value))
  {
    case SQLITE_INTEGER:
      lua_pushnumber(L, sqlite3_value_int(value) );
      break;
    
    case SQLITE_FLOAT:
      lua_pushnumber(L, sqlite3_value_double(value) );
      break;
    
    case SQLITE_TEXT:
      lua_pushlstring(L, (const char*)sqlite3_value_text(value), sqlite3_value_bytes(value) );
      break;
    
    case SQLITE_BLOB:
      lua_pushlstring(L, sqlite3_value_blob(value), sqlite3_value_bytes(value) );
      break;
    
    case SQLITE_NULL:
      lua_pushnil(L);
      break;
    
    default:
      report_error(L, "libluasqlite3: Internal error: Unknonw SQLITE data type.");
  }
  return 1;
}


FUNC( l_sqlite3_value_type )
{
  sqlite3_value ** values = checkvalues(L, 1);
  int index = checkint(L, 2);
  lua_pushnumber(L, sqlite3_value_type(values[index]) );
  return 1;
}


FUNC( l_sqlite3_libversion )
{
  lua_pushstring(L, sqlite3_libversion() );
  return 1;
}


static int xcommit_callback_wrapper(void * cb_data)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State * L  = db->L;
  
  push_callback(L, db, KEY_XCOMMIT(cb_data));
  
  if ( lua_pcall(L, 0, 1, 0) )
  {
    lua_pop(L, 1);
    return 1;   /* on errors, rollback */
  }
  
  return pop_break_condition(L);
}

FUNC( l_sqlite3_commit_hook )
{
  DB * db = checkdb(L, 1);
  CB_Data * cb_data = get_commit_cb_data(L, db);
  
  int (*xcommit)(void *);
  
  if ( checknilornoneorfunc(L, 1) )
    xcommit = xcommit_callback_wrapper;
  else
    xcommit = 0;
  
  register_callback(L, db, KEY_XCOMMIT(cb_data), 2);
  sqlite3_commit_hook(db->kr_db, xcommit, cb_data);
  
  lua_pushnumber(L, sqlite3_errcode(db->kr_db) );
  return 1;
}


static int xprogress_callback_wrapper(void * cb_data)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State * L  = db->L;
  
  push_callback(L, db, KEY_XPROGRESS(cb_data));
  
  if ( lua_pcall(L, 0, 1, 0) )
  {
    lua_pop(L, 1);
    return 1;   /* on errors, rollback */
  }
  
  return pop_break_condition(L);
  return 1;
}

FUNC( l_sqlite3_progress_handler )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_progress_cb_data(L, db);
  
  int (*xprogress)(void *);
  
  if ( checknilornoneorfunc(L, 1) )
    xprogress = xprogress_callback_wrapper;
  else
    xprogress = 0;
  
  register_callback(L, db, KEY_XPROGRESS(cb_data), 3);
  sqlite3_progress_handler(db->kr_db, checkint(L, 2), xprogress, cb_data);
  
  lua_pushnumber(L, sqlite3_errcode(db->kr_db) );
  return 1;
}


static int xbusy_callback_wrapper(void * cb_data, int num_called)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State * L  = db->L;
  
  push_callback(L, db, KEY_XBUSY(cb_data));
  lua_pushnumber(L, num_called);
  
  if ( lua_pcall(L, 1, 1, 0) )
  {
    lua_pop(L, 1);
    return 0;   /* On errors, sqlite should return SQLITE_BUSY */
  }
  
  return pop_break_condition(L);  /* WARNING: In reality, the semantic is inverted !!!*/
}

FUNC( l_sqlite3_busy_handler )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_busy_cb_data(L, db);
  
  int (*xbusy)(void *, int);
  
  if ( checknilornoneorfunc(L, 2) )
    xbusy = xbusy_callback_wrapper;
  else
    xbusy = 0;
  
  register_callback(L, db, KEY_XBUSY(cb_data), 2);
  
  lua_pushnumber(L, sqlite3_busy_handler(db->kr_db, xbusy, cb_data) );
  return 1;
}



static int xauth_callback_wrapper(void * cb_data, int auth_request, const char * name1, const char * name2, const char * db_name, const char * trigger_name)
{
  DB *    db = CB_DATA(cb_data)->db;
  lua_State * L  = db->L;
  int result;
  
  push_callback(L, db, KEY_XAUTH(cb_data));
  lua_pushnumber(L, auth_request);
  push_nil_or_string(L, name1);
  push_nil_or_string(L, name2);
  push_nil_or_string(L, db_name);
  push_nil_or_string(L, trigger_name);
  
  if ( lua_pcall(L, 5, 1, 0) )
  {
    lua_pop(L, 1);
    return SQLITE_DENY;   /* On errors, sqlite should deny access */
  }
  
  if (lua_isnumber(L, -1))
    result = lua_tonumber(L, -1);
  else
    result = SQLITE_DENY; /* Wrong result values should deny access */
  
  lua_pop(L, 1);
  return result;
}

FUNC( l_sqlite3_set_authorizer )
{
  DB * db   = checkdb(L, 1);
  CB_Data * cb_data = get_authorizer_cb_data(L, db);
  
  int (*xauth)(void *, int, const char *, const char *, const char *, const char *);
  
  if ( checknilornoneorfunc(L, 2) )
    xauth = xauth_callback_wrapper;
  else
    xauth = 0;
  
  register_callback(L, db, KEY_XAUTH(cb_data), 2);

  lua_pushnumber(L, sqlite3_set_authorizer(db->kr_db, xauth, cb_data) );
  return 1;
}






typedef struct { char * name; int (*func)(lua_State *); } f_entry;
typedef struct { char * name; int value; } d_entry;



static void f(lua_State * L, f_entry entries[])
{
  int index;
  lua_newtable(L);
  for( index=0; entries[index].name; index++)
  {
    lua_pushstring(L, entries[index].name);
    lua_pushcfunction(L, entries[index].func);
    lua_rawset(L, -3);
  }
}



static void d(lua_State * L, d_entry entries[])
{
  int index;
  lua_newtable(L);
  for( index=0; entries[index].name; index++)
  {
    lua_pushstring(L, entries[index].name);
    lua_pushnumber(L, entries[index].value);
    lua_rawset(L, -3);
  }
}



f_entry api_entries[] = {
  { "bind_null",    l_sqlite3_bind_null },
  { "bind_text",    l_sqlite3_bind_text },
  { "bind_blob",    l_sqlite3_bind_blob },
  { "bind_int",     l_sqlite3_bind_int },
  { "bind_double",    l_sqlite3_bind_double },
  { "bind_number",    l_sqlite3_bind_number },
  { "bind",     l_sqlite3_bind },
  { "bind_parameter_name",  l_sqlite3_bind_parameter_name },
  { "bind_parameter_name_x",  l_sqlite3_bind_parameter_name_x },
  { "bind_parameter_count", l_sqlite3_bind_parameter_count },
  { "busy_timeout",   l_sqlite3_busy_timeout },
  { "changes",      l_sqlite3_changes },
  { "close",      l_sqlite3_close },
  { "column_blob",    l_sqlite3_column_blob },
  { "column_text",    l_sqlite3_column_text },
  { "column_int",   l_sqlite3_column_int },
  { "column_double",    l_sqlite3_column_double },
  { "column_number",    l_sqlite3_column_number },
  { "column",     l_sqlite3_column },
  { "column_type",    l_sqlite3_column_type },
  { "column_count",   l_sqlite3_column_count },
  { "column_decltype",    l_sqlite3_column_decltype },
  { "column_name",    l_sqlite3_column_name },
  { "complete",     l_sqlite3_complete },
  { "data_count",   l_sqlite3_data_count },
  { "errcode",      l_sqlite3_errcode },
  { "errmsg",     l_sqlite3_errmsg },
  { "finalize",     l_sqlite3_finalize },
  { "interrupt",    l_sqlite3_interrupt },
  { "last_insert_rowid",  l_sqlite3_last_insert_rowid },
  { "open",     l_sqlite3_open },
  { "prepare",      l_sqlite3_prepare },
  { "reset",      l_sqlite3_reset },
  { "step",     l_sqlite3_step },
  { "total_changes",    l_sqlite3_total_changes },
  { "exec",     l_sqlite3_exec },
  { "create_function",    l_sqlite3_create_function },
  { "create_collation",   l_sqlite3_create_collation },
  { "trace",      l_sqlite3_trace },
  { "collation_needed",   l_sqlite3_collation_needed },
  { "result_null",    l_sqlite3_result_null },
  { "result_error",   l_sqlite3_result_error },
  { "result_double",    l_sqlite3_result_double },
  { "result_int",   l_sqlite3_result_int },
  { "result_number",    l_sqlite3_result_number },
  { "result_blob",    l_sqlite3_result_blob },
  { "result_text",    l_sqlite3_result_text },
  { "result_value",   l_sqlite3_result_value },
  { "result",     l_sqlite3_result },
  { "aggregate_count",    l_sqlite3_aggregate_count },
  { "aggregate_context",  l_sqlite3_aggregate_context },
  { "value_int",    l_sqlite3_value_int },
  { "value_double",   l_sqlite3_value_double },
  { "value_number",   l_sqlite3_value_number },
  { "value_blob",   l_sqlite3_value_blob },
  { "value_text",   l_sqlite3_value_text },
  { "value",      l_sqlite3_value },
  { "value_type",   l_sqlite3_value_type },
  { "libversion",   l_sqlite3_libversion },
  { "commit_hook",    l_sqlite3_commit_hook },
  { "progress_handler",   l_sqlite3_progress_handler },
  { "busy_handler",   l_sqlite3_busy_handler },
  { "set_authorizer",   l_sqlite3_set_authorizer },
  { "drow",     l_sqlite3_drow },
  { "irow",     l_sqlite3_irow },
  { "arow",     l_sqlite3_arow },
  { 0, 0 }
};


d_entry error_entries[] = {
  { "OK",     SQLITE_OK },
  { "ERROR",      SQLITE_ERROR },
  { "INTERNAL",     SQLITE_INTERNAL },
  { "PERM",     SQLITE_PERM },
  { "ABORT",      SQLITE_ABORT },
  { "BUSY",     SQLITE_BUSY },
  { "LOCKED",     SQLITE_LOCKED },
  { "NOMEM",      SQLITE_NOMEM },
  { "READONLY",     SQLITE_READONLY },
  { "INTERRUPT",    SQLITE_INTERRUPT },
  { "IOERR",      SQLITE_IOERR },
  { "CORRUPT",      SQLITE_CORRUPT },
  { "NOTFOUND",     SQLITE_NOTFOUND },
  { "FULL",     SQLITE_FULL },
  { "CANTOPEN",     SQLITE_CANTOPEN },
  { "PROTOCOL",     SQLITE_PROTOCOL },
  { "EMPTY",      SQLITE_EMPTY },
  { "SCHEMA",     SQLITE_SCHEMA },
  { "TOOBIG",     SQLITE_TOOBIG },
  { "CONSTRAINT",   SQLITE_CONSTRAINT },
  { "MISMATCH",     SQLITE_MISMATCH },
  { "MISUSE",     SQLITE_MISUSE },
  { "NOLFS",      SQLITE_NOLFS },
  { "AUTH",     SQLITE_AUTH },
  { "ROW",      SQLITE_ROW },
  { "DONE",     SQLITE_DONE },
  { "DENY",     SQLITE_DENY },
  { "IGNORE",     SQLITE_IGNORE },
  { 0, 0 }
};


d_entry type_entries[] = {
  { "INTEGER",      SQLITE_INTEGER },
  { "INT",      SQLITE_INTEGER },
  { "FLOAT",      SQLITE_FLOAT },
  { "DOUBLE",     SQLITE_FLOAT },
  { "TEXT",     SQLITE_TEXT },
  { "BLOB",     SQLITE_BLOB },
  { "NULL",     SQLITE_NULL },
  { 0, 0 }
};


d_entry auth_entries[] = {
  { "CREATE_INDEX",   SQLITE_CREATE_INDEX },
  { "CREATE_TABLE",   SQLITE_CREATE_TABLE },
  { "CREATE_TRIGGER",   SQLITE_CREATE_TRIGGER },
  { "CREATE_VIEW",    SQLITE_CREATE_VIEW },
  { "CREATE_TEMP_INDEX",  SQLITE_CREATE_TEMP_INDEX },
  { "CREATE_TEMP_TABLE",  SQLITE_CREATE_TEMP_TABLE },
  { "CREATE_TEMP_TRIGGER",  SQLITE_CREATE_TEMP_TRIGGER },
  { "CREATE_TEMP_VIEW", SQLITE_CREATE_TEMP_VIEW },
  { "DROP_INDEX",   SQLITE_DROP_INDEX },
  { "DROP_TABLE",   SQLITE_DROP_TABLE },
  { "DROP_TRIGGER",   SQLITE_DROP_TRIGGER },
  { "DROP_VIEW",    SQLITE_DROP_VIEW },
  { "DROP_TEMP_INDEX",    SQLITE_DROP_TEMP_INDEX },
  { "DROP_TEMP_TABLE",    SQLITE_DROP_TEMP_TABLE },
  { "DROP_TEMP_TRIGGER",  SQLITE_DROP_TEMP_TRIGGER },
  { "DROP_TEMP_VIEW",   SQLITE_DROP_TEMP_VIEW },
  { "INSERT",     SQLITE_INSERT },
  { "PRAGMA",     SQLITE_PRAGMA },
  { "READ",     SQLITE_READ },
  { "SELECT",     SQLITE_SELECT },
  { "TRANSACTION",    SQLITE_TRANSACTION },
  { "UPDATE",     SQLITE_UPDATE },
  { "ATTACH",     SQLITE_ATTACH },
  { "DETACH",     SQLITE_DETACH },
  { 0, 0 }
};




int luaopen_sqlite3(lua_State * L)
{
  f(L, api_entries);
  d(L, error_entries);
  d(L, type_entries);
  d(L, auth_entries);
  
  return 4; /* api, error codes, type codes, auth requests */
}