swift-db-sqlite3 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+== 0.1.0 (2012-07-20)
+
+* Initial version.

data/README.md

@@ -0,0 +1,76 @@
+# Swift Sqlite3 adapter
+
+MRI adapter for sqlite3 for use in Swift ORM.
+
+## Features
+
+* Lightweight & fast
+* Result typecasting
+* Prepared statements
+* Nested transactions
+
+## API
+
+```
+  Swift::DB::Sqlite3
+    .new(options)
+    #execute(sql, *bind)
+    #prepare(sql)
+    #begin(savepoint = nil)
+    #commit(savepoint = nil)
+    #rollback(savepoint = nil)
+    #transaction(savepoint = nil, &block)
+    #close
+    #closed?
+    #escape(text)
+
+  Swift::DB::Sqlite3::Statement
+    .new(Swift::DB::Sqlite3, sql)
+    #execute(*bind)
+    #release
+
+  Swift::DB::Sqlite3::Result
+    #selected_rows
+    #affected_rows
+    #fields
+    #types
+    #each
+    #insert_id
+```
+
+## Example
+
+```ruby
+require 'swift/db/sqlite3'
+
+db = Swift::DB::Sqlite3.new(db: ':memory:')
+
+db.execute('drop table if exists users')
+db.execute('create table users (id integer primary key, name text, age integer, created_at datetime)')
+db.execute('insert into users(name, age, created_at) values(?, ?, ?)', 'test', 30, Time.now.utc)
+
+row = db.execute('select * from users').first
+p row #=> {:id => 1, :name => 'test', :age => 30, :created_at=> #<Swift::DateTime>}
+```
+
+## Performance
+
+Don't read too much into it. Each library has its advantages and disadvantages.
+
+```
+# insert 1000 rows and read them back 100 times with typecasting enabled.
+
+                           user     system      total        real
+do_sqlite3 insert      0.050000   0.020000   0.070000 (  0.062814)
+do_sqlite3 select      0.720000   0.000000   0.720000 (  0.723628)
+
+sqlite3 insert         0.040000   0.000000   0.040000 (  0.046895)
+sqlite3 select         4.390000   0.000000   4.390000 (  4.400678)
+
+swift insert           0.030000   0.000000   0.030000 (  0.030628)
+swift select           0.480000   0.000000   0.480000 (  0.488608)
+```
+
+## License
+
+MIT

data/ext/swift/db/sqlite3/adapter.c

