rdo-sqlite 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.so
+*.bundle

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rdo-postgres.gemspec
+gemspec
+
+# allow a local version of RDO to be used during dev
+if ENV["RDO_PATH"]
+  gem 'rdo', path: ENV["RDO_PATH"]
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright © 2012 Chris Corbyn.
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,89 @@
+# RDO SQLite3 Driver
+
+This is the SQLite3 driver for [RDO—Ruby Data Objects]
+(https://github.com/d11wtq/rdo).
+
+Refer to the RDO project [README](https://github.com/d11wtq/rdo) for usage
+information.
+
+## Installation
+
+Via rubygems:
+
+    $ gem install rdo-sqlite
+
+Or add the following line to your application's Gemfile:
+
+    gem "rdo-sqlite"
+
+And install with Bundler:
+
+    $ bundle install
+
+## Usage
+
+The registered URI schemes are sqlite: and sqlite3:
+
+``` ruby
+require "rdo"
+require "rdo-sqlite"
+
+# use an in-memory database :memory:
+db = RDO.open("sqlite::memory:")
+
+# use a temporary file for the database (automatically deleted once closed)
+db = RDO.open("sqlite:")
+
+# use a relative path to a database (will be created if it doesn't exist)
+db = RDO.open("sqlite:some/path/to/your.db")
+
+# use an absolute path to a database
+db = RDO.open("sqlite:/absolute/path/to/your.db")
+```
+
+## Type casting and bind parameters
+
+SQLite, being a very basic database only has limited type support. Without
+going into the whole discussion about SQLite's "type affinity" and how it
+will effectively store anything in any column declared as any type, know that
+the only internal types it actually stores are:
+
+  - NULL, which converts to nil in Ruby
+  - TEXT, which converts to a UTF-8 encoded String in Ruby
+  - INTEGER, which converts to a Fixnum in Ruby
+  - REAL, which converts to a Float in Ruby
+  - BLOB, which converts to a binary String in Ruby
+
+If you have fields storing date strings etc, they are just Text, so are
+returned as Strings, which you need to convert by hand. SQLite has no actual
+DATE type, even if its date functions operate on strings formatted correctly.
+
+### Boolean types
+
+Because defining fields as BOOLEAN and storing integer 0 or 1 in them is
+common, rdo-sqlite will convert boolean bind parameters to 0 or 1. If you
+actually want to store the String 'true' or 'false', you will need to
+convert it to a String first.
+
+### Character encoding
+
+SQLite does not allow the encoding of an existing database to be changed. It
+only supports two encodings: UTF-8 and UTF-16. rdo-sqlite currently just
+assumes UTF-8 encoding.
+
+## Contributing
+
+If you find any bugs, please send a pull request if you think you can
+fix it, or file in an issue in the issue tracker.
+
+When sending pull requests, please use topic branches—don't send a pull
+request from the master branch of your fork, as that may change
+unintentionally.
+
+Contributors will be credited in this README.
+
+## Copyright & Licensing
+
+Written by Chris Corbyn.
+
+Licensed under the MIT license. See the LICENSE file for full details.

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('rdo_sqlite') do |ext|
+  ext.lib_dir = File.join('lib', 'rdo_sqlite')
+end
+
+desc "Run the full RSpec suite"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern     = 'spec/'
+end
+
+Rake::Task['spec'].prerequisites << :compile

data/ext/rdo_sqlite/driver.c

@@ -0,0 +1,99 @@
+/*
+ * RDO SQLite3 Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "driver.h"
+#include "macros.h"
+#include "statements.h"
+
+/** Free memory associated with the driver during GC */
+static void rdo_sqlite_driver_free(RDOSQLiteDriver * driver) {
+  sqlite3_close(driver->db);
+  free(driver);
+}
+
+/** Wrap the RDOSQLiteDriver struct with the new instance */
+static VALUE rdo_sqlite_driver_allocate(VALUE klass) {
+  RDOSQLiteDriver * driver = malloc(sizeof(RDOSQLiteDriver));
+  driver->db      = NULL;
+  driver->is_open = 0;
+
+  return Data_Wrap_Struct(klass, 0, rdo_sqlite_driver_free, driver);
+}
+
+/** Opens a database */
+static VALUE rdo_sqlite_driver_open(VALUE self) {
+  RDOSQLiteDriver * driver;
+  Data_Get_Struct(self, RDOSQLiteDriver, driver);
+
+  if (driver->is_open) {
+    return Qtrue;
+  }
+
+  if (sqlite3_open_v2(
+        RSTRING_PTR(rb_funcall(self, rb_intern("filename"), 0)),
+        &(driver->db),
+        SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK) {
+    RDO_ERROR("SQLite3 database open failed: %s", sqlite3_errmsg(driver->db));
+  } else {
+    driver->is_open = 1;
+  }
+
+  return Qtrue;
+}
+
+/** Checks if the database file is open */
+static VALUE rdo_sqlite_driver_open_p(VALUE self) {
+  RDOSQLiteDriver * driver;
+  Data_Get_Struct(self, RDOSQLiteDriver, driver);
+  return driver->is_open ? Qtrue : Qfalse;
+}
+
+/** Close the database and free memory */
+static VALUE rdo_sqlite_driver_close(VALUE self) {
+  RDOSQLiteDriver * driver;
+  Data_Get_Struct(self, RDOSQLiteDriver, driver);
+
+  sqlite3_close(driver->db);
+  driver->db      = NULL;
+  driver->is_open = 0;
+
+  return Qtrue;
+}
+
+/** Create a new prepared statement for cmd */
+static VALUE rdo_sqlite_driver_prepare(VALUE self, VALUE cmd) {
+  return RDO_STATEMENT(rdo_sqlite_statement_executor_new(self, cmd));
+}
+
+/** Quote a string literal for interpolation into a statement */
+static VALUE rdo_sqlite_driver_quote(VALUE self, VALUE str) {
+  Check_Type(str, T_STRING);
+  char * quoted = sqlite3_mprintf("%q", RSTRING_PTR(str));
+  VALUE new_str = rb_str_new2(quoted);
+  sqlite3_free(quoted);
+  return new_str;
+}
+
+/** Initialize driver class */
+void Init_rdo_sqlite_driver(void) {
+  rb_require("rdo");
+  rb_require("rdo/sqlite/driver");
+
+  VALUE cSQLiteDriver = rb_path2class("RDO::SQLite::Driver");
+
+  rb_define_alloc_func(cSQLiteDriver, rdo_sqlite_driver_allocate);
+
+  rb_define_method(cSQLiteDriver, "open", rdo_sqlite_driver_open, 0);
+  rb_define_method(cSQLiteDriver, "open?", rdo_sqlite_driver_open_p, 0);
+  rb_define_method(cSQLiteDriver, "close", rdo_sqlite_driver_close, 0);
+  rb_define_method(cSQLiteDriver, "prepare", rdo_sqlite_driver_prepare, 1);
+  rb_define_method(cSQLiteDriver, "quote", rdo_sqlite_driver_quote, 1);
+
+  Init_rdo_sqlite_statements();
+}

data/ext/rdo_sqlite/driver.h

@@ -0,0 +1,18 @@
+/*
+ * RDO SQLite3 Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include <sqlite3.h>
+
+/** Struct wrapped by RDO::SQLite::Driver class */
+typedef struct {
+  sqlite3 * db;
+  int       is_open;
+} RDOSQLiteDriver;
+
+/** Called during extension initialization to create the Driver class */
+void Init_rdo_sqlite_driver(void);

data/ext/rdo_sqlite/extconf.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require "mkmf"
+
+if ENV["CC"]
+  RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
+end
+
+def have_build_env
+  [
+    have_library("sqlite3"),
+    have_header("sqlite3.h")
+  ].all?
+end
+
+dir_config("sqlite")
+
+unless have_build_env
+  puts "Unable to find sqlite3 libraries and headers. Not building."
+  exit(1)
+end
+
+create_makefile("rdo_sqlite/rdo_sqlite")

data/ext/rdo_sqlite/macros.h

@@ -0,0 +1,193 @@
+/*
+ * RDO—Ruby Data Objects.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+/** -------------------------------------------------------------------------
+ * These macros are for use by RDO driver developers.
+ *
+ * They simplify the logic needed when converting types provided by the RDBMS
+ * into their equivalent Ruby types.
+ *
+ * All of these macros take a C string and return a Ruby VALUE.
+ *
+ * The actual logic for many of the conversions is handled in RDO::Util, which
+ * is written in Ruby.
+ * --------------------------------------------------------------------------
+ */
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+/**
+ * Convenience to call #to_s on any Ruby object.
+ */
+#define RDO_OBJ_TO_S(obj) (rb_funcall(obj, rb_intern("to_s"), 0))
+
+/**
+ * Raise an RDO::Exception with the given msg format and any number of parameters.
+ *
+ * @param (char *) msg
+ *   a format string passed to rb_raise()
+ *
+ * @param (void *) ...
+ *   args used to interpolate the error message
+ */
+#define RDO_ERROR(...) (rb_raise(rb_path2class("RDO::Exception"), __VA_ARGS__))
+
+/**
+ * Factory to return a new RDO::Result for an Enumerable object of tuples.
+ *
+ * @param VALUE (Enumerable) tuples
+ *   an object that knows how to iterate all tuples
+ *
+ * @param VALUE (Hash)
+ *   an optional hash of query info.
+ *
+ * @return VALUE (RDO::Result)
+ *   a new Result object
+ */
+#define RDO_RESULT(tuples, info) \
+  (rb_funcall(rb_path2class("RDO::Result"), rb_intern("new"), 2, tuples, info))
+
+/**
+ * Wrap the given StatementExecutor in a RDO::Statement.
+ *
+ * @param VALUE
+ *   any object that responds to #command and #execute
+ *
+ * @return VALUE
+ *   an RDO::Statement
+ */
+#define RDO_STATEMENT(executor) \
+  (rb_funcall(rb_path2class("RDO::Statement"), rb_intern("new"), 1, executor))
+
+/**
+ * Convert a C string to a ruby String.
+ *
+ * @param (char *) s
+ *   a C string that is valid in the default encoding
+ *
+ * @param (size_t) len
+ *   the length of the string
+ *
+ * @return VALUE (String)
+ *   a Ruby String
+ */
+#define RDO_STRING(s, len, enc) \
+  (rb_enc_associate_index(rb_str_new(s, len), enc > 0 ? enc : 0))
+
+/**
+ * Convert a C string to a ruby String, assuming possible NULL bytes.
+ *
+ * @param (char *) s
+ *   a C string, possibly containing nulls
+ *
+ * @param (size_t) len
+ *   the length of the string
+ *
+ * @return VALUE (String)
+ *   a Ruby String
+ */
+#define RDO_BINARY_STRING(s, len) (rb_str_new(s, len))
+
+/**
+ * Convert a C string to a Fixnum.
+ */
+#define RDO_FIXNUM(s) (rb_cstr2inum(s, 10))
+
+/**
+ * Convert a C string to a Float.
+ *
+ * This supports Infinity and NaN.
+ *
+ * @param (char *) s
+ *   a C string representing a float (e.g. "1.234")
+ *
+ * @return VALUE (Float)
+ *   a ruby Float
+ */
+#define RDO_FLOAT(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("float"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a precision decimal into a BigDecimal.
+ *
+ * @param (char *) s
+ *   a C string representing a decimal ("1.245")
+ *
+ * @return VALUE (BigDecimal)
+ *   a BigDecimal representation of this string
+ *
+ * @example
+ *   RDO_DECIMAL("1.234")
+ *   => #<BigDecimal:7feb42b2b6e8,'0.1234E1',18(18)>
+ */
+#define RDO_DECIMAL(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("decimal"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a date into a Date.
+ *
+ * @param (char *) s
+ *   the C string with a parseable date
+ *
+ * @return VALUE (Date)
+ *   a Date, exactly as was specified in the input
+ *
+ * @example
+ *   RDO_DATE("431-09-22 BC")
+ *   #<Date: -0430-09-22 ((1564265j,0s,0n),+0s,2299161j)>
+ */
+#define RDO_DATE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a date & time with no time zone into a DateTime.
+ *
+ * @param (char *) s
+ *   the C string with the date & time provided
+ *
+ * @return VALUE (DateTime)
+ *   a DateTime, assuming the system time zone
+ *
+ * @example
+ *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12")
+ *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
+ */
+#define RDO_DATE_TIME_WITHOUT_ZONE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date_time_without_zone"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a C string representing a date & time that includes a time zone into a DateTime.
+ *
+ * @param (char *) s
+ *   the C string with the date & time provided, including the time zone
+ *
+ * @return VALUE (DateTime)
+ *   a DateTime, exactly as was specified in the input
+ *
+ * @example
+ *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12+10:00")
+ *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
+ */
+#define RDO_DATE_TIME_WITH_ZONE(s) \
+  (rb_funcall(rb_path2class("RDO::Util"), \
+              rb_intern("date_time_with_zone"), 1, rb_str_new2(s)))
+
+/**
+ * Convert a boolean string to TrueClass/FalseClass.
+ *
+ * @param (char *) s
+ *   a C string that is either 't', 'true', 'f' or 'false'
+ *
+ * @return VALUE (TrueClass, FalseClass)
+ *   the boolean representation
+ */
+#define RDO_BOOL(s) ((s[0] == 't') ? Qtrue : Qfalse)

data/ext/rdo_sqlite/rdo_sqlite.c

@@ -0,0 +1,15 @@
+/*
+ * RDO SQLite3 Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include "driver.h"
+
+/** Extension initializer */
+void Init_rdo_sqlite(void) {
+  rb_require("rdo");
+  Init_rdo_sqlite_driver();
+}