lib/lua/sqlite/sqlite.c

   1 /*      $NetBSD: sqlite.c,v 1.6 2013/10/27 12:38:08 mbalmer Exp $ */
   2
   3 /*
   4  * Copyright (c) 2011, 2013 Marc Balmer <marc@msys.ch>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 /* SQLite interface for Lua */
  29
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <stdlib.h>
  34 #include <sqlite3.h>
  35
  36 #include <lua.h>
  37 #include <lauxlib.h>
  38 #include <lualib.h>
  39
  40 #define SQLITE_DB_METATABLE "SQLite database connection methods"
  41 #define SQLITE_STMT_METATABLE "SQLite statement methods"
  42
  43 int luaopen_sqlite(lua_State*);
  44
  45 static __printflike(2, 3) void
  46 sqlite_error(lua_State *L, const char *fmt, ...)
  47 {
  48         va_list ap;
  49         int len;
  50         char *msg;
  51
  52         va_start(ap, fmt);
  53         len = vasprintf(&msg, fmt, ap);
  54         va_end(ap);
  55
  56         if (len != -1) {
  57                 lua_pushstring(L, msg);
  58                 free(msg);
  59         } else
  60                 lua_pushstring(L, "vasprintf failed");
  61         lua_error(L);
  62 }
  63
  64 static int
  65 sqlite_initialize(lua_State *L)
  66 {
  67         lua_pushinteger(L, sqlite3_initialize());
  68         return 1;
  69 }
  70
  71 static int
  72 sqlite_shutdown(lua_State *L)
  73 {
  74         lua_pushinteger(L, sqlite3_shutdown());
  75         return 1;
  76 }
  77
  78 static int
  79 sqlite_open(lua_State *L)
  80 {
  81         sqlite3 **db;
  82
  83         db = lua_newuserdata(L, sizeof(sqlite3 *));
  84         luaL_getmetatable(L, SQLITE_DB_METATABLE);
  85         lua_setmetatable(L, -2);
  86
  87         if (lua_gettop(L) > 2)
  88                 lua_pushinteger(L, sqlite3_open_v2(luaL_checkstring(L, -3), db,
  89                     (int)luaL_checkinteger(L, -2), NULL));
  90         else
  91                 lua_pushinteger(L, sqlite3_open(luaL_checkstring(L, -2), db));
  92         return 2;
  93
  94 }
  95
  96 static int
  97 sqlite_libversion(lua_State *L)
  98 {
  99         lua_pushstring(L, sqlite3_libversion());
 100         return 1;
 101 }
 102
 103 static int
 104 sqlite_libversion_number(lua_State *L)
 105 {
 106         lua_pushinteger(L, sqlite3_libversion_number());
 107         return 1;
 108 }
 109
 110 static int
 111 sqlite_sourceid(lua_State *L)
 112 {
 113         lua_pushstring(L, sqlite3_sourceid());
 114         return 1;
 115 }
 116
 117 static int
 118 db_close(lua_State *L)
 119 {
 120         sqlite3 **db;
 121
 122         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 123         lua_pushinteger(L, sqlite3_close(*db));
 124         return 1;
 125
 126 }
 127
 128 static int
 129 db_prepare(lua_State *L)
 130 {
 131         sqlite3 **db;
 132         sqlite3_stmt **stmt;
 133         const char *sql;
 134
 135         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 136         stmt = lua_newuserdata(L, sizeof(sqlite3_stmt *));
 137         sql = luaL_checkstring(L, 2);
 138         lua_pushinteger(L, sqlite3_prepare_v2(*db, sql,
 139             (int)strlen(sql) + 1, stmt, NULL));
 140         luaL_getmetatable(L, SQLITE_STMT_METATABLE);
 141         lua_setmetatable(L, -3);
 142         return 2;
 143
 144 }
 145
 146 static int
 147 db_exec(lua_State *L)
 148 {
 149         sqlite3 **db;
 150
 151         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 152         lua_pushinteger(L, sqlite3_exec(*db, lua_tostring(L, 2), NULL,
 153             NULL, NULL));
 154         return 1;
 155 }
 156
 157 static int
 158 db_errcode(lua_State *L)
 159 {
 160         sqlite3 **db;
 161
 162         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 163         lua_pushinteger(L, sqlite3_errcode(*db));
 164         return 1;
 165 }
 166
 167 static int
 168 db_errmsg(lua_State *L)
 169 {
 170         sqlite3 **db;
 171
 172         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 173         lua_pushstring(L, sqlite3_errmsg(*db));
 174         return 1;
 175 }
 176
 177 static int
 178 db_get_autocommit(lua_State *L)
 179 {
 180         sqlite3 **db;
 181
 182         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 183         lua_pushboolean(L, sqlite3_get_autocommit(*db));
 184         return 1;
 185 }
 186
 187 static int
 188 db_changes(lua_State *L)
 189 {
 190         sqlite3 **db;
 191
 192         db = luaL_checkudata(L, 1, SQLITE_DB_METATABLE);
 193         lua_pushinteger(L, sqlite3_changes(*db));
 194         return 1;
 195 }
 196
 197 static int
 198 stmt_bind(lua_State *L)
 199 {
 200         sqlite3_stmt **stmt;
 201         int pidx;
 202
 203         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 204         pidx = (int)luaL_checkinteger(L, 2);
 205
 206         switch (lua_type(L, 3)) {
 207         case LUA_TNUMBER:
 208                 lua_pushinteger(L, sqlite3_bind_double(*stmt, pidx,
 209                     lua_tonumber(L, 3)));
 210                 break;
 211         case LUA_TSTRING:
 212                 lua_pushinteger(L, sqlite3_bind_text(*stmt, pidx,
 213                     lua_tostring(L, 3), -1, SQLITE_TRANSIENT));
 214                 break;
 215         case LUA_TNIL:
 216                 lua_pushinteger(L, sqlite3_bind_null(*stmt, pidx));
 217                 break;
 218         default:
 219                 sqlite_error(L, "unsupported data type %s",
 220                     luaL_typename(L, 3));
 221         }
 222         return 1;
 223 }
 224
 225 static int
 226 stmt_bind_parameter_count(lua_State *L)
 227 {
 228         sqlite3_stmt **stmt;
 229
 230         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 231         lua_pushinteger(L, sqlite3_bind_parameter_count(*stmt));
 232         return 1;
 233 }
 234
 235 static int
 236 stmt_bind_parameter_index(lua_State *L)
 237 {
 238         sqlite3_stmt **stmt;
 239
 240         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 241         lua_pushinteger(L, sqlite3_bind_parameter_index(*stmt,
 242             lua_tostring(L, 2)));
 243         return 1;
 244 }
 245
 246 static int
 247 stmt_bind_parameter_name(lua_State *L)
 248 {
 249         sqlite3_stmt **stmt;
 250         int pidx;
 251
 252         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 253         pidx = (int)luaL_checkinteger(L, 2);
 254         lua_pushstring(L, sqlite3_bind_parameter_name(*stmt, pidx));
 255         return 1;
 256 }
 257
 258 static int
 259 stmt_step(lua_State *L)
 260 {
 261         sqlite3_stmt **stmt;
 262
 263         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 264         lua_pushinteger(L, sqlite3_step(*stmt));
 265         return 1;
 266 }
 267
 268 static int
 269 stmt_column_name(lua_State *L)
 270 {
 271         sqlite3_stmt **stmt;
 272         int cidx;
 273
 274         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 275         cidx = (int)luaL_checkinteger(L, 2) - 1;
 276
 277         lua_pushstring(L, sqlite3_column_name(*stmt, cidx));
 278         return 1;
 279 }
 280
 281 static int
 282 stmt_column_count(lua_State *L)
 283 {
 284         sqlite3_stmt **stmt;
 285
 286         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 287         lua_pushinteger(L, sqlite3_column_count(*stmt));
 288         return 1;
 289 }
 290
 291 static int
 292 stmt_column(lua_State *L)
 293 {
 294         sqlite3_stmt **stmt;
 295         int cidx;
 296
 297         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 298         cidx = (int)luaL_checkinteger(L, 2) - 1;
 299
 300         switch (sqlite3_column_type(*stmt, cidx)) {
 301         case SQLITE_INTEGER:
 302                 lua_pushinteger(L, sqlite3_column_int(*stmt, cidx));
 303                 break;
 304         case SQLITE_FLOAT:
 305                 lua_pushnumber(L, sqlite3_column_double(*stmt, cidx));
 306                 break;
 307         case SQLITE_TEXT:
 308                 lua_pushstring(L, (const char *)sqlite3_column_text(*stmt,
 309                     cidx));
 310                 break;
 311         case SQLITE_BLOB:
 312         case SQLITE_NULL:
 313                 lua_pushnil(L);
 314                 break;
 315         }
 316         return 1;
 317 }
 318
 319 static int
 320 stmt_reset(lua_State *L)
 321 {
 322         sqlite3_stmt **stmt;
 323
 324         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 325         sqlite3_reset(*stmt);
 326         return 0;
 327 }
 328
 329 static int
 330 stmt_clear_bindings(lua_State *L)
 331 {
 332         sqlite3_stmt **stmt;
 333
 334         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 335         sqlite3_clear_bindings(*stmt);
 336         return 0;
 337 }
 338
 339 static int
 340 stmt_finalize(lua_State *L)
 341 {
 342         sqlite3_stmt **stmt;
 343
 344         stmt = luaL_checkudata(L, 1, SQLITE_STMT_METATABLE);
 345         sqlite3_finalize(*stmt);
 346         return 0;
 347 }
 348
 349 struct constant {
 350         const char *name;
 351         int value;
 352 };
 353
 354 static const struct constant sqlite_constant[] = {
 355         /* SQLite return codes */
 356         { "OK",                 SQLITE_OK },
 357         { "ERROR",              SQLITE_ERROR },
 358         { "INTERNAL",           SQLITE_INTERNAL },
 359         { "PERM",               SQLITE_PERM },
 360         { "ABORT",              SQLITE_ABORT },
 361         { "BUSY",               SQLITE_BUSY },
 362         { "LOCKED",             SQLITE_LOCKED },
 363         { "NOMEM",              SQLITE_NOMEM },
 364         { "READONLY",           SQLITE_READONLY },
 365         { "INTERRUPT",          SQLITE_INTERRUPT },
 366         { "IOERR",              SQLITE_IOERR },
 367         { "CORRUPT",            SQLITE_CORRUPT },
 368         { "NOTFOUND",           SQLITE_NOTFOUND },
 369         { "FULL",               SQLITE_FULL },
 370         { "CANTOPEN",           SQLITE_CANTOPEN },
 371         { "PROTOCOL",           SQLITE_PROTOCOL },
 372         { "EMPTY",              SQLITE_EMPTY },
 373         { "SCHEMA",             SQLITE_SCHEMA },
 374         { "TOOBIG",             SQLITE_TOOBIG },
 375         { "CONSTRAINT",         SQLITE_CONSTRAINT },
 376         { "MISMATCH",           SQLITE_MISMATCH },
 377         { "MISUSE",             SQLITE_MISUSE },
 378         { "NOLFS",              SQLITE_NOLFS },
 379         { "AUTH",               SQLITE_AUTH },
 380         { "FORMAT",             SQLITE_FORMAT },
 381         { "RANGE",              SQLITE_RANGE },
 382         { "NOTADB",             SQLITE_NOTADB },
 383         { "ROW",                SQLITE_ROW },
 384         { "DONE",               SQLITE_DONE },
 385
 386         /* File modes */
 387         { "OPEN_READONLY",      SQLITE_OPEN_READONLY },
 388         { "OPEN_READWRITE",     SQLITE_OPEN_READWRITE },
 389         { "OPEN_CREATE",        SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
 390
 391         { NULL,                 0 }
 392 };
 393
 394 static void
 395 gpio_set_info(lua_State *L)
 396 {
 397         lua_pushliteral(L, "_COPYRIGHT");
 398         lua_pushliteral(L, "Copyright (C) 2011, 2012, 2013 by "
 399             "Marc Balmer <marc@msys.ch>");
 400         lua_settable(L, -3);
 401         lua_pushliteral(L, "_DESCRIPTION");
 402         lua_pushliteral(L, "SQLite interface for Lua");
 403         lua_settable(L, -3);
 404         lua_pushliteral(L, "_VERSION");
 405         lua_pushliteral(L, "sqlite 1.0.3");
 406         lua_settable(L, -3);
 407 }
 408
 409 int
 410 luaopen_sqlite(lua_State* L)
 411 {
 412         static const struct luaL_Reg sqlite_methods[] = {
 413                 { "initialize",                 sqlite_initialize },
 414                 { "shutdown",                   sqlite_shutdown },
 415                 { "open",                       sqlite_open },
 416                 { "libversion",                 sqlite_libversion },
 417                 { "libversion_number",          sqlite_libversion_number },
 418                 { "sourceid",                   sqlite_sourceid },
 419                 { NULL,                         NULL }
 420         };
 421         static const struct luaL_Reg db_methods[] = {
 422                 { "close",                      db_close },
 423                 { "prepare",                    db_prepare },
 424                 { "exec",                       db_exec },
 425                 { "errcode",                    db_errcode },
 426                 { "errmsg",                     db_errmsg },
 427                 { "get_autocommit",             db_get_autocommit },
 428                 { "changes",                    db_changes },
 429                 { NULL,                         NULL }
 430         };
 431         static const struct luaL_Reg stmt_methods[] = {
 432                 { "bind",                       stmt_bind },
 433                 { "bind_parameter_count",       stmt_bind_parameter_count },
 434                 { "bind_parameter_index",       stmt_bind_parameter_index },
 435                 { "bind_parameter_name",        stmt_bind_parameter_name },
 436                 { "step",                       stmt_step },
 437                 { "column",                     stmt_column },
 438                 { "reset",                      stmt_reset },
 439                 { "clear_bindings",             stmt_clear_bindings },
 440                 { "finalize",                   stmt_finalize },
 441                 { "column_name",                stmt_column_name },
 442                 { "column_count",               stmt_column_count },
 443                 { NULL,         NULL }
 444         };
 445         int n;
 446
 447         sqlite3_initialize();
 448
 449         luaL_register(L, "sqlite", sqlite_methods);
 450         luaL_register(L, NULL, db_methods);
 451         luaL_register(L, NULL, stmt_methods);
 452         gpio_set_info(L);
 453
 454         /* The database connection metatable */
 455         if (luaL_newmetatable(L, SQLITE_DB_METATABLE)) {
 456                 luaL_register(L, NULL, db_methods);
 457
 458                 lua_pushliteral(L, "__gc");
 459                 lua_pushcfunction(L, db_close);
 460                 lua_settable(L, -3);
 461
 462                 lua_pushliteral(L, "__index");
 463                 lua_pushvalue(L, -2);
 464                 lua_settable(L, -3);
 465
 466                 lua_pushliteral(L, "__metatable");
 467                 lua_pushliteral(L, "must not access this metatable");
 468                 lua_settable(L, -3);
 469         }
 470         lua_pop(L, 1);
 471
 472         /* The statement metatable */
 473         if (luaL_newmetatable(L, SQLITE_STMT_METATABLE)) {
 474                 luaL_register(L, NULL, stmt_methods);
 475
 476                 lua_pushliteral(L, "__gc");
 477                 lua_pushcfunction(L, stmt_finalize);
 478                 lua_settable(L, -3);
 479
 480                 lua_pushliteral(L, "__index");
 481                 lua_pushvalue(L, -2);
 482                 lua_settable(L, -3);
 483
 484                 lua_pushliteral(L, "__metatable");
 485                 lua_pushliteral(L, "must not access this metatable");
 486                 lua_settable(L, -3);
 487         }
 488         lua_pop(L, 1);
 489
 490         for (n = 0; sqlite_constant[n].name != NULL; n++) {
 491                 lua_pushinteger(L, sqlite_constant[n].value);
 492                 lua_setfield(L, -2, sqlite_constant[n].name);
 493         };
 494         return 1;
 495 }