@@ -0,0 +1,231 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "adapter.h"
+
+/* declaration */
+VALUE cDSA;
+VALUE db_sqlite3_statement_allocate(VALUE);
+VALUE db_sqlite3_statement_initialize(VALUE, VALUE, VALUE);
+VALUE db_sqlite3_statement_execute(int argc, VALUE *argv, VALUE self);
+
+/* definition */
+Adapter* db_sqlite3_adapter_handle(VALUE self) {
+    Adapter *a;
+    Data_Get_Struct(self, Adapter, a);
+    if (!a)
+        rb_raise(eSwiftRuntimeError, "Invalid sqlite3 adapter");
+    return a;
+}
+
+Adapter* db_sqlite3_adapter_handle_safe(VALUE self) {
+    Adapter *a = db_sqlite3_adapter_handle(self);
+    if (!a->connection)
+        rb_raise(eSwiftConnectionError, "sqlite3 database is not open");
+    return a;
+}
+
+VALUE db_sqlite3_adapter_deallocate(Adapter *a) {
+    if (a && a->connection)
+        sqlite3_close(a->connection);
+    if (a)
+        free(a);
+}
+
+VALUE db_sqlite3_adapter_allocate(VALUE klass) {
+    Adapter *a = (Adapter*)malloc(sizeof(Adapter));
+
+    a->connection = 0;
+    a->t_nesting  = 0;
+    return Data_Wrap_Struct(klass, 0, db_sqlite3_adapter_deallocate, a);
+}
+
+VALUE db_sqlite3_adapter_initialize(VALUE self, VALUE options) {
+    VALUE db;
+    sqlite3* connection;
+    Adapter *a = db_sqlite3_adapter_handle(self);
+
+    if (TYPE(options) != T_HASH)
+        rb_raise(eSwiftArgumentError, "options needs to be a hash");
+
+    db = rb_hash_aref(options, ID2SYM(rb_intern("db")));
+    if (NIL_P(db))
+        rb_raise(eSwiftConnectionError, "Invalid db name");
+
+    if (sqlite3_open_v2(CSTRING(db), &connection, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0) != SQLITE_OK)
+       rb_raise(eSwiftConnectionError, "%s", sqlite3_errmsg(connection));
+
+    a->connection = connection;
+    return Qnil;
+}
+
+VALUE db_sqlite3_adapter_execute(int argc, VALUE *argv, VALUE self) {
+    VALUE sql, bind;
+    rb_scan_args(argc, argv, "10*", &sql, &bind);
+
+    return db_sqlite3_statement_execute(
+        RARRAY_LEN(bind),
+        RARRAY_PTR(bind),
+        db_sqlite3_statement_initialize(db_sqlite3_statement_allocate(cDSS), self, sql)
+    );
+}
+
+VALUE db_sqlite3_adapter_prepare(VALUE self, VALUE sql) {
+    return db_sqlite3_statement_initialize(db_sqlite3_statement_allocate(cDSS), self, sql);
+}
+
+VALUE db_sqlite3_adapter_begin(int argc, VALUE *argv, VALUE self) {
+    int auto_commit;
+    VALUE savepoint, sql;
+    char command[256];
+
+    Adapter *a = db_sqlite3_adapter_handle_safe(self);
+    rb_scan_args(argc, argv, "01", &savepoint);
+
+    if (a->t_nesting == 0) {
+        sql = rb_str_new2("begin");
+        db_sqlite3_adapter_execute(1, &sql, self);
+        a->t_nesting++;
+        if (NIL_P(savepoint))
+            return Qtrue;
+    }
+
+    if (NIL_P(savepoint))
+        savepoint = rb_uuid_string();
+
+    snprintf(command, 256, "savepoint %s", CSTRING(savepoint));
+    sql = rb_str_new2(command);
+    db_sqlite3_adapter_execute(1, &sql, self);
+    a->t_nesting++;
+    return savepoint;
+}
+
+VALUE db_sqlite3_adapter_commit(int argc, VALUE *argv, VALUE self) {
+    VALUE savepoint, sql;
+    char command[256];
+
+    Adapter *a = db_sqlite3_adapter_handle_safe(self);
+    rb_scan_args(argc, argv, "01", &savepoint);
+
+    if (a->t_nesting == 0)
+        return Qfalse;
+
+    if (NIL_P(savepoint)) {
+        sql = rb_str_new2("commit");
+        db_sqlite3_adapter_execute(1, &sql, self);
+        a->t_nesting--;
+    }
+    else {
+        snprintf(command, 256, "release savepoint %s", CSTRING(savepoint));
+        sql = rb_str_new2(command);
+        db_sqlite3_adapter_execute(1, &sql, self);
+        a->t_nesting--;
+    }
+    return Qtrue;
+}
+
+VALUE db_sqlite3_adapter_rollback(int argc, VALUE *argv, VALUE self) {
+    VALUE savepoint, sql;
+    char command[256];
+
+    Adapter *a = db_sqlite3_adapter_handle_safe(self);
+    rb_scan_args(argc, argv, "01", &savepoint);
+
+    if (a->t_nesting == 0)
+        return Qfalse;
+
+    if (NIL_P(savepoint)) {
+        sql = rb_str_new2("rollback");
+        db_sqlite3_adapter_execute(1, &sql, self);
+        a->t_nesting--;
+    }
+    else {
+        snprintf(command, 256, "rollback to savepoint %s", CSTRING(savepoint));
+        sql = rb_str_new2(command);
+        db_sqlite3_adapter_execute(1, &sql, self);
+        a->t_nesting--;
+    }
+    return Qtrue;
+}
+
+VALUE db_sqlite3_adapter_transaction(int argc, VALUE *argv, VALUE self) {
+    int status;
+    VALUE savepoint, block, block_result;
+
+    Adapter *a = db_sqlite3_adapter_handle_safe(self);
+    rb_scan_args(argc, argv, "01&", &savepoint, &block);
+
+    if (NIL_P(block))
+        rb_raise(eSwiftRuntimeError, "sqlite3 transaction requires a block");
+
+    if (a->t_nesting == 0) {
+        db_sqlite3_adapter_begin(1, &savepoint, self);
+        block_result = rb_protect(rb_yield, self, &status);
+        if (!status) {
+            db_sqlite3_adapter_commit(1, &savepoint, self);
+            if (!NIL_P(savepoint))
+                db_sqlite3_adapter_commit(0, 0, self);
+        }
+        else {
+            db_sqlite3_adapter_rollback(1, &savepoint, self);
+            if (!NIL_P(savepoint))
+                db_sqlite3_adapter_rollback(0, 0, self);
+            rb_jump_tag(status);
+        }
+    }
+    else {
+        if (NIL_P(savepoint))
+            savepoint = rb_uuid_string();
+        db_sqlite3_adapter_begin(1, &savepoint, self);
+        block_result = rb_protect(rb_yield, self, &status);
+        if (!status)
+            db_sqlite3_adapter_commit(1, &savepoint, self);
+        else {
+            db_sqlite3_adapter_rollback(1, &savepoint, self);
+            rb_jump_tag(status);
+        }
+    }
+
+    return block_result;
+}
+
+VALUE db_sqlite3_adapter_close(VALUE self) {
+    Adapter *a = db_sqlite3_adapter_handle(self);
+    if (a->connection) {
+        sqlite3_close(a->connection);
+        a->connection = 0;
+        return Qtrue;
+    }
+    return Qfalse;
+}
+
+VALUE db_sqlite3_adapter_closed_q(VALUE self) {
+    Adapter *a = db_sqlite3_adapter_handle(self);
+    return a->connection ? Qfalse : Qtrue;
+}
+
+VALUE db_sqlite3_adapter_escape(VALUE self, VALUE text) {
+    VALUE escaped;
+    Adapter *a = db_sqlite3_adapter_handle_safe(self);
+    char *sqlite3_escaped = sqlite3_mprintf("%q", CSTRING(text));
+    escaped = rb_str_new2(sqlite3_escaped);
+    sqlite3_free(sqlite3_escaped);
+    return escaped;
+}
+
+void init_swift_db_sqlite3_adapter() {
+    cDSA = rb_define_class_under(mDB, "Sqlite3", rb_cObject);
+    rb_define_alloc_func(cDSA, db_sqlite3_adapter_allocate);
+
+    rb_define_method(cDSA, "initialize",  db_sqlite3_adapter_initialize,   1);
+    rb_define_method(cDSA, "prepare",     db_sqlite3_adapter_prepare,      1);
+    rb_define_method(cDSA, "execute",     db_sqlite3_adapter_execute,     -1);
+    rb_define_method(cDSA, "begin",       db_sqlite3_adapter_begin,       -1);
+    rb_define_method(cDSA, "commit",      db_sqlite3_adapter_commit,      -1);
+    rb_define_method(cDSA, "rollback",    db_sqlite3_adapter_rollback,    -1);
+    rb_define_method(cDSA, "transaction", db_sqlite3_adapter_transaction, -1);
+    rb_define_method(cDSA, "close",       db_sqlite3_adapter_close,        0);
+    rb_define_method(cDSA, "closed?",     db_sqlite3_adapter_closed_q,     0);
+    rb_define_method(cDSA, "escape",      db_sqlite3_adapter_escape,       1);
+}

