To do so, a few dependencies have been imported: * external/bsd/lutok * external/mit/lua * external/public-domain/sqlite * external/public-domain/xz The Kyua framework is the new generation of ATF (Automated Test Framework), it is composed of: * external/bsd/atf * external/bsd/kyua-atf-compat * external/bsd/kyua-cli * external/bsd/kyua-tester * tests Kyua/ATF being written in C++, it depends on libstdc++ which is provided by GCC. As this is not part of the sources, Kyua is only compiled when the native GCC utils are installed. To install Kyua do the following: * In a cross-build enviromnent, add the following to the build.sh commandline: -V MKBINUTILS=yes -V MKGCCCMDS=yes WARNING: At this point the import is still experimental, and not supported on native builds (a.k.a make build). Change-Id: I26aee23c5bbd2d64adcb7c1beb98fe0d479d7ada
489 lines
11 KiB
C
489 lines
11 KiB
C
/* $NetBSD: sqlite.c,v 1.5 2012/11/02 12:24:52 mbalmer Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2011 Marc Balmer <marc@msys.ch>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/* SQLite interface for Lua */
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <sqlite3.h>
|
|
|
|
#include <lua.h>
|
|
#include <lauxlib.h>
|
|
#include <lualib.h>
|
|
|
|
#define SQLITE_DB_METATABLE "SQLite database connection methods"
|
|
#define SQLITE_STMT_METATABLE "SQLite statement methods"
|
|
|
|
int luaopen_sqlite(lua_State*);
|
|
|
|
static __printflike(2, 3) void
|
|
sqlite_error(lua_State *L, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
int len;
|
|
char *msg;
|
|
|
|
va_start(ap, fmt);
|
|
len = vasprintf(&msg, fmt, ap);
|
|
va_end(ap);
|
|
|
|
if (len != -1) {
|
|
lua_pushstring(L, msg);
|
|
free(msg);
|
|
} else
|
|
lua_pushstring(L, "vasprintf failed");
|
|
lua_error(L);
|
|
}
|
|
|
|
static int
|
|
sqlite_initialize(lua_State *L)
|
|
{
|
|
lua_pushinteger(L, sqlite3_initialize());
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
sqlite_shutdown(lua_State *L)
|
|
{
|
|
lua_pushinteger(L, sqlite3_shutdown());
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
sqlite_open(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = lua_newuserdata(L, sizeof(sqlite3 *));
|
|
lua_pushinteger(L, sqlite3_open_v2(luaL_checkstring(L, -3), db,
|
|
(int)luaL_checkinteger(L, -2), NULL));
|
|
|
|
luaL_getmetatable(L, SQLITE_DB_METATABLE);
|
|
lua_setmetatable(L, -3);
|
|
return 2;
|
|
|
|
}
|
|
|
|
static int
|
|
sqlite_libversion(lua_State *L)
|
|
{
|
|
lua_pushstring(L, sqlite3_libversion());
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
sqlite_libversion_number(lua_State *L)
|
|
{
|
|
lua_pushinteger(L, sqlite3_libversion_number());
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
sqlite_sourceid(lua_State *L)
|
|
{
|
|
lua_pushstring(L, sqlite3_sourceid());
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
db_close(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
lua_pushinteger(L, sqlite3_close(*db));
|
|
return 1;
|
|
|
|
}
|
|
|
|
static int
|
|
db_prepare(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
sqlite3_stmt **stmt;
|
|
const char *sql;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
stmt = lua_newuserdata(L, sizeof(sqlite3_stmt *));
|
|
sql = luaL_checkstring(L, 2);
|
|
lua_pushinteger(L, sqlite3_prepare_v2(*db, sql,
|
|
(int)strlen(sql) + 1, stmt, NULL));
|
|
luaL_getmetatable(L, SQLITE_STMT_METATABLE);
|
|
lua_setmetatable(L, -3);
|
|
return 2;
|
|
|
|
}
|
|
|
|
static int
|
|
db_exec(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
lua_pushinteger(L, sqlite3_exec(*db, lua_tostring(L, 2), NULL,
|
|
NULL, NULL));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
db_errcode(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
lua_pushinteger(L, sqlite3_errcode(*db));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
db_errmsg(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
lua_pushstring(L, sqlite3_errmsg(*db));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
db_get_autocommit(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
lua_pushboolean(L, sqlite3_get_autocommit(*db));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
db_changes(lua_State *L)
|
|
{
|
|
sqlite3 **db;
|
|
|
|
db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
|
|
lua_pushinteger(L, sqlite3_changes(*db));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_bind(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
int pidx;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
pidx = (int)luaL_checkinteger(L, 2);
|
|
|
|
switch (lua_type(L, 3)) {
|
|
case LUA_TNUMBER:
|
|
lua_pushinteger(L, sqlite3_bind_double(*stmt, pidx,
|
|
lua_tonumber(L, 3)));
|
|
break;
|
|
case LUA_TSTRING:
|
|
lua_pushinteger(L, sqlite3_bind_text(*stmt, pidx,
|
|
lua_tostring(L, 3), -1, SQLITE_TRANSIENT));
|
|
break;
|
|
case LUA_TNIL:
|
|
lua_pushinteger(L, sqlite3_bind_null(*stmt, pidx));
|
|
break;
|
|
default:
|
|
sqlite_error(L, "unsupported data type %s",
|
|
luaL_typename(L, 3));
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_bind_parameter_count(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
lua_pushinteger(L, sqlite3_bind_parameter_count(*stmt));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_bind_parameter_index(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
lua_pushinteger(L, sqlite3_bind_parameter_index(*stmt,
|
|
lua_tostring(L, 2)));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_bind_parameter_name(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
int pidx;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
pidx = (int)luaL_checkinteger(L, 2);
|
|
lua_pushstring(L, sqlite3_bind_parameter_name(*stmt, pidx));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_step(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
lua_pushinteger(L, sqlite3_step(*stmt));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_column_name(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
int cidx;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
cidx = (int)luaL_checkinteger(L, 2) - 1;
|
|
|
|
lua_pushstring(L, sqlite3_column_name(*stmt, cidx));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_column_count(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
lua_pushinteger(L, sqlite3_column_count(*stmt));
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_column(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
int cidx;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
cidx = (int)luaL_checkinteger(L, 2) - 1;
|
|
|
|
switch (sqlite3_column_type(*stmt, cidx)) {
|
|
case SQLITE_INTEGER:
|
|
lua_pushinteger(L, sqlite3_column_int(*stmt, cidx));
|
|
break;
|
|
case SQLITE_FLOAT:
|
|
lua_pushnumber(L, sqlite3_column_double(*stmt, cidx));
|
|
break;
|
|
case SQLITE_TEXT:
|
|
lua_pushstring(L, (const char *)sqlite3_column_text(*stmt,
|
|
cidx));
|
|
break;
|
|
case SQLITE_BLOB:
|
|
case SQLITE_NULL:
|
|
lua_pushnil(L);
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
stmt_reset(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
sqlite3_reset(*stmt);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
stmt_clear_bindings(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
sqlite3_clear_bindings(*stmt);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
stmt_finalize(lua_State *L)
|
|
{
|
|
sqlite3_stmt **stmt;
|
|
|
|
stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
|
|
sqlite3_finalize(*stmt);
|
|
return 0;
|
|
}
|
|
|
|
struct constant {
|
|
const char *name;
|
|
int value;
|
|
};
|
|
|
|
static const struct constant sqlite_constant[] = {
|
|
/* SQLite return codes */
|
|
{ "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 },
|
|
{ "FULL", SQLITE_FULL },
|
|
{ "CANTOPEN", SQLITE_CANTOPEN },
|
|
{ "EMPTY", SQLITE_EMPTY },
|
|
{ "SCHEMA", SQLITE_SCHEMA },
|
|
{ "TOOBIG", SQLITE_TOOBIG },
|
|
{ "CONSTRAINT", SQLITE_CONSTRAINT },
|
|
{ "MISMATCH", SQLITE_MISMATCH },
|
|
{ "MISUSE", SQLITE_MISUSE },
|
|
{ "NOLFS", SQLITE_NOLFS },
|
|
{ "AUTH", SQLITE_AUTH },
|
|
{ "FORMAT", SQLITE_FORMAT },
|
|
{ "RANGE", SQLITE_RANGE },
|
|
{ "NOTADB", SQLITE_NOTADB },
|
|
|
|
{ "ROW", SQLITE_ROW },
|
|
{ "DONE", SQLITE_DONE },
|
|
|
|
/* File modes */
|
|
{ "OPEN_READONLY", SQLITE_OPEN_READONLY },
|
|
{ "OPEN_READWRITE", SQLITE_OPEN_READWRITE },
|
|
{ "OPEN_CREATE", SQLITE_OPEN_CREATE },
|
|
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
static void
|
|
gpio_set_info(lua_State *L)
|
|
{
|
|
lua_pushliteral(L, "_COPYRIGHT");
|
|
lua_pushliteral(L, "Copyright (C) 2011, 2012 by "
|
|
"Marc Balmer <marc@msys.ch>");
|
|
lua_settable(L, -3);
|
|
lua_pushliteral(L, "_DESCRIPTION");
|
|
lua_pushliteral(L, "SQLite interface for Lua");
|
|
lua_settable(L, -3);
|
|
lua_pushliteral(L, "_VERSION");
|
|
lua_pushliteral(L, "sqlite 1.0.2");
|
|
lua_settable(L, -3);
|
|
}
|
|
|
|
int
|
|
luaopen_sqlite(lua_State* L)
|
|
{
|
|
static const struct luaL_Reg sqlite_methods[] = {
|
|
{ "initialize", sqlite_initialize },
|
|
{ "shutdown", sqlite_shutdown },
|
|
{ "open", sqlite_open },
|
|
{ "libversion", sqlite_libversion },
|
|
{ "libversion_number", sqlite_libversion_number },
|
|
{ "sourceid", sqlite_sourceid },
|
|
{ NULL, NULL }
|
|
};
|
|
static const struct luaL_Reg db_methods[] = {
|
|
{ "close", db_close },
|
|
{ "prepare", db_prepare },
|
|
{ "exec", db_exec },
|
|
{ "errcode", db_errcode },
|
|
{ "errmsg", db_errmsg },
|
|
{ "get_autocommit", db_get_autocommit },
|
|
{ "changes", db_changes },
|
|
{ NULL, NULL }
|
|
};
|
|
static const struct luaL_Reg stmt_methods[] = {
|
|
{ "bind", stmt_bind },
|
|
{ "bind_parameter_count", stmt_bind_parameter_count },
|
|
{ "bind_parameter_index", stmt_bind_parameter_index },
|
|
{ "bind_parameter_name", stmt_bind_parameter_name },
|
|
{ "step", stmt_step },
|
|
{ "column", stmt_column },
|
|
{ "reset", stmt_reset },
|
|
{ "clear_bindings", stmt_clear_bindings },
|
|
{ "finalize", stmt_finalize },
|
|
{ "column_name", stmt_column_name },
|
|
{ "column_count", stmt_column_count },
|
|
{ NULL, NULL }
|
|
};
|
|
int n;
|
|
|
|
sqlite3_initialize();
|
|
|
|
luaL_register(L, "sqlite", sqlite_methods);
|
|
gpio_set_info(L);
|
|
|
|
/* The database connection metatable */
|
|
if (luaL_newmetatable(L, SQLITE_DB_METATABLE)) {
|
|
luaL_register(L, NULL, db_methods);
|
|
|
|
lua_pushliteral(L, "__gc");
|
|
lua_pushcfunction(L, db_close);
|
|
lua_settable(L, -3);
|
|
|
|
lua_pushliteral(L, "__index");
|
|
lua_pushvalue(L, -2);
|
|
lua_settable(L, -3);
|
|
|
|
lua_pushliteral(L, "__metatable");
|
|
lua_pushliteral(L, "must not access this metatable");
|
|
lua_settable(L, -3);
|
|
}
|
|
lua_pop(L, 1);
|
|
|
|
/* The statement metatable */
|
|
if (luaL_newmetatable(L, SQLITE_STMT_METATABLE)) {
|
|
luaL_register(L, NULL, stmt_methods);
|
|
|
|
lua_pushliteral(L, "__gc");
|
|
lua_pushcfunction(L, stmt_finalize);
|
|
lua_settable(L, -3);
|
|
|
|
lua_pushliteral(L, "__index");
|
|
lua_pushvalue(L, -2);
|
|
lua_settable(L, -3);
|
|
|
|
lua_pushliteral(L, "__metatable");
|
|
lua_pushliteral(L, "must not access this metatable");
|
|
lua_settable(L, -3);
|
|
}
|
|
lua_pop(L, 1);
|
|
|
|
for (n = 0; sqlite_constant[n].name != NULL; n++) {
|
|
lua_pushinteger(L, sqlite_constant[n].value);
|
|
lua_setfield(L, -2, sqlite_constant[n].name);
|
|
};
|
|
return 1;
|
|
}
|