rdo-sqlite 0.0.1

data/ext/rdo_sqlite/statements.c

@@ -0,0 +1,269 @@
+/*
+ * RDO SQLite3 Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "statements.h"
+#include "driver.h"
+#include "macros.h"
+
+/** Sruct wrapped by class RDO::SQLite::StatementExecutor */
+typedef struct {
+  RDOSQLiteDriver * driver;
+  char            * cmd;
+  sqlite3_stmt    * stmt;
+} RDOSQLiteStatementExecutor;
+
+/** RDO::SQLite::StatementExecutor class */
+VALUE rdo_sqlite_cStatementExecutor;
+
+/** Free memory associated with the statement during GC */
+static void rdo_sqlite_statement_executor_free(RDOSQLiteStatementExecutor * executor) {
+  sqlite3_finalize(executor->stmt);
+  free(executor);
+}
+
+/** Check if the 'tail' of a query points to something other than a comment */
+static int rdo_sqlite_inert_p(char * s) {
+  int  inslcmt = 0;
+  int  inmlcmt = 0;
+
+  for (; *s; ++s) {
+    switch (*s) {
+      case ' ':
+      case '\t':
+        break;
+
+      case '\r':
+      case '\n':
+        inslcmt = 0;
+        break;
+
+      case '/':
+        if (!inslcmt && *(s + 1) == '*') {
+          inmlcmt = 1;
+          ++s;
+        } else if (!inslcmt && !inmlcmt) {
+          return 0;
+        }
+        break;
+
+      case '*':
+        if (inmlcmt && *(s + 1) == '/') {
+          inmlcmt = 0;
+          ++s;
+        } else if (!inslcmt && !inmlcmt) {
+          return 0;
+        }
+        break;
+
+      case '-':
+        if (!inmlcmt && *(s + 1) == '-') {
+          inslcmt = 1;
+          ++s;
+        } else if (!inslcmt && !inmlcmt) {
+          return 0;
+        }
+        break;
+
+      default:
+        if (!inslcmt && !inmlcmt) {
+          return 0;
+        }
+    }
+  }
+
+  return 1;
+}
+
+/** Create a new statement executor for the given command */
+VALUE rdo_sqlite_statement_executor_new(VALUE driver, VALUE cmd) {
+  Check_Type(cmd, T_STRING);
+
+  RDOSQLiteStatementExecutor * executor =
+    malloc(sizeof(RDOSQLiteStatementExecutor));
+
+  Data_Get_Struct(driver, RDOSQLiteDriver, executor->driver);
+  executor->cmd    = strdup(RSTRING_PTR(cmd));
+  executor->stmt   = NULL;
+
+  VALUE self = Data_Wrap_Struct(rdo_sqlite_cStatementExecutor, 0,
+      rdo_sqlite_statement_executor_free, executor);
+
+  rb_obj_call_init(self, 1, &driver);
+
+  return self;
+}
+
+/** Initialize the statement (prepare it) */
+static VALUE rdo_sqlite_statement_executor_initialize(VALUE self, VALUE driver) {
+  rb_iv_set(self, "driver", driver); // GC safety
+  RDOSQLiteStatementExecutor * executor;
+  Data_Get_Struct(self, RDOSQLiteStatementExecutor, executor);
+
+  if (!(executor->driver->is_open)) {
+    RDO_ERROR("Cannot execute prepare statement: database is not open");
+  }
+
+  const char * tail;
+
+  int status = sqlite3_prepare_v2(executor->driver->db,
+      executor->cmd,
+      (int) strlen(executor->cmd) + 1,
+      &(executor->stmt),
+      &tail);
+
+  if ((status != SQLITE_OK) || sqlite3_errcode(executor->driver->db)) {
+    RDO_ERROR("Failed to prepare statement: %s",
+        sqlite3_errmsg(executor->driver->db));
+  }
+
+  if (!rdo_sqlite_inert_p((char *) tail)) {
+    rb_raise(rb_eArgError, "Only one statement can be executed at a time");
+  }
+
+  return self;
+}
+
+/** Get the command this statement will execute */
+static VALUE rdo_sqlite_statement_executor_command(VALUE self) {
+  RDOSQLiteStatementExecutor * executor;
+  Data_Get_Struct(self, RDOSQLiteStatementExecutor, executor);
+  return rb_str_new2(executor->cmd);
+}
+
+/** Fetch the value from the given column in the result and convert to a Ruby type */
+static VALUE rdo_sqlite_cast_value(sqlite3_stmt * stmt, int col) {
+  switch (sqlite3_column_type(stmt, col)) {
+    case SQLITE_NULL:
+      return Qnil;
+
+    case SQLITE_INTEGER:
+      return LL2NUM(sqlite3_column_int64(stmt, col));
+
+    case SQLITE_FLOAT:
+      return DBL2NUM(sqlite3_column_double(stmt, col));
+
+    case SQLITE_TEXT:
+      return RDO_STRING((const char *) sqlite3_column_text(stmt, col),
+          sqlite3_column_bytes(stmt, col), 1);
+
+    case SQLITE_BLOB:
+      return RDO_BINARY_STRING((const char *) sqlite3_column_blob(stmt, col),
+          sqlite3_column_bytes(stmt, col));
+
+    default:
+      return RDO_BINARY_STRING((const char *) sqlite3_column_text(stmt, col),
+          sqlite3_column_bytes(stmt, col));
+  }
+}
+
+/** Extract useful result information from the db and the statement */
+static VALUE rdo_sqlite_result_info(sqlite3 * db, sqlite3_stmt * stmt) {
+  VALUE info = rb_hash_new();
+  rb_hash_aset(info, ID2SYM(rb_intern("insert_id")),
+      LL2NUM(sqlite3_last_insert_rowid(db)));
+  rb_hash_aset(info, ID2SYM(rb_intern("affected_rows")),
+      LL2NUM(sqlite3_changes(db)));
+  return info;
+}
+
+/** Bind all input values to the statement */
+static void rdo_sqlite_statement_bind_args(sqlite3_stmt * stmt, int argc, VALUE * args) {
+  if (sqlite3_bind_parameter_count(stmt) != argc) {
+    rb_raise(rb_eArgError,
+        "Bind parameter count mismatch: wanted %i, got %i",
+        sqlite3_bind_parameter_count(stmt),
+        argc);
+  }
+
+  VALUE v;
+  int   i = 0;
+
+  for (; i < argc; ++i) {
+    v = args[i];
+
+    if (v == Qnil) {
+      sqlite3_bind_null(stmt, i);
+    } else {
+      if (v == Qtrue)          v = INT2NUM(1);
+      if (v == Qfalse)         v = INT2NUM(0);
+
+      if ((rb_funcall(v, rb_intern("kind_of?"), 1, rb_cTime) == Qtrue)
+          || rb_funcall(v, rb_intern("kind_of?"), 1, rb_path2class("DateTime"))) {
+        v = rb_funcall(v, rb_intern("strftime"), 1, rb_str_new2("%F %T"));
+      }
+
+      if (TYPE(v) != T_STRING) v = RDO_OBJ_TO_S(v);
+
+      sqlite3_bind_text(stmt, i + 1,
+          RSTRING_PTR(v), (int) RSTRING_LEN(v), NULL);
+    }
+  }
+}
+
+/** Iterate over all rows in the result and return an Array */
+static VALUE rdo_sqlite_statement_extract_tuples(sqlite3 * db, sqlite3_stmt * stmt) {
+  int   status;
+  int   col     = 0;
+  int   ncols   = 0;
+  VALUE hash;
+  VALUE tuples  = rb_ary_new();
+
+  while ((status = sqlite3_step(stmt)) == SQLITE_ROW) {
+    hash  = rb_hash_new();
+    ncols = sqlite3_column_count(stmt);
+
+    for (col = 0; col < ncols; ++col) {
+      rb_hash_aset(hash,
+          ID2SYM(rb_intern(sqlite3_column_name(stmt, col))),
+          rdo_sqlite_cast_value(stmt, col));
+    }
+
+    rb_ary_push(tuples, hash);
+  }
+
+  if (status != SQLITE_DONE) {
+    RDO_ERROR("Failed to execute statement: %s", sqlite3_errmsg(db));
+  }
+
+  return tuples;
+}
+
+/** Execute the statement with the given bind parameters and return a Result */
+static VALUE rdo_sqlite_statement_executor_execute(int argc, VALUE * args, VALUE self) {
+  RDOSQLiteStatementExecutor * executor;
+  Data_Get_Struct(self, RDOSQLiteStatementExecutor, executor);
+
+  if (!(executor->driver->is_open)) {
+    RDO_ERROR("Cannot execute execute statement: database is not open");
+  }
+
+  rdo_sqlite_statement_bind_args(executor->stmt, argc, args);
+
+  VALUE tuples = rdo_sqlite_statement_extract_tuples(executor->driver->db, executor->stmt);
+  VALUE info   = rdo_sqlite_result_info(executor->driver->db, executor->stmt);
+  sqlite3_reset(executor->stmt);
+
+  return RDO_RESULT(tuples, info);
+}
+
+/** Initialize the statements framework */
+void Init_rdo_sqlite_statements(void) {
+  rb_require("date");
+
+  VALUE mSQLite = rb_path2class("RDO::SQLite");
+  rdo_sqlite_cStatementExecutor = rb_define_class_under(
+      mSQLite, "StatementExecutor", rb_cObject);
+
+  rb_define_method(rdo_sqlite_cStatementExecutor,
+      "initialize", rdo_sqlite_statement_executor_initialize, 1);
+  rb_define_method(rdo_sqlite_cStatementExecutor,
+      "command", rdo_sqlite_statement_executor_command, 0);
+  rb_define_method(rdo_sqlite_cStatementExecutor,
+      "execute", rdo_sqlite_statement_executor_execute, -1);
+}