data/ext/swift/db/sqlite3/adapter.h

@@ -0,0 +1,14 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+
+typedef struct Adapter {
+    sqlite3 *connection;
+    int t_nesting;
+} Adapter;
+
+void init_swift_db_sqlite3_adapter();

data/ext/swift/db/sqlite3/common.c

@@ -0,0 +1,19 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "common.h"
+#include "uuid/uuid.h"
+
+VALUE rb_uuid_string() {
+    size_t n;
+    uuid_t uuid;
+    char uuid_hex[sizeof(uuid_t) * 2 + 1];
+
+    uuid_generate(uuid);
+    for (n = 0; n < sizeof(uuid_t); n++)
+        sprintf(uuid_hex + n * 2 + 1, "%02x", uuid[n]);
+
+    uuid_hex[0] = 'u';
+    return rb_str_new(uuid_hex, sizeof(uuid_t) * 2 + 1);
+}

data/ext/swift/db/sqlite3/common.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#define DLL_PRIVATE __attribute__ ((visibility ("hidden")))
+#define CONST_GET(scope, constant) rb_funcall(scope, rb_intern("const_get"), 1, rb_str_new2(constant))
+#define TO_S(v)    rb_funcall(v, rb_intern("to_s"), 0)
+#define CSTRING(v) RSTRING_PTR(TO_S(v))
+
+#include <ruby/ruby.h>
+#include <ruby/encoding.h>
+
+#include <fcntl.h>
+#include <sqlite3.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+extern VALUE mSwift, mDB;
+extern VALUE cDSA, cDSS, cDSR;
+extern VALUE eSwiftError, eSwiftArgumentError, eSwiftRuntimeError, eSwiftConnectionError;
+
+VALUE rb_uuid_string();

data/ext/swift/db/sqlite3/datetime.c

@@ -0,0 +1,99 @@
+#include "datetime.h"
+#include <ctype.h>
+
+extern VALUE dtformat;
+
+VALUE cSwiftDateTime, day_seconds;
+ID fcivil, fparse, fstrptime;
+
+// NOTE: only parses '%F %T.%N %z' format and falls back to the built-in DateTime#parse
+//       and is almost 2x faster than doing:
+//
+//       rb_funcall(klass, fstrptime, 2, rb_str_new(data, size), dtformat);
+//
+VALUE datetime_parse(VALUE klass, const char *data, size_t size) {
+  struct tm tm;
+  double seconds;
+  const char *ptr;
+  char tzsign = 0, fraction[32];
+  int  tzhour = 0, tzmin = 0, lastmatch = -1, offset = 0, idx;
+
+  memset(&tm, 0, sizeof(struct tm));
+  sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%n",
+      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &lastmatch);
+
+  // fallback to default datetime parser, this is more expensive.
+  if (tm.tm_mday == 0)
+    return Qnil;
+
+  seconds = tm.tm_sec;
+
+  // parse millisecs if any -- tad faster than using %lf in sscanf above.
+  if (lastmatch > 0 && lastmatch < (int)size && *(data + lastmatch) == '.') {
+      idx = 0;
+      ptr = data + ++lastmatch;
+      while (*ptr && isdigit(*ptr) && idx < 31) {
+        lastmatch++;
+        fraction[idx++] = *ptr++;
+      }
+
+      fraction[idx] = 0;
+      seconds += (double)atoll(fraction) / pow(10, idx);
+  }
+
+  // parse timezone offsets if any - matches +HH:MM +HH MM +HHMM
+  if (lastmatch > 0 && lastmatch < (int)size) {
+    const char *ptr = data + lastmatch;
+    while(*ptr && *ptr != '+' && *ptr != '-') ptr++;
+    tzsign = *ptr++;
+    if (*ptr && isdigit(*ptr)) {
+      tzhour = *ptr++ - '0';
+      if (*ptr && isdigit(*ptr)) tzhour = tzhour * 10 + *ptr++ - '0';
+      while(*ptr && !isdigit(*ptr)) ptr++;
+      if (*ptr) {
+        tzmin = *ptr++ - '0';
+        if (*ptr && isdigit(*ptr)) tzmin = tzmin * 10 + *ptr++ - '0';
+      }
+    }
+  }
+
+  if (tzsign) {
+    offset = tzsign == '+'
+      ? (time_t)tzhour *  3600 + (time_t)tzmin *  60
+      : (time_t)tzhour * -3600 + (time_t)tzmin * -60;
+  }
+
+  return rb_funcall(klass, fcivil, 7,
+    INT2FIX(tm.tm_year), INT2FIX(tm.tm_mon), INT2FIX(tm.tm_mday),
+    INT2FIX(tm.tm_hour), INT2FIX(tm.tm_min), DBL2NUM(seconds),
+    offset == 0 ? INT2FIX(0) : rb_Rational(INT2FIX(offset), day_seconds)
+  );
+}
+
+VALUE rb_datetime_parse(VALUE self, VALUE string) {
+  VALUE datetime;
+  const char *data = CSTRING(string);
+  size_t size = TYPE(string) == T_STRING ? (size_t)RSTRING_LEN(string) : strlen(data);
+
+  if (NIL_P(string))
+    return Qnil;
+
+  datetime = datetime_parse(self, data, size);
+  return NIL_P(datetime) ? rb_call_super(1, &string) : datetime;
+}
+
+void init_swift_datetime() {
+  VALUE mSwift, cDateTime;
+
+  rb_require("date");
+  mSwift          = rb_define_module("Swift");
+  cDateTime       = CONST_GET(rb_mKernel, "DateTime");
+  cSwiftDateTime  = rb_define_class_under(mSwift, "DateTime", cDateTime);
+  fcivil          = rb_intern("civil");
+  fparse          = rb_intern("parse");
+  fstrptime       = rb_intern("strptime");
+  day_seconds     = INT2FIX(86400);
+
+  rb_global_variable(&day_seconds);
+  rb_define_singleton_method(cSwiftDateTime, "parse", RUBY_METHOD_FUNC(rb_datetime_parse), 1);
+}

data/ext/swift/db/sqlite3/datetime.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "common.h"
+#include <math.h>
+
+DLL_PRIVATE extern VALUE cSwiftDateTime;
+DLL_PRIVATE void init_swift_datetime();
+DLL_PRIVATE VALUE datetime_parse(VALUE klass, const char *data, size_t size);

data/ext/swift/db/sqlite3/extconf.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+find_library('sqlite3', 'main', '/usr/lib /usr/local/lib /opt/lib /opt/local/lib')
+find_library('uuid',    'main', '/usr/lib /usr/local/lib /opt/lib /opt/local/lib')
+create_makefile('swift_db_sqlite3_ext')
+

data/ext/swift/db/sqlite3/main.c

@@ -0,0 +1,28 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "common.h"
+#include "adapter.h"
+#include "statement.h"
+#include "result.h"
+#include "datetime.h"
+
+VALUE mSwift, mDB;
+VALUE eSwiftError, eSwiftArgumentError, eSwiftRuntimeError, eSwiftConnectionError;
+
+void Init_swift_db_sqlite3_ext() {
+    mSwift = rb_define_module("Swift");
+    mDB    = rb_define_module_under(mSwift, "DB");
+
+    eSwiftError           = rb_define_class_under(mSwift, "Error",           rb_eStandardError);
+    eSwiftArgumentError   = rb_define_class_under(mSwift, "ArgumentError",   eSwiftError);
+    eSwiftRuntimeError    = rb_define_class_under(mSwift, "RuntimeError",    eSwiftError);
+    eSwiftConnectionError = rb_define_class_under(mSwift, "ConnectionError", eSwiftError);
+
+    init_swift_db_sqlite3_adapter();
+    init_swift_db_sqlite3_statement();
+    init_swift_db_sqlite3_result();
+    init_swift_datetime();
+    init_swift_db_sqlite3_typecast();
+}

data/ext/swift/db/sqlite3/result.c