data/ext/rdo_sqlite/statements.h

@@ -0,0 +1,15 @@
+/*
+ * RDO SQLite3 Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include <sqlite3.h>
+
+/** Create a new prepared statement executor for the given command */
+VALUE rdo_sqlite_statement_executor_new(VALUE driver, VALUE cmd);
+
+/** Initialize the prepared statements class */
+void Init_rdo_sqlite_statements(void);

data/lib/rdo/sqlite/driver.rb

@@ -0,0 +1,23 @@
+##
+# RDO SQLite3 driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+module RDO
+  module SQLite
+    # Main Driver class to hook into sqlite3 API
+    class Driver < RDO::Driver
+      def execute(stmt, *args)
+        prepare(stmt).execute(*args)
+      end
+
+      private
+
+      def filename
+        options[:path].to_s
+      end
+    end
+  end
+end

data/lib/rdo/sqlite/version.rb

@@ -0,0 +1,12 @@
+##
+# RDO SQLite3 driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+module RDO
+  module SQLite
+    VERSION = "0.0.1"
+  end
+end

data/lib/rdo/sqlite.rb

@@ -0,0 +1,16 @@
+##
+# RDO SQLite3 driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+require "rdo"
+require "rdo/sqlite/version"
+require "rdo/sqlite/driver"
+require "rdo_sqlite/rdo_sqlite" # c extension
+
+# Register driver with RDO
+%w[sqlite sqlite3].each do |name|
+  RDO::Connection.register_driver(name, RDO::SQLite::Driver)
+end