@@ -0,0 +1,236 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "result.h"
+
+/* declaration */
+
+typedef struct Result {
+    VALUE fields;
+    VALUE types;
+    VALUE rows;
+    VALUE statement;
+    sqlite3* c;
+    sqlite3_stmt *s;
+    size_t affected;
+    size_t insert_id;
+} Result;
+
+typedef struct Type {
+    int value;
+    const char *definition;
+} Type;
+
+VALUE cDSR;
+
+Statement* db_sqlite3_statement_handle(VALUE);
+
+/* definition */
+
+Result* db_sqlite3_result_handle(VALUE self) {
+    Result *r;
+    Data_Get_Struct(self, Result, r);
+    if (!r)
+        rb_raise(eSwiftRuntimeError, "Invalid sqlite3 result");
+    return r;
+}
+
+void db_sqlite3_result_mark(Result *r) {
+    if (r) {
+        if (!NIL_P(r->statement))
+            rb_gc_mark_maybe(r->statement);
+        if (!NIL_P(r->fields))
+            rb_gc_mark_maybe(r->fields);
+        if (!NIL_P(r->types))
+            rb_gc_mark_maybe(r->types);
+        if (!NIL_P(r->rows))
+            rb_gc_mark_maybe(r->rows);
+    }
+}
+
+VALUE db_sqlite3_result_deallocate(Result *r) {
+    if (r) free(r);
+}
+
+VALUE db_sqlite3_result_allocate(VALUE klass) {
+    Result *r = (Result*)malloc(sizeof(Result));
+    memset(r, 0, sizeof(Result));
+    return Data_Wrap_Struct(klass, db_sqlite3_result_mark, db_sqlite3_result_deallocate, r);
+}
+
+VALUE db_sqlite3_result_initialize(VALUE self, VALUE statement) {
+    Result *r    = db_sqlite3_result_handle(self);
+    Statement *s = db_sqlite3_statement_handle(statement);
+
+    r->fields    = rb_ary_new();
+    r->types     = rb_ary_new();
+    r->rows      = rb_ary_new();
+    r->statement = statement;
+    r->s         = s->s;
+    r->c         = s->c;
+    r->affected  = 0;
+
+    return self;
+}
+
+VALUE db_sqlite3_result_consume(VALUE self) {
+    int n, i, rc;
+    const char *type, *data;
+    Result *r = db_sqlite3_result_handle(self);
+
+    Type types[] = {
+        {SWIFT_TYPE_INT,        "int"},
+        {SWIFT_TYPE_INT,        "integer"},
+        {SWIFT_TYPE_INT,        "bigint"},
+        {SWIFT_TYPE_FLOAT,      "real"},
+        {SWIFT_TYPE_FLOAT,      "float"},
+        {SWIFT_TYPE_NUMERIC,    "decimal"},
+        {SWIFT_TYPE_NUMERIC,    "numeric"},
+        {SWIFT_TYPE_BOOLEAN,    "bool"},
+        {SWIFT_TYPE_BOOLEAN,    "boolean"},
+        {SWIFT_TYPE_DATE,       "date"},
+        {SWIFT_TYPE_TIME,       "time"},
+        {SWIFT_TYPE_TIMESTAMP,  "timestamp"},
+        {SWIFT_TYPE_TIMESTAMP,  "datetime"},
+        {SWIFT_TYPE_TEXT,       "text"},
+        {SWIFT_TYPE_TEXT,       "char"},
+        {SWIFT_TYPE_TEXT,       "varchar"},
+        {SWIFT_TYPE_BLOB,       "blob"},
+        {SWIFT_TYPE_UNKNOWN,    "unknown"}
+    };
+
+    int lazy_types = 0;
+    size_t ntypes = sizeof(types) / sizeof(Type);
+
+    rb_ary_clear(r->fields);
+    rb_ary_clear(r->types);
+    rb_ary_clear(r->rows);
+
+    for (n = 0; n < sqlite3_column_count(r->s); n++) {
+        rb_ary_push(r->fields, ID2SYM(rb_intern(sqlite3_column_name(r->s, n))));
+
+        type = sqlite3_column_decltype(r->s, n);
+        if (!type) {
+            lazy_types = 1;
+            rb_ary_push(r->types, INT2NUM(SWIFT_TYPE_UNKNOWN));
+            continue;
+        }
+
+        for (i = 0; i < (int)ntypes; i++) {
+            if (strcmp(type, types[i].definition) == 0 || types[i].value == SWIFT_TYPE_UNKNOWN) {
+                rb_ary_push(r->types, INT2NUM(types[i].value));
+                break;
+            }
+        }
+    }
+
+    r->affected = sqlite3_total_changes(r->c);
+
+    while ((rc = sqlite3_step(r->s)) == SQLITE_ROW) {
+        VALUE row = rb_ary_new();
+
+        /* type determination of aggregrations can only be determined after a row is pulled out */
+        if (lazy_types) {
+            for (n = 0; n < RARRAY_LEN(r->types); n++) {
+                if (NUM2INT(rb_ary_entry(r->types, n)) == SWIFT_TYPE_UNKNOWN) {
+                    switch(sqlite3_column_type(r->s, n)) {
+                        case SQLITE_INTEGER:
+                            rb_ary_store(r->types, n, INT2NUM(SWIFT_TYPE_INT)); break;
+                        case SQLITE_FLOAT:
+                            rb_ary_store(r->types, n, INT2NUM(SWIFT_TYPE_FLOAT)); break;
+                        case SQLITE_BLOB:
+                            rb_ary_store(r->types, n, INT2NUM(SWIFT_TYPE_BLOB)); break;
+                        default:
+                            rb_ary_store(r->types, n, INT2NUM(SWIFT_TYPE_TEXT));
+                    }
+                }
+            }
+            lazy_types = 0;
+        }
+
+        for (n = 0; n < sqlite3_column_count(r->s); n++) {
+            switch (sqlite3_column_type(r->s, n)) {
+                case SQLITE_NULL:
+                    rb_ary_push(row, Qnil);
+                    break;
+                case SQLITE_TEXT:
+                case SQLITE_BLOB:
+                    data = sqlite3_column_blob(r->s, n);
+                    rb_ary_push(row, typecast_detect(data, sqlite3_column_bytes(r->s, n), NUM2INT(rb_ary_entry(r->types, n))));
+                    break;
+                default:
+                    data = sqlite3_column_text(r->s, n);
+                    rb_ary_push(row, typecast_detect(data, strlen(data), NUM2INT(rb_ary_entry(r->types, n))));
+            }
+        }
+        rb_ary_push(r->rows, row);
+    }
+
+    if (rc != SQLITE_DONE)
+        rb_raise(eSwiftRuntimeError, "%s\nSQL: %s", sqlite3_errmsg(r->c), sqlite3_sql(r->s));
+
+    r->affected  = sqlite3_total_changes(r->c) - r->affected;
+    r->insert_id = sqlite3_last_insert_rowid(r->c);
+    sqlite3_reset(r->s);
+
+    return self;
+}
+
+VALUE db_sqlite3_result_each(VALUE self) {
+    int n, f;
+    Result *r = db_sqlite3_result_handle(self);
+
+    if (!r->rows) return Qnil;
+
+    for (n = 0; n < RARRAY_LEN(r->rows); n++) {
+        VALUE tuple = rb_hash_new();
+        VALUE row   = rb_ary_entry(r->rows, n);
+        for (f = 0; f < RARRAY_LEN(r->fields); f++)
+            rb_hash_aset(tuple, rb_ary_entry(r->fields, f), rb_ary_entry(row, f));
+        rb_yield(tuple);
+    }
+}
+
+VALUE db_sqlite3_result_selected_rows(VALUE self) {
+    Result *r = db_sqlite3_result_handle(self);
+    return r->rows ? SIZET2NUM(RARRAY_LEN(r->rows)) : INT2NUM(0);
+}
+
+VALUE db_sqlite3_result_affected_rows(VALUE self) {
+    Result *r = db_sqlite3_result_handle(self);
+    return SIZET2NUM(r->affected);
+}
+
+VALUE db_sqlite3_result_fields(VALUE self) {
+    Result *r = db_sqlite3_result_handle(self);
+    return r->fields ? r->fields : rb_ary_new();
+}
+
+VALUE db_sqlite3_result_types(VALUE self) {
+    Result *r = db_sqlite3_result_handle(self);
+    return r->types ? typecast_description(r->types) : rb_ary_new();
+}
+
+VALUE db_sqlite3_result_insert_id(VALUE self) {
+    Result *r = db_sqlite3_result_handle(self);
+    return SIZET2NUM(r->insert_id);
+}
+
+void init_swift_db_sqlite3_result() {
+    rb_require("bigdecimal");
+    rb_require("stringio");
+    rb_require("date");
+
+    cDSR = rb_define_class_under(cDSA, "Result", rb_cObject);
+
+    rb_include_module(cDSR, rb_mEnumerable);
+    rb_define_alloc_func(cDSR, db_sqlite3_result_allocate);
+    rb_define_method(cDSR, "initialize",    db_sqlite3_result_initialize,    1);
+    rb_define_method(cDSR, "each",          db_sqlite3_result_each,          0);
+    rb_define_method(cDSR, "selected_rows", db_sqlite3_result_selected_rows, 0);
+    rb_define_method(cDSR, "affected_rows", db_sqlite3_result_affected_rows, 0);
+    rb_define_method(cDSR, "fields",        db_sqlite3_result_fields,        0);
+    rb_define_method(cDSR, "types",         db_sqlite3_result_types,         0);
+    rb_define_method(cDSR, "insert_id",     db_sqlite3_result_insert_id,     0);
+}

data/ext/swift/db/sqlite3/result.h

@@ -0,0 +1,11 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+#include "statement.h"
+#include "typecast.h"
+
+void init_swift_db_sqlite3_result();

data/ext/swift/db/sqlite3/statement.c

@@ -0,0 +1,114 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "statement.h"
+#include "typecast.h"
+
+/* declaration */
+
+VALUE cDSS;
+
+Adapter* db_sqlite3_adapter_handle_safe(VALUE);
+VALUE    db_sqlite3_result_allocate(VALUE);
+VALUE    db_sqlite3_result_initialize(VALUE, VALUE);
+VALUE    db_sqlite3_result_consume(VALUE);
+VALUE    db_sqlite3_result_each(VALUE);
+
+/* definition */
+
+Statement* db_sqlite3_statement_handle(VALUE self) {
+    Statement *s;
+    Data_Get_Struct(self, Statement, s);
+    if (!s)
+        rb_raise(eSwiftRuntimeError, "Invalid sqlite3 statement");
+    return s;
+}
+
+Statement* db_sqlite3_statement_handle_safe(VALUE self) {
+    Statement *s = db_sqlite3_statement_handle(self);
+    if (!s->s)
+        rb_raise(eSwiftRuntimeError, "Statement instance not allocated or has been released");
+    return s;
+}
+
+void db_sqlite3_statement_mark(Statement *s) {
+    if (s && !NIL_P(s->adapter))
+        rb_gc_mark_maybe(s->adapter);
+}
+
+VALUE db_sqlite3_statement_deallocate(Statement *s) {
+    if (s && s->s) {
+        sqlite3_finalize(s->s);
+        free(s);
+    }
+}
+
+VALUE db_sqlite3_statement_allocate(VALUE klass) {
+    Statement *s = (Statement*)malloc(sizeof(Statement));
+    memset(s, 0, sizeof(Statement));
+    return Data_Wrap_Struct(klass, db_sqlite3_statement_mark, db_sqlite3_statement_deallocate, s);
+}
+
+VALUE db_sqlite3_statement_initialize(VALUE self, VALUE adapter, VALUE sql) {
+    Statement *s = db_sqlite3_statement_handle(self);
+
+    s->s       = 0;
+    s->c       = db_sqlite3_adapter_handle_safe(adapter)->connection;
+    s->adapter = adapter;
+
+    if (sqlite3_prepare_v2(s->c, RSTRING_PTR(sql), RSTRING_LEN(sql), &(s->s), 0) != SQLITE_OK)
+        rb_raise(eSwiftRuntimeError, "%s\nSQL: %s", sqlite3_errmsg(s->c), RSTRING_PTR(sql));
+
+    return self;
+}
+
+VALUE db_sqlite3_statement_insert_id(VALUE self) {
+    Statement *s = db_sqlite3_statement_handle_safe(self);
+    return SIZET2NUM(sqlite3_last_insert_rowid(s->c));
+}
+
+VALUE db_sqlite3_statement_execute(int argc, VALUE *argv, VALUE self) {
+    int expect, n;
+    VALUE bind, result;
+
+    Statement *s = db_sqlite3_statement_handle_safe(self);
+
+    sqlite3_reset(s->s);
+    sqlite3_clear_bindings(s->s);
+
+    rb_scan_args(argc, argv, "00*", &bind);
+    expect = sqlite3_bind_parameter_count(s->s);
+    if (expect != RARRAY_LEN(bind))
+        rb_raise(eSwiftArgumentError, "expected %d bind values got %d", expect, RARRAY_LEN(bind));
+
+    for (n = 0; n < expect; n++) {
+        VALUE value = rb_ary_entry(bind, n);
+        if (NIL_P(value))
+            sqlite3_bind_null(s->s, n + 1);
+        else {
+            VALUE text = typecast_to_string(value);
+            sqlite3_bind_text(s->s, n + 1, RSTRING_PTR(text), RSTRING_LEN(text), 0);
+        }
+    }
+
+    result = db_sqlite3_result_allocate(cDSR);
+    db_sqlite3_result_initialize(result, self);
+    db_sqlite3_result_consume(result);
+    return result;
+}
+
+VALUE db_sqlite3_statement_release(VALUE self) {
+    Statement *s = db_sqlite3_statement_handle_safe(self);
+    sqlite3_finalize(s->s);
+    s->s = 0;
+    return Qtrue;
+}
+
+void init_swift_db_sqlite3_statement() {
+    cDSS = rb_define_class_under(cDSA, "Statement", rb_cObject);
+    rb_define_alloc_func(cDSS, db_sqlite3_statement_allocate);
+    rb_define_method(cDSS, "initialize", db_sqlite3_statement_initialize, 2);
+    rb_define_method(cDSS, "execute",    db_sqlite3_statement_execute,   -1);
+    rb_define_method(cDSS, "release",    db_sqlite3_statement_release,    0);
+}