data/lib/rdo-sqlite.rb

@@ -0,0 +1 @@
+require "rdo/sqlite"

data/rdo-sqlite.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rdo/sqlite/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["d11wtq"]
+  gem.email         = ["chris@w3style.co.uk"]
+  gem.description   = "Provides access to SQLite3 using the RDO interface"
+  gem.summary       = "SQLite3 Driver for RDO"
+  gem.homepage      = "https://github.com/d11wtq/rdo-sqlite"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rdo-sqlite"
+  gem.require_paths = ["lib"]
+  gem.version       = RDO::SQLite::VERSION
+  gem.extensions    = ["ext/rdo_sqlite/extconf.rb"]
+
+  gem.add_runtime_dependency "rdo", ">= 0.0.1"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake-compiler"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "rdo"
+require "rdo/sqlite"
+
+ENV["CONNECTION"] ||= "sqlite://memory?encoding=utf-8"
+
+RSpec.configure do |config|
+  def connection_uri
+    ENV["CONNECTION"]
+  end
+end

data/spec/sqlite/bind_params_spec.rb

@@ -0,0 +1,316 @@
+require "spec_helper"
+require "bigdecimal"
+require "date"
+
+describe RDO::SQLite::Driver, "bind params" do
+  let(:options) { "sqlite::memory:" }
+  let(:db)      { RDO.connect(options) }
+  let(:table)   { "" }
+  let(:tuple)   { db.execute("SELECT * FROM test").first }
+
+  before(:each) { db.execute(table) }
+
+  describe "nil param" do
+    context "against a text field" do
+      let(:table)   { "CREATE TABLE test (name text)" }
+
+      before(:each) { db.execute("INSERT INTO test (name) VALUES (?)", nil) }
+
+      it "is inferred correctly" do
+        tuple[:name].should be_nil
+      end
+    end
+
+    context "against an integer field" do
+      let(:table)   { "CREATE TABLE test (age integer)" }
+
+      before(:each) { db.execute("INSERT INTO test (age) VALUES (?)", nil) }
+
+      it "is inferred correctly" do
+        tuple[:age].should be_nil
+      end
+    end
+
+    context "against a float field" do
+      let(:table)   { "CREATE TABLE test (score float)" }
+
+      before(:each) { db.execute("INSERT INTO test (score) VALUES (?)", nil) }
+
+      it "is inferred correctly" do
+        tuple[:score].should be_nil
+      end
+    end
+
+    context "against a blob field" do
+      let(:table)   { "CREATE TABLE test (salt blob)" }
+
+      before(:each) { db.execute("INSERT INTO test (salt) VALUES (?)", nil) }
+
+      it "is inferred correctly" do
+        tuple[:salt].should be_nil
+      end
+    end
+  end
+
+  describe "String param" do
+    context "against a text field" do
+      let(:table)   { "CREATE TABLE test (name text)" }
+
+      before(:each) { db.execute("INSERT INTO test (name) VALUES (?)", "jim") }
+
+      it "is inferred correctly" do
+        tuple[:name].should == "jim"
+      end
+    end
+
+    context "against an integer field" do
+      let(:table)   { "CREATE TABLE test (age integer)" }
+
+      before(:each) { db.execute("INSERT INTO test (age) VALUES (?)", "29") }
+
+      it "is inferred correctly" do
+        tuple[:age].should == 29
+      end
+    end
+
+    context "against an float field" do
+      let(:table)   { "CREATE TABLE test (score float)" }
+
+      before(:each) { db.execute("INSERT INTO test (score) VALUES (?)", "56.4") }
+
+      it "is inferred correctly" do
+        tuple[:score].should == 56.4
+      end
+    end
+
+    context "against an blob field" do
+      let(:table)   { "CREATE TABLE test (salt blob)" }
+
+      before(:each) { db.execute("INSERT INTO test (salt) VALUES (?)", "\x00\x11\x22") }
+
+      it "is inferred correctly" do
+        tuple[:salt].should == "\x00\x11\x22"
+      end
+    end
+  end
+
+  describe "Fixnum param" do
+    context "against an integer field" do
+      let(:table)   { "CREATE TABLE test (age integer)" }
+
+      before(:each) { db.execute("INSERT INTO test (age) VALUES (?)", 29) }
+
+      it "is inferred correctly" do
+        tuple[:age].should == 29
+      end
+    end
+
+    context "against a text field" do
+      let(:table)   { "CREATE TABLE test (name text)" }
+
+      before(:each) { db.execute("INSERT INTO test (name) VALUES (?)", 27) }
+
+      it "is inferred correctly" do
+        tuple[:name].should == "27"
+      end
+    end
+
+    context "against an float field" do
+      let(:table)   { "CREATE TABLE test (score float)" }
+
+      before(:each) { db.execute("INSERT INTO test (score) VALUES (?)", 56) }
+
+      it "is inferred correctly" do
+        tuple[:score].should == 56.0
+      end
+    end
+
+    context "against an blob field" do
+      let(:table)   { "CREATE TABLE test (salt blob)" }
+
+      before(:each) { db.execute("INSERT INTO test (salt) VALUES (?)", 19) }
+
+      it "is inferred correctly" do
+        tuple[:salt].should == "19"
+      end
+    end
+  end
+
+  describe "Float param" do
+    context "against an float field" do
+      let(:table)   { "CREATE TABLE test (score float)" }
+
+      before(:each) { db.execute("INSERT INTO test (score) VALUES (?)", 56.4) }
+
+      it "is inferred correctly" do
+        tuple[:score].should == 56.4
+      end
+    end
+
+    context "against an integer field" do
+      let(:table)   { "CREATE TABLE test (age integer)" }
+
+      before(:each) { db.execute("INSERT INTO test (age) VALUES (?)", 29.2) }
+
+      it "is inferred correctly" do
+        tuple[:age].should == 29.2 # sqlite type affinity
+      end
+    end
+
+    context "against a text field" do
+      let(:table)   { "CREATE TABLE test (name text)" }
+
+      before(:each) { db.execute("INSERT INTO test (name) VALUES (?)", 27.4) }
+
+      it "is inferred correctly" do
+        tuple[:name].should == "27.4"
+      end
+    end
+
+    context "against an blob field" do
+      let(:table)   { "CREATE TABLE test (salt blob)" }
+
+      before(:each) { db.execute("INSERT INTO test (salt) VALUES (?)", 19.2) }
+
+      it "is inferred correctly" do
+        tuple[:salt].should == "19.2"
+      end
+    end
+  end
+
+  describe "Boolean param" do
+    context "against an boolean (i.e. numeric) field" do
+      context "when it is true" do
+        let(:table)   { "CREATE TABLE test (rad boolean)" }
+
+        before(:each) { db.execute("INSERT INTO test (rad) VALUES (?)", true) }
+
+        it "is inferred as integer 1" do
+          tuple[:rad].should == 1
+        end
+      end
+
+      context "when it is false" do
+        let(:table)   { "CREATE TABLE test (rad boolean)" }
+
+        before(:each) { db.execute("INSERT INTO test (rad) VALUES (?)", false) }
+
+        it "is inferred as integer 0" do
+          tuple[:rad].should == 0
+        end
+      end
+    end
+  end
+
+  describe "BigDecimal param" do
+    context "against an float field" do
+      let(:table)   { "CREATE TABLE test (score float)" }
+
+      before(:each) { db.execute("INSERT INTO test (score) VALUES (?)", BigDecimal("56.4")) }
+
+      it "is inferred correctly" do
+        tuple[:score].should == 56.4
+      end
+    end
+
+    context "against an integer field" do
+      let(:table)   { "CREATE TABLE test (age integer)" }
+
+      before(:each) { db.execute("INSERT INTO test (age) VALUES (?)", BigDecimal("29.2")) }
+
+      it "is inferred correctly" do
+        tuple[:age].should == 29.2 # sqlite type affinity
+      end
+    end
+
+    context "against a text field" do
+      let(:table)   { "CREATE TABLE test (name text)" }
+
+      before(:each) { db.execute("INSERT INTO test (name) VALUES (?)", BigDecimal("27.4")) }
+
+      it "is inferred correctly" do
+        tuple[:name].should == "0.274E2"
+      end
+    end
+
+    context "against an blob field" do
+      let(:table)   { "CREATE TABLE test (salt blob)" }
+
+      before(:each) { db.execute("INSERT INTO test (salt) VALUES (?)", BigDecimal("27.4")) }
+
+      it "is inferred correctly" do
+        tuple[:salt].should == "0.274E2"
+      end
+    end
+  end
+
+  describe "Date param" do
+    context "against an date (numeric) field" do
+      let(:table)   { "CREATE TABLE test (dob date)" }
+
+      before(:each) { db.execute("INSERT INTO test (dob) VALUES (?)", Date.new(1983, 5, 3)) }
+
+      it "is inferred correctly" do
+        tuple[:dob].should == "1983-05-03"
+      end
+    end
+  end
+
+  describe "Time param" do
+    context "against an datetime (numeric) field" do
+      let(:table)   { "CREATE TABLE test (created_at datetime)" }
+
+      before(:each) do
+        db.execute(
+          "INSERT INTO test (created_at) VALUES (?)",
+          Time.new(1983, 5, 3, 7, 15, 43)
+        )
+      end
+
+      it "is inferred correctly" do
+        tuple[:created_at].should == "1983-05-03 07:15:43"
+      end
+
+      it "is parseable by sqlite" do
+        tuple
+        db.execute("SELECT date(created_at, '+1 day') FROM test").first_value.should ==
+          "1983-05-04"
+      end
+    end
+  end
+
+  describe "DateTime param" do
+    context "against an datetime (numeric) field" do
+      let(:table)   { "CREATE TABLE test (created_at datetime)" }
+
+      before(:each) do
+        db.execute(
+          "INSERT INTO test (created_at) VALUES (?)",
+          DateTime.new(1983, 5, 3, 7, 15, 43)
+        )
+      end
+
+      it "is inferred correctly" do
+        tuple[:created_at].should == "1983-05-03 07:15:43"
+      end
+
+      it "is parseable by sqlite" do
+        tuple
+        db.execute("SELECT date(created_at, '+1 day') FROM test").first_value.should ==
+          "1983-05-04"
+      end
+    end
+  end
+
+  describe "multiple params" do
+    let(:table)   { "CREATE TABLE test (name text, age integer)" }
+
+    before(:each) do
+      db.execute("INSERT INTO test (name, age) VALUES (?, ?)", "bob", 27)
+    end
+
+    it "binds them all" do
+      tuple.should == {name: "bob", age: 27}
+    end
+  end
+end