data/ext/swift/db/sqlite3/statement.h

@@ -0,0 +1,17 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+#include "adapter.h"
+
+void init_swift_db_sqlite3_statement();
+
+typedef struct Statement {
+    sqlite3 *c;
+    sqlite3_stmt *s;
+    VALUE adapter;
+} Statement;
+

data/ext/swift/db/sqlite3/typecast.c

@@ -0,0 +1,106 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#include "common.h"
+#include "typecast.h"
+#include "datetime.h"
+
+#define date_parse(klass, data,len) rb_funcall(datetime_parse(klass, data, len), fto_date, 0)
+
+ID fnew, fto_date, fstrftime;
+VALUE cBigDecimal, cStringIO;
+VALUE dtformat;
+VALUE cDateTime;
+
+VALUE typecast_string(const char *data, size_t n) {
+    return rb_enc_str_new(data, n, rb_utf8_encoding());
+}
+
+VALUE typecast_detect(const char *data, size_t size, int type) {
+    switch (type) {
+        case SWIFT_TYPE_INT:
+            return rb_cstr2inum(data, 10);
+        case SWIFT_TYPE_FLOAT:
+            return rb_float_new(atof(data));
+        case SWIFT_TYPE_NUMERIC:
+            return rb_funcall(cBigDecimal, fnew, 1, rb_str_new(data, size));
+        case SWIFT_TYPE_BOOLEAN:
+            return (data && (data[0] =='t' || data[0] == '1')) ? Qtrue : Qfalse;
+        case SWIFT_TYPE_BLOB:
+            return rb_funcall(cStringIO, fnew, 1, rb_str_new(data, size));
+        case SWIFT_TYPE_TIMESTAMP:
+            return datetime_parse(cSwiftDateTime, data, size);
+        case SWIFT_TYPE_DATE:
+            return date_parse(cSwiftDateTime, data, size);
+        default:
+            return rb_enc_str_new(data, size, rb_utf8_encoding());
+    }
+}
+
+#define TO_UTF8(value) rb_str_encode(value, rb_str_new2("UTF-8"), 0, Qnil)
+#define UTF8_STRING(value) strcmp(rb_enc_get(value)->name, "UTF-8") ? TO_UTF8(value) : value
+
+VALUE typecast_to_string(VALUE value) {
+    switch (TYPE(value)) {
+        case T_STRING:
+            return UTF8_STRING(value);
+        case T_TRUE:
+            return rb_str_new2("1");
+        case T_FALSE:
+            return rb_str_new2("0");
+        default:
+            if (rb_obj_is_kind_of(value, rb_cTime) || rb_obj_is_kind_of(value, cDateTime))
+                return rb_funcall(value, fstrftime, 1, dtformat);
+            else if (rb_obj_is_kind_of(value, rb_cIO) || rb_obj_is_kind_of(value, cStringIO))
+                return rb_funcall(value, rb_intern("read"), 0);
+            else
+                return UTF8_STRING(rb_funcall(value, rb_intern("to_s"), 0));
+    }
+}
+
+VALUE typecast_description(VALUE list) {
+    int n;
+    VALUE types = rb_ary_new();
+
+    for (n = 0; n < RARRAY_LEN(list); n++) {
+        switch (NUM2INT(rb_ary_entry(list, n))) {
+            case SWIFT_TYPE_INT:
+                rb_ary_push(types, rb_str_new2("integer")); break;
+            case SWIFT_TYPE_NUMERIC:
+                rb_ary_push(types, rb_str_new2("numeric")); break;
+            case SWIFT_TYPE_FLOAT:
+                rb_ary_push(types, rb_str_new2("float")); break;
+            case SWIFT_TYPE_BLOB:
+                rb_ary_push(types, rb_str_new2("blob")); break;
+            case SWIFT_TYPE_DATE:
+                rb_ary_push(types, rb_str_new2("date")); break;
+            case SWIFT_TYPE_TIME:
+                rb_ary_push(types, rb_str_new2("time")); break;
+            case SWIFT_TYPE_TIMESTAMP:
+                rb_ary_push(types, rb_str_new2("timestamp")); break;
+            case SWIFT_TYPE_BOOLEAN:
+                rb_ary_push(types, rb_str_new2("boolean")); break;
+            default:
+                rb_ary_push(types, rb_str_new2("text"));
+
+        }
+    }
+    return types;
+}
+
+void init_swift_db_sqlite3_typecast() {
+    rb_require("bigdecimal");
+    rb_require("stringio");
+    rb_require("date");
+
+    cStringIO   = CONST_GET(rb_mKernel, "StringIO");
+    cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
+    cDateTime   = CONST_GET(rb_mKernel, "DateTime");
+    fnew        = rb_intern("new");
+    fto_date    = rb_intern("to_date");
+    fstrftime   = rb_intern("strftime");
+    dtformat    = rb_str_new2("%F %T.%N %z");
+
+    rb_global_variable(&dtformat);
+}

data/ext/swift/db/sqlite3/typecast.h

@@ -0,0 +1,24 @@
+// vim:ts=4:sts=4:sw=4:expandtab
+
+// (c) Bharanee Rathna 2012
+
+#pragma once
+
+#include "common.h"
+
+#define SWIFT_TYPE_INT       0
+#define SWIFT_TYPE_FLOAT     1
+#define SWIFT_TYPE_NUMERIC   2
+#define SWIFT_TYPE_BOOLEAN   3
+#define SWIFT_TYPE_DATE      4
+#define SWIFT_TYPE_TIME      5
+#define SWIFT_TYPE_TIMESTAMP 6
+#define SWIFT_TYPE_TEXT      7
+#define SWIFT_TYPE_BLOB      8
+#define SWIFT_TYPE_UNKNOWN   9
+
+DLL_PRIVATE VALUE typecast_to_string(VALUE);
+DLL_PRIVATE VALUE typecast_string(const char *, size_t);
+DLL_PRIVATE VALUE typecast_detect(const char *, size_t, int);
+DLL_PRIVATE VALUE typecast_description(VALUE list);
+DLL_PRIVATE void  init_swift_db_sqlite3_typecast();

data/lib/swift-db-sqlite3.rb

@@ -0,0 +1 @@
+require 'swift/db/sqlite3'

data/lib/swift/db/sqlite3.rb

@@ -0,0 +1 @@
+require 'swift/db/sqlite3/swift_db_sqlite3_ext'

data/test/helper.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+require 'swift/db/sqlite3'
+
+class MiniTest::Spec
+  def db
+    @db ||= Swift::DB::Sqlite3.new(db: ':memory:')
+  end
+end

data/test/test_adapter.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+describe 'sqlite3 adapter' do
+  it 'should initialize' do
+    assert db
+  end
+
+  it 'should execute sql' do
+    assert db.execute("select name from sqlite_master")
+  end
+
+  it 'should expect the correct number of bind args' do
+    assert_raises(Swift::ArgumentError) { db.execute("select * from sqlite_master where name = ?", 1, 2) }
+  end
+
+  it 'should return result on #execute' do
+    now = Time.now
+    assert db.execute('create table users (id integer primary key, name text, age integer, created_at timestamp)')
+    assert db.execute('insert into users(name, age, created_at) values(?, ?, ?)', 'test', nil, now)
+
+    result = db.execute('select * from users')
+
+    assert_equal 1, result.selected_rows
+    assert_equal 0, result.affected_rows
+    assert_equal %w(id name age created_at).map(&:to_sym), result.fields
+    assert_equal %w(integer text integer timestamp), result.types
+
+    row = result.first
+    assert_equal 1,      row[:id]
+    assert_equal 'test', row[:name]
+    assert_equal nil,    row[:age]
+    assert_equal now,    row[:created_at].to_time
+
+    result = db.execute('delete from users where id = 0')
+    assert_equal 0, result.selected_rows
+    assert_equal 0, result.affected_rows
+
+    assert_equal 1, db.execute('select count(*) as count from users').first[:count]
+
+    result = db.execute('delete from users')
+    assert_equal 0, result.selected_rows
+    assert_equal 1, result.affected_rows
+  end
+
+  it 'should close handle' do
+    assert !db.closed?
+    assert db.close
+    assert db.closed?
+
+    assert_raises(Swift::ConnectionError) { db.execute("select * from users") }
+  end
+
+  it 'should prepare & release statement' do
+    assert db.execute("create table users(id integer primary key, name text)")
+    assert db.execute("insert into users (name) values (?)", "test")
+    assert s = db.prepare("select * from users where id > ?")
+
+    assert_equal 1, s.execute(0).selected_rows
+    assert_equal 0, s.execute(1).selected_rows
+
+    assert s.release
+    assert_raises(Swift::RuntimeError) { s.execute(1) }
+  end
+
+  it 'should escape whatever' do
+    assert_equal "foo''bar", db.escape("foo'bar")
+  end
+end

data/test/test_encoding.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+describe 'utf-8 encoding' do
+  before do
+    assert db.execute('create table users (name text)')
+
+    @text = ["King of \u2665s", "\xA1\xB8".force_encoding('euc-jp')]
+  end
+
+  it 'should store and retrieve utf8 characters with Statement#execute' do
+    @text.each do |name|
+      db.prepare('insert into users (name) values(?)').execute(name)
+      value = db.prepare('select * from users limit 1').execute.first[:name]
+      assert_equal Encoding::UTF_8, value.encoding
+      assert_equal name.encode('utf-8'), value
+      db.execute('delete from users')
+    end
+  end
+
+  it 'should store and retrieve utf8 characters Adapter#execute' do
+    @text.each do |name|
+      db.execute('insert into users (name) values(?)', name)
+      value = db.execute('select * from users limit 1').first[:name]
+      assert_equal Encoding::UTF_8, value.encoding
+      assert_equal name.encode('utf-8'), value
+      db.execute('delete from users')
+    end
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: swift-db-sqlite3
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Bharanee Rathna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Swift adapter for Sqlite3 database
+email:
+- deepfryed@gmail.com
+executables: []
+extensions:
+- ext/swift/db/sqlite3/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/swift/db/sqlite3/adapter.c
+- ext/swift/db/sqlite3/datetime.c
+- ext/swift/db/sqlite3/typecast.c
+- ext/swift/db/sqlite3/common.c
+- ext/swift/db/sqlite3/main.c
+- ext/swift/db/sqlite3/statement.c
+- ext/swift/db/sqlite3/result.c
+- ext/swift/db/sqlite3/adapter.h
+- ext/swift/db/sqlite3/statement.h
+- ext/swift/db/sqlite3/typecast.h
+- ext/swift/db/sqlite3/common.h
+- ext/swift/db/sqlite3/result.h
+- ext/swift/db/sqlite3/datetime.h
+- ext/swift/db/sqlite3/extconf.rb
+- test/test_encoding.rb
+- test/helper.rb
+- test/test_adapter.rb
+- lib/swift/db/sqlite3.rb
+- lib/swift-db-sqlite3.rb
+- README.md
+- CHANGELOG
+homepage: http://github.com/deepfryed/swift-db-sqlite3
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Swift sqlite3 adapter
+test_files: []
+has_rdoc: