do_sqlite3 0.9.6-x86-mswin32-60

data/History.txt

@@ -0,0 +1 @@
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Yehuda Katz
+
+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/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+TODO
+ext/do_sqlite3_ext.c
+ext/do_sqlite3_ext.so
+ext/extconf.rb
+lib/do_sqlite3.rb
+lib/do_sqlite3/transaction.rb
+lib/do_sqlite3/version.rb
+lib/sqlite3.dll
+spec/integration/do_sqlite3_spec.rb
+spec/integration/logging_spec.rb
+spec/integration/quoting_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/unit/transaction_spec.rb

data/README.txt

@@ -0,0 +1,3 @@
+= do_sqlite3
+
+A DataObjects driver for SQLite3

data/Rakefile

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'pathname'
+
+ROOT = Pathname(__FILE__).dirname.expand_path
+
+require "lib/do_sqlite3/version"
+
+JRUBY   = (RUBY_PLATFORM =~ /java/) rescue nil
+WINDOWS = (RUBY_PLATFORM =~ /mswin|mingw|cygwin/) rescue nil
+          # don't use SUDO with JRuby, for the moment, although this behaviour
+          # is not entirely correct.
+SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+AUTHOR = "Bernerd Schaefer"
+EMAIL  = "bj.schaefer@gmail.com"
+GEM_NAME = "do_sqlite3"
+GEM_VERSION = DataObjects::Sqlite3::VERSION
+GEM_DEPENDENCIES = [["data_objects", GEM_VERSION]]
+
+clean = %w(o bundle log a gem dSYM obj pdb lib def exp DS_Store)
+
+unless ENV["WINDOWS"]
+  clean << "so" 
+  GEM_EXTRAS = { :extensions => %w[ ext/extconf.rb ], :has_rdoc => false }
+else
+  GEM_EXTRAS = {}
+end
+
+GEM_CLEAN = ["**/*.{#{clean.join(",")}}", 'ext/Makefile']
+
+PROJECT_NAME = "dorb"
+PROJECT_URL  = "http://rubyforge.org/projects/dorb"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY = "A DataObject.rb driver for Sqlite3"
+
+DRIVER = true
+
+require ROOT.parent + 'tasks/hoe'
+
+# Installation
+
+task :install => [ :package ] do
+  sh %{#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}, :verbose => false
+end
+
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
+end
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--format' << 'specdoc' << '--colour'
+  t.spec_opts << '--loadby' << 'random'
+  t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb')
+
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end
+
+namespace :ci do
+
+  task :prepare do
+    rm_rf ROOT + "ci"
+    mkdir_p ROOT + "ci"
+    mkdir_p ROOT + "ci/doc"
+    mkdir_p ROOT + "ci/cyclomatic"
+    mkdir_p ROOT + "ci/token"
+  end
+
+  task :publish do
+    out = ENV['CC_BUILD_ARTIFACTS'] || "out"
+    mkdir_p out unless File.directory? out
+
+    mv "ci/rspec_report.html", "#{out}/rspec_report.html"
+    mv "ci/coverage", "#{out}/coverage"
+  end
+
+  task :spec => :prepare do
+    Rake::Task[:spec].invoke
+    mv ROOT + "coverage", ROOT + "ci/coverage"
+  end
+
+end
+
+task :ci => ["ci:spec"]

data/TODO

@@ -0,0 +1,4 @@
+TODO
+====
+
+  * Add JDBC-based version of this driver.

data/ext/do_sqlite3_ext.c

@@ -0,0 +1,549 @@
+#include <ruby.h>
+#include <version.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <locale.h>
+#include <sqlite3.h>
+
+#define ID_CONST_GET rb_intern("const_get")
+#define ID_PATH rb_intern("path")
+#define ID_NEW rb_intern("new")
+#define ID_ESCAPE rb_intern("escape_sql")
+
+#define RUBY_STRING(char_ptr) rb_str_new2(char_ptr)
+#define TAINTED_STRING(name) rb_tainted_str_new2(name)
+#define CONST_GET(scope, constant) (rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant)))
+#define SQLITE3_CLASS(klass, parent) (rb_define_class_under(mSqlite3, klass, parent))
+
+#define TRUE_CLASS CONST_GET(rb_mKernel, "TrueClass")
+
+#ifdef _WIN32
+#define do_int64 signed __int64
+#else
+#define do_int64 signed long long int
+#endif
+
+// To store rb_intern values
+static ID ID_NEW_DATE;
+static ID ID_LOGGER;
+static ID ID_DEBUG;
+static ID ID_LEVEL;
+
+static VALUE mDO;
+static VALUE cDO_Quoting;
+static VALUE cDO_Connection;
+static VALUE cDO_Command;
+static VALUE cDO_Result;
+static VALUE cDO_Reader;
+
+static VALUE rb_cDate;
+static VALUE rb_cDateTime;
+static VALUE rb_cRational;
+static VALUE rb_cBigDecimal;
+
+static VALUE mSqlite3;
+static VALUE cConnection;
+static VALUE cCommand;
+static VALUE cResult;
+static VALUE cReader;
+
+static VALUE eSqlite3Error;
+
+
+/****** Typecasting ******/
+static VALUE native_typecast(sqlite3_value *value, int type) {
+	VALUE ruby_value = Qnil;
+
+	switch(type) {
+		case SQLITE_NULL: {
+			ruby_value = Qnil;
+			break;
+		}
+		case SQLITE_INTEGER: {
+			ruby_value = LL2NUM(sqlite3_value_int64(value));
+			break;
+		}
+		case SQLITE3_TEXT: {
+			ruby_value = rb_str_new2((char*)sqlite3_value_text(value));
+			break;
+		}
+		case SQLITE_FLOAT: {
+			ruby_value = rb_float_new(sqlite3_value_double(value));
+			break;
+		}
+	}
+	return ruby_value;
+}
+
+// Find the greatest common denominator and reduce the provided numerator and denominator.
+// This replaces calles to Rational.reduce! which does the same thing, but really slowly.
+static void reduce( do_int64 *numerator, do_int64 *denominator ) {
+	do_int64 a, b, c = 0;
+	a = *numerator;
+	b = *denominator;
+	while ( a != 0 ) {
+		c = a; a = b % a; b = c;
+	}
+	*numerator = *numerator / b;
+	*denominator = *denominator / b;
+}
+
+// Generate the date integer which Date.civil_to_jd returns
+static int jd_from_date(int year, int month, int day) {
+	int a, b;
+	if ( month <= 2 ) {
+		year -= 1;
+		month += 12;
+	}
+	a = year / 100;
+	b = 2 - a + (a / 4);
+	return floor(365.25 * (year + 4716)) + floor(30.6001 * (month + 1)) + day + b - 1524;
+}
+
+static void data_objects_debug(VALUE string) {
+	VALUE logger = rb_funcall(mSqlite3, ID_LOGGER, 0);
+	int log_level = NUM2INT(rb_funcall(logger, ID_LEVEL, 0));
+
+	if (0 == log_level) {
+		rb_funcall(logger, ID_DEBUG, 1, string);
+	}
+}
+
+static VALUE parse_date(char *date) {
+	int year, month, day;
+	int jd, ajd;
+	VALUE rational;
+
+	sscanf(date, "%4d-%2d-%2d", &year, &month, &day);
+
+	jd = jd_from_date(year, month, day);
+
+	// Math from Date.jd_to_ajd
+	ajd = jd * 2 - 1;
+	rational = rb_funcall(rb_cRational, rb_intern("new!"), 2, INT2NUM(ajd), INT2NUM(2));
+	return rb_funcall(rb_cDate, ID_NEW_DATE, 3, rational, INT2NUM(0), INT2NUM(2299161));
+}
+
+// Creates a Rational for use as a Timezone offset to be passed to DateTime.new!
+static VALUE seconds_to_offset(do_int64 num) {
+	do_int64 den = 86400;
+	reduce(&num, &den);
+	return rb_funcall(rb_cRational, rb_intern("new!"), 2, rb_ll2inum(num), rb_ll2inum(den));
+}
+
+static VALUE timezone_to_offset(int hour_offset, int minute_offset) {
+	do_int64 seconds = 0;
+
+	seconds += hour_offset * 3600;
+	seconds += minute_offset * 60;
+
+	return seconds_to_offset(seconds);
+}
+
+static VALUE parse_date_time(char *date) {
+	VALUE ajd, offset;
+
+	int year, month, day, hour, min, sec, usec, hour_offset, minute_offset;
+	int jd;
+	do_int64 num, den;
+
+	long int gmt_offset;
+	int is_dst;
+
+	time_t rawtime;
+	struct tm * timeinfo;
+
+	int tokens_read, max_tokens;
+
+  if ( strcmp(date, "") == 0 ) {
+    return Qnil;
+  }
+
+	if (0 != strchr(date, '.')) {
+		// This is a datetime with sub-second precision
+		tokens_read = sscanf(date, "%4d-%2d-%2d%*c%2d:%2d:%2d.%d%3d:%2d", &year, &month, &day, &hour, &min, &sec, &usec, &hour_offset, &minute_offset);
+		max_tokens = 9;
+	} else {
+		// This is a datetime second precision
+		tokens_read = sscanf(date, "%4d-%2d-%2d%*c%2d:%2d:%2d%3d:%2d", &year, &month, &day, &hour, &min, &sec, &hour_offset, &minute_offset);
+		max_tokens = 8;
+	}
+
+	if (max_tokens == tokens_read) {
+		// We read the Date, Time, and Timezone info
+		minute_offset *= hour_offset < 0 ? -1 : 1;
+	} else if ((max_tokens - 1) == tokens_read) {
+		// We read the Date and Time, but no Minute Offset
+		minute_offset = 0;
+	} else if (tokens_read == 3) {
+		return parse_date(date);
+	} else if (tokens_read >= (max_tokens - 3)) {
+		// We read the Date and Time, default to the current locale's offset
+
+		// Get localtime
+		time(&rawtime);
+		timeinfo = localtime(&rawtime);
+
+		is_dst = timeinfo->tm_isdst * 3600;
+
+		// Reset to GM Time
+		timeinfo = gmtime(&rawtime);
+
+		gmt_offset = mktime(timeinfo) - rawtime;
+
+		if ( is_dst > 0 )
+			gmt_offset -= is_dst;
+
+		hour_offset = -(gmt_offset / 3600);
+		minute_offset = -(gmt_offset % 3600 / 60);
+
+	} else {
+		// Something went terribly wrong
+		rb_raise(eSqlite3Error, "Couldn't parse date: %s", date);
+	}
+
+	jd = jd_from_date(year, month, day);
+
+	// Generate ajd with fractional days for the time
+	// Extracted from Date#jd_to_ajd, Date#day_fraction_to_time, and Rational#+ and #-
+	num = (hour * 1440) + (min * 24);
+
+	// Modify the numerator so when we apply the timezone everything works out
+	num -= (hour_offset * 1440) + (minute_offset * 24);
+
+	den = (24 * 1440);
+	reduce(&num, &den);
+
+	num = (num * 86400) + (sec * den);
+	den = den * 86400;
+	reduce(&num, &den);
+
+	num = (jd * den) + num;
+
+	num = num * 2;
+	num = num - den;
+	den = den * 2;
+
+	reduce(&num, &den);
+
+	ajd = rb_funcall(rb_cRational, rb_intern("new!"), 2, rb_ull2inum(num), rb_ull2inum(den));
+	offset = timezone_to_offset(hour_offset, minute_offset);
+
+	return rb_funcall(rb_cDateTime, ID_NEW_DATE, 3, ajd, offset, INT2NUM(2299161));
+}
+
+static VALUE parse_time(char *date) {
+
+	int year, month, day, hour, min, sec, usec;
+	char subsec[7];
+
+	if (0 != strchr(date, '.')) {
+		// right padding usec with 0. e.g. '012' will become 12000 microsecond, since Time#local use microsecond
+	  sscanf(date, "%4d-%2d-%2d %2d:%2d:%2d.%s", &year, &month, &day, &hour, &min, &sec, subsec);
+		sscanf(subsec, "%d", &usec);
+	} else {
+		sscanf(date, "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec);
+		usec = 0;
+	}
+
+	return rb_funcall(rb_cTime, rb_intern("local"), 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
+}
+
+static VALUE ruby_typecast(sqlite3_value *value, char *type, int original_type) {
+	VALUE ruby_value = Qnil;
+
+	if ( original_type == SQLITE_NULL ) {
+		return ruby_value;
+	} else if ( strcmp(type, "Class") == 0) {
+    ruby_value = rb_funcall(mDO, rb_intern("find_const"), 1, TAINTED_STRING((char*)sqlite3_value_text(value)));
+  } else if ( strcmp(type, "Object") == 0 ) {
+		ruby_value = rb_marshal_load(rb_str_new2((char*)sqlite3_value_text(value)));
+	} else if ( strcmp(type, "TrueClass") == 0 ) {
+		ruby_value = strcmp((char*)sqlite3_value_text(value), "t") == 0 ? Qtrue : Qfalse;
+	} else if ( strcmp(type, "Integer") == 0 || strcmp(type, "Fixnum") == 0 || strcmp(type, "Bignum") == 0 ) {
+		ruby_value = LL2NUM(sqlite3_value_int64(value));
+	} else if ( strcmp(type, "BigDecimal") == 0 ) {
+		ruby_value = rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING((char*)sqlite3_value_text(value)));
+	} else if ( strcmp(type, "String") == 0 ) {
+		ruby_value = TAINTED_STRING((char*)sqlite3_value_text(value));
+	} else if ( strcmp(type, "Float") == 0 ) {
+		ruby_value = rb_float_new(sqlite3_value_double(value));
+	} else if ( strcmp(type, "Date") == 0 ) {
+		ruby_value = parse_date((char*)sqlite3_value_text(value));
+	} else if ( strcmp(type, "DateTime") == 0 ) {
+		ruby_value = parse_date_time((char*)sqlite3_value_text(value));
+	} else if ( strcmp(type, "Time") == 0 ) {
+		ruby_value = parse_time((char*)sqlite3_value_text(value));
+	}
+
+	return ruby_value;
+}
+
+
+/****** Public API ******/
+
+static VALUE cConnection_initialize(VALUE self, VALUE uri) {
+	int ret;
+	VALUE path;
+	sqlite3 *db;
+
+	path = rb_funcall(uri, ID_PATH, 0);
+	ret = sqlite3_open(StringValuePtr(path), &db);
+
+	if ( ret != SQLITE_OK ) {
+		rb_raise(eSqlite3Error, sqlite3_errmsg(db));
+	}
+
+	rb_iv_set(self, "@uri", uri);
+	rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
+
+	return Qtrue;
+}
+
+static VALUE cConnection_dispose(VALUE self) {
+	sqlite3 *db;
+	Data_Get_Struct(rb_iv_get(self, "@connection"), sqlite3, db);
+	sqlite3_close(db);
+	return Qtrue;
+}
+
+static VALUE cCommand_set_types(VALUE self, VALUE array) {
+	rb_iv_set(self, "@field_types", array);
+	return array;
+}
+
+static VALUE cCommand_quote_boolean(VALUE self, VALUE value) {
+	return TAINTED_STRING(value == Qtrue ? "'t'" : "'f'");
+}
+
+static VALUE cCommand_quote_string(VALUE self, VALUE string) {
+	const char *source = StringValuePtr(string);
+	char *escaped_with_quotes;
+
+	// Wrap the escaped string in single-quotes, this is DO's convention
+	escaped_with_quotes = sqlite3_mprintf("%Q", source);
+
+	return TAINTED_STRING(escaped_with_quotes);
+}
+
+static VALUE build_query_from_args(VALUE klass, int count, VALUE *args) {
+	VALUE query = rb_iv_get(klass, "@text");
+	if ( count > 0 ) {
+		int i;
+		VALUE array = rb_ary_new();
+		for ( i = 0; i < count; i++) {
+			rb_ary_push(array, (VALUE)args[i]);
+		}
+		query = rb_funcall(klass, ID_ESCAPE, 1, array);
+	}
+	return query;
+}
+
+static VALUE cCommand_execute_non_query(int argc, VALUE *argv, VALUE self) {
+	sqlite3 *db;
+	char *error_message;
+	int status;
+	int affected_rows;
+	int insert_id;
+	VALUE conn_obj;
+	VALUE query;
+
+	query = build_query_from_args(self, argc, argv);
+	data_objects_debug(query);
+
+	conn_obj = rb_iv_get(self, "@connection");
+	Data_Get_Struct(rb_iv_get(conn_obj, "@connection"), sqlite3, db);
+
+	status = sqlite3_exec(db, StringValuePtr(query), 0, 0, &error_message);
+
+	if ( status != SQLITE_OK ) {
+		rb_raise(eSqlite3Error, sqlite3_errmsg(db));
+	}
+
+	affected_rows = sqlite3_changes(db);
+	insert_id = sqlite3_last_insert_rowid(db);
+
+	return rb_funcall(cResult, ID_NEW, 3, self, INT2NUM(affected_rows), INT2NUM(insert_id));
+}
+
+static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
+	sqlite3 *db;
+	sqlite3_stmt *sqlite3_reader;
+	int status;
+	int field_count;
+	int i;
+	VALUE reader;
+	VALUE conn_obj;
+	VALUE query;
+	VALUE field_names, field_types;
+
+	conn_obj = rb_iv_get(self, "@connection");
+	Data_Get_Struct(rb_iv_get(conn_obj, "@connection"), sqlite3, db);
+
+	query = build_query_from_args(self, argc, argv);
+	
+	data_objects_debug(query);
+
+	status = sqlite3_prepare_v2(db, StringValuePtr(query), -1, &sqlite3_reader, 0);
+
+	if ( status != SQLITE_OK ) {
+		rb_raise(eSqlite3Error, sqlite3_errmsg(db));
+	}
+
+	field_count = sqlite3_column_count(sqlite3_reader);
+
+	reader = rb_funcall(cReader, ID_NEW, 0);
+	rb_iv_set(reader, "@reader", Data_Wrap_Struct(rb_cObject, 0, 0, sqlite3_reader));
+	rb_iv_set(reader, "@field_count", INT2NUM(field_count));
+
+	field_names = rb_ary_new();
+	field_types = rb_iv_get(self, "@field_types");
+
+	// if ( field_types == Qnil ) {
+	// 	field_types = rb_ary_new();
+	// }
+
+	if ( field_types == Qnil || 0 == RARRAY(field_types)->len ) {
+		field_types = rb_ary_new();
+	} else if (RARRAY(field_types)->len != field_count) {
+		// Whoops...  wrong number of types passed to set_types.  Close the reader and raise
+		// and error
+		rb_funcall(reader, rb_intern("close"), 0);
+		rb_raise(eSqlite3Error, "Field-count mismatch. Expected %d fields, but the query yielded %d", RARRAY(field_types)->len, field_count);
+	}
+
+
+
+	for ( i = 0; i < field_count; i++ ) {
+		rb_ary_push(field_names, rb_str_new2((char *)sqlite3_column_name(sqlite3_reader, i)));
+	}
+
+	rb_iv_set(reader, "@fields", field_names);
+	rb_iv_set(reader, "@field_types", field_types);
+
+	return reader;
+}
+
+static VALUE cReader_close(VALUE self) {
+	VALUE reader_obj = rb_iv_get(self, "@reader");
+
+	if ( reader_obj != Qnil ) {
+		sqlite3_stmt *reader;
+		Data_Get_Struct(reader_obj, sqlite3_stmt, reader);
+		sqlite3_finalize(reader);
+		rb_iv_set(self, "@reader", Qnil);
+		return Qtrue;
+	}
+	else {
+		return Qfalse;
+	}
+}
+
+static VALUE cReader_next(VALUE self) {
+	sqlite3_stmt *reader;
+	int field_count;
+	int result;
+	int i;
+	int ft_length;
+	VALUE arr = rb_ary_new();
+	VALUE field_types;
+	VALUE value;
+
+	Data_Get_Struct(rb_iv_get(self, "@reader"), sqlite3_stmt, reader);
+	field_count = NUM2INT(rb_iv_get(self, "@field_count"));
+
+	field_types = rb_iv_get(self, "@field_types");
+	ft_length = RARRAY(field_types)->len;
+
+	result = sqlite3_step(reader);
+
+	rb_iv_set(self, "@state", INT2NUM(result));
+
+	if ( result != SQLITE_ROW ) {
+		return Qnil;
+	}
+
+	for ( i = 0; i < field_count; i++ ) {
+		if ( ft_length == 0 ) {
+			value = native_typecast(sqlite3_column_value(reader, i), sqlite3_column_type(reader, i));
+		}
+		else {
+			value = ruby_typecast(sqlite3_column_value(reader, i), rb_class2name(RARRAY(field_types)->ptr[i]), sqlite3_column_type(reader, i));
+		}
+		rb_ary_push(arr, value);
+	}
+
+	rb_iv_set(self, "@values", arr);
+
+	return Qtrue;
+}
+
+static VALUE cReader_values(VALUE self) {
+	VALUE state = rb_iv_get(self, "@state");
+	if ( state == Qnil || NUM2INT(state) != SQLITE_ROW ) {
+		rb_raise(eSqlite3Error, "Reader is not initialized");
+	}
+	else {
+		return rb_iv_get(self, "@values");
+	}
+}
+
+static VALUE cReader_fields(VALUE self) {
+	return rb_iv_get(self, "@fields");
+}
+
+void Init_do_sqlite3_ext() {
+
+	rb_require("rubygems");
+	rb_require("bigdecimal");
+	rb_require("date");
+
+	// Get references classes needed for Date/Time parsing
+	rb_cDate = CONST_GET(rb_mKernel, "Date");
+	rb_cDateTime = CONST_GET(rb_mKernel, "DateTime");
+	rb_cTime = CONST_GET(rb_mKernel, "Time");
+	rb_cRational = CONST_GET(rb_mKernel, "Rational");
+	rb_cBigDecimal = CONST_GET(rb_mKernel, "BigDecimal");
+
+	rb_funcall(rb_mKernel, rb_intern("require"), 1, rb_str_new2("data_objects"));
+
+	ID_NEW_DATE = RUBY_VERSION_CODE < 186 ? rb_intern("new0") : rb_intern("new!");
+	ID_LOGGER = rb_intern("logger");
+	ID_DEBUG = rb_intern("debug");
+	ID_LEVEL = rb_intern("level");
+
+	// Get references to the DataObjects module and its classes
+	mDO = CONST_GET(rb_mKernel, "DataObjects");
+	cDO_Quoting = CONST_GET(mDO, "Quoting");
+	cDO_Connection = CONST_GET(mDO, "Connection");
+	cDO_Command = CONST_GET(mDO, "Command");
+	cDO_Result = CONST_GET(mDO, "Result");
+	cDO_Reader = CONST_GET(mDO, "Reader");
+
+	// Initialize the DataObjects::Sqlite3 module, and define its classes
+	mSqlite3 = rb_define_module_under(mDO, "Sqlite3");
+
+	eSqlite3Error = rb_define_class("Sqlite3Error", rb_eStandardError);
+
+	cConnection = SQLITE3_CLASS("Connection", cDO_Connection);
+	rb_define_method(cConnection, "initialize", cConnection_initialize, 1);
+	rb_define_method(cConnection, "dispose", cConnection_dispose, 0);
+
+	cCommand = SQLITE3_CLASS("Command", cDO_Command);
+	rb_include_module(cCommand, cDO_Quoting);
+	rb_define_method(cCommand, "set_types", cCommand_set_types, 1);
+	rb_define_method(cCommand, "execute_non_query", cCommand_execute_non_query, -1);
+	rb_define_method(cCommand, "execute_reader", cCommand_execute_reader, -1);
+	rb_define_method(cCommand, "quote_boolean", cCommand_quote_boolean, 1);
+	rb_define_method(cCommand, "quote_string", cCommand_quote_string, 1);
+
+	cResult = SQLITE3_CLASS("Result", cDO_Result);
+
+	cReader = SQLITE3_CLASS("Reader", cDO_Reader);
+	rb_define_method(cReader, "close", cReader_close, 0);
+	rb_define_method(cReader, "next!", cReader_next, 0);
+	rb_define_method(cReader, "values", cReader_values, 0);
+	rb_define_method(cReader, "fields", cReader_fields, 0);
+
+}

data/ext/extconf.rb

@@ -0,0 +1,35 @@
+# ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+#
+# require 'mkmf'
+#
+# SWIG_WRAP = "sqlite3_api_wrap.c"
+#
+# dir_config( "sqlite3", "/usr/local" )
+#
+# if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" )
+#   create_makefile( "sqlite3_c" )
+# end
+
+if RUBY_PLATFORM =~ /darwin/
+  ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
+
+  # On PowerPC the defaults are fine
+  ENV["RC_ARCHS"] = '' if `uname -m` =~ /^Power Macintosh/
+end
+
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'do_sqlite3_ext'
+
+dir_config("sqlite3")
+
+# NOTE: use GCC flags unless Visual C compiler is used
+$CFLAGS << ' -Wall ' unless RUBY_PLATFORM =~ /mswin/
+
+# Do the work
+# create_makefile(extension_name)
+if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" )
+  create_makefile(extension_name)
+end

data/lib/do_sqlite3.rb

@@ -0,0 +1,13 @@
+
+# HACK: If running on Windows, then add the current directory to the PATH
+# for the current process so it can find the bundled dlls before the require
+# of the actual extension file.
+if RUBY_PLATFORM.match(/mingw|mswin/i)
+  libdir = File.expand_path(File.dirname(__FILE__)).gsub(File::SEPARATOR, File::ALT_SEPARATOR)
+  ENV['PATH'] = "#{libdir};" + ENV['PATH']
+end
+
+require 'rubygems'
+require 'data_objects'
+require 'do_sqlite3_ext'
+require 'do_sqlite3/transaction'

data/lib/do_sqlite3/transaction.rb

@@ -0,0 +1,36 @@
+
+module DataObjects
+
+  module Sqlite3
+
+    class Transaction < DataObjects::Transaction
+
+      def begin
+        cmd = "BEGIN"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def commit
+        cmd = "COMMIT"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def rollback
+        cmd = "ROLLBACK"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def rollback_prepared
+        cmd = "ROLLBACK"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def prepare
+        # Eek, I don't know how to do this. Lets hope a commit arrives soon...
+      end
+
+    end
+
+  end
+
+end

data/lib/do_sqlite3/version.rb

@@ -0,0 +1,5 @@
+module DataObjects
+  module Sqlite3
+    VERSION = "0.9.6"
+  end
+end

data/spec/integration/do_sqlite3_spec.rb

@@ -0,0 +1,256 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe "DataObjects::Sqlite3" do
+  include Sqlite3SpecHelpers
+
+  it "should raise error on bad connection string" do
+    # lambda { DataObjects::Connection.new("sqlite3:///ac0d9iopalmsdcasd/asdc9pomasd/test.db") }.should raise_error("unable to open database file")
+  end
+end
+
+NOW = DateTime.now
+
+describe "DataObjects::Sqlite3::Result" do
+  include Sqlite3SpecHelpers
+
+  before(:all) do
+    @connection = DataObjects::Connection.new("sqlite3://#{File.expand_path(File.dirname(__FILE__))}/test.db")
+  end
+
+  after :all do
+    @connection.close
+  end
+
+  it "should raise an error for a bad query" do
+    command = @connection.create_command("INSER INTO table_which_doesnt_exist (id) VALUES (1)")
+    lambda { command.execute_non_query }.should raise_error('near "INSER": syntax error')
+
+    command = @connection.create_command("INSERT INTO table_which_doesnt_exist (id) VALUES (1)")
+    lambda { command.execute_non_query }.should raise_error("no such table: table_which_doesnt_exist")
+
+    command = @connection.create_command("SELECT * FROM table_which_doesnt_exist")
+    lambda { command.execute_reader }.should raise_error("no such table: table_which_doesnt_exist")
+  end
+
+  it "should return the affected rows and insert_id" do
+    command = @connection.create_command("DROP TABLE users")
+    command.execute_non_query rescue nil
+    command = @connection.create_command("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, type TEXT, age INTEGER, created_at DATETIME, balance DECIMAL default '0.00')")
+    result = command.execute_non_query
+    command = @connection.create_command("INSERT INTO users (name) VALUES ('test')")
+    result = command.execute_non_query
+    result.insert_id.should == 1
+    result.to_i.should == 1
+  end
+
+  it "should do a reader query" do
+    command = @connection.create_command("SELECT * FROM users")
+    reader = command.execute_reader
+
+    lambda { reader.values }.should raise_error
+
+    while ( reader.next! )
+      lambda { reader.values }.should_not raise_error
+      reader.values.should be_a_kind_of(Array)
+    end
+
+    lambda { reader.values }.should raise_error
+
+    reader.close
+  end
+
+  it "should do a paramaterized reader query" do
+    command = @connection.create_command("SELECT * FROM users WHERE id = ?")
+    reader = command.execute_reader(1)
+    reader.next!
+
+    reader.values[0].should == 1
+
+    reader.next!
+
+    lambda { reader.values }.should raise_error
+
+    reader.close
+  end
+
+  it "should do a custom typecast reader" do
+    command = @connection.create_command("SELECT name, id FROM users")
+    command.set_types [String, String]
+    reader = command.execute_reader
+
+    while ( reader.next! )
+      reader.fields.should == ["name", "id"]
+      reader.values.each { |v| v.should be_a_kind_of(String) }
+    end
+
+    reader.close
+
+  end
+
+  it "should handle a null value" do
+    id = insert("INSERT INTO users (name) VALUES (NULL)")
+    select("SELECT name from users WHERE name is null") do |reader|
+      reader.values[0].should == nil
+    end
+  end
+
+  it "should not convert empty strings to null" do
+    id = insert("INSERT INTO users (name) VALUES ('')")
+    select("SELECT name FROM users WHERE id = ?", [String], id) do |reader|
+      reader.values.first.should == ''
+    end
+  end
+
+  it "should raise an error when you pass too many or too few types for the expected result set" do
+    lambda { select("SELECT name, id FROM users", [String, Integer, String]) }.should raise_error(Sqlite3Error)
+  end
+
+  it "should do a custom typecast reader with Class" do
+    class Person; end
+
+    id = insert("INSERT INTO users (name, age, type) VALUES (?, ?, ?)", 'Sam', 30, Person)
+
+    select("SELECT name, age, type FROM users WHERE id = ?", [String, Integer, Class], id) do |reader|
+      reader.fields.should == ["name", "age", "type"]
+      reader.values.should == ["Sam", 30, Person]
+    end
+
+    exec("DELETE FROM users WHERE id = ?", id)
+  end
+
+  [
+    NOW.strftime('%Y-%m-%dT%H:%M:%S'),
+    NOW.strftime('%Y-%m-%d %H:%M:%S')
+  ].each do |raw_value|
+    it "should return #{NOW.to_s} using the LOCAL timezone when typecasting '#{raw_value}'" do
+
+      # Insert a timezone-less DateTime into the DB
+      id = insert("INSERT INTO users (name, age, type, created_at) VALUES (?, ?, ?, ?)", 'Sam', 30, Person, raw_value)
+
+      select("SELECT created_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+        reader.values.last.to_s.should == NOW.to_s
+      end
+
+      exec("DELETE FROM users WHERE id = ?", id)
+    end
+  end
+
+  it "should not blow up when an empty string for a timestamp is used" do
+    id = insert("INSERT INTO users (name, age, type, created_at) VALUES (?, ?, ?, ?)", 'Sam', 30, Person, "")
+
+    select("SELECT created_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+      reader.values.last.should == nil
+    end
+  end
+
+  it "should return DateTimes using the same timezone that was used to insert it" do
+    pending "improved support for timezone checking"
+
+    dates = [
+      NOW,
+      NOW.new_offset( (-11 * 3600).to_r / 86400), # GMT -11:00
+      NOW.new_offset( (-9 * 3600 + 10 * 60).to_r / 86400), # GMT -9:10
+      NOW.new_offset( (-8 * 3600).to_r / 86400), # GMT -08:00
+      NOW.new_offset( (+3 * 3600).to_r / 86400), # GMT +03:00
+      NOW.new_offset( (+5 * 3600 + 30 * 60).to_r / 86400)  # GMT +05:30 (New Delhi)
+    ]
+
+    dates.each do |date|
+      id = insert("INSERT INTO users (name, age, type, created_at) VALUES (?, ?, ?, ?)", 'Sam', 30, Person, date)
+
+      select("SELECT created_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+        reader.values.last.year.should == date.year
+        reader.values.last.month.should == date.month
+        reader.values.last.day.should == date.day
+        reader.values.last.hour.should == date.hour
+        reader.values.last.min.should == date.min
+        reader.values.last.sec.should == date.sec
+        reader.values.last.zone.should == date.zone
+      end
+
+      exec("DELETE FROM users WHERE id = ?", id)
+    end
+  end
+
+  it "should return a BigDecimal" do
+    balance = BigDecimal.new('10000000000.00')
+
+    id = insert("INSERT INTO users (name, age, type, created_at, balance) VALUES (?, ?, ?, ?, ?)", 'Scott', 27, Person, DateTime.now, balance)
+
+    select("SELECT balance FROM users WHERE id = ?", [BigDecimal], id) do |reader|
+      reader.values.last.should == balance
+    end
+  end
+
+  describe "quoting" do
+
+    before do
+      @connection.create_command("DROP TABLE IF EXISTS sail_boats").execute_non_query
+      @connection.create_command("CREATE TABLE sail_boats ( id INTEGER PRIMARY KEY, name VARCHAR(50), port VARCHAR(50), notes VARCHAR(50), vintage BOOLEAN )").execute_non_query
+      command = @connection.create_command("INSERT INTO sail_boats (id, name, port, name, vintage) VALUES (?, ?, ?, ?, ?)")
+      command.execute_non_query(1, "A", "C", "Fortune Pig!", false)
+      command.execute_non_query(2, "B", "B", "Happy Cow!", true)
+      command.execute_non_query(3, "C", "A", "Spoon", true)
+    end
+
+    after do
+      @connection.create_command("DROP TABLE sail_boats").execute_non_query
+    end
+
+    it "should quote a String" do
+      command = @connection.create_command("INSERT INTO users (name) VALUES (?)")
+      result = command.execute_non_query("John Doe")
+      result.to_i.should == 1
+    end
+
+    it "should quote multiple values" do
+      command = @connection.create_command("INSERT INTO users (name, age) VALUES (?, ?)")
+      result = command.execute_non_query("Sam Smoot", 1)
+      result.to_i.should == 1
+    end
+
+
+    it "should handle boolean columns gracefully" do
+      command = @connection.create_command("INSERT INTO sail_boats (id, name, port, name, vintage) VALUES (?, ?, ?, ?, ?)")
+      result = command.execute_non_query(4, "Scooner", "Port au Prince", "This is one gangster boat!", true)
+      result.to_i.should == 1
+    end
+
+    it "should quote an Array" do
+      command = @connection.create_command("SELECT id, notes FROM sail_boats WHERE (id IN ?)")
+      reader = command.execute_reader([1, 2, 3])
+
+      i = 1
+      while(reader.next!)
+        reader.values[0].should == i
+        i += 1
+      end
+    end
+
+    it "should quote an Array with NULL values returned" do
+      command = @connection.create_command("SELECT id, NULL AS notes FROM sail_boats WHERE (id IN ?)")
+      reader = command.execute_reader([1, 2, 3])
+
+      i = 1
+      while(reader.next!)
+        reader.values[0].should == i
+        i += 1
+      end
+    end
+
+    it "should quote an Array with NULL values returned AND set_types called" do
+      command = @connection.create_command("SELECT id, NULL AS notes FROM sail_boats WHERE (id IN ?)")
+      command.set_types [ Integer, String ]
+
+      reader = command.execute_reader([1, 2, 3])
+
+      i = 1
+      while(reader.next!)
+        reader.values[0].should == i
+        i += 1
+      end
+    end
+
+  end # describe "quoting"
+end

data/spec/integration/logging_spec.rb

@@ -0,0 +1,51 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataObjects::Sqlite3::Command do
+
+  before(:each) do
+    @connection = DataObjects::Connection.new("sqlite3://#{File.expand_path(File.dirname(__FILE__))}/test.db")
+  end
+
+  after(:each) do
+    @connection.close
+  end
+
+  describe "Executing a Reader" do
+
+    it "should log reader queries when the level is Debug (0)" do
+      command = @connection.create_command("SELECT * FROM users")
+      @mock_logger = mock('MockLogger', :level => 0)
+      DataObjects::Sqlite3.should_receive(:logger).and_return(@mock_logger)
+      @mock_logger.should_receive(:debug).with("SELECT * FROM users")
+      command.execute_reader
+    end
+
+    it "shouldn't log reader queries when the level isn't Debug (0)" do
+      command = @connection.create_command("SELECT * FROM users")
+      @mock_logger = mock('MockLogger', :level => 1)
+      DataObjects::Sqlite3.should_receive(:logger).and_return(@mock_logger)
+      @mock_logger.should_not_receive(:debug)
+      command.execute_reader
+    end
+  end
+
+  describe "Executing a Non-Query" do
+    it "should log non-query statements when the level is Debug (0)" do
+      command = @connection.create_command("INSERT INTO users (name) VALUES (?)")
+      @mock_logger = mock('MockLogger', :level => 0)
+      DataObjects::Sqlite3.should_receive(:logger).and_return(@mock_logger)
+      @mock_logger.should_receive(:debug).with("INSERT INTO users (name) VALUES ('Blah')")
+      command.execute_non_query('Blah')
+    end
+
+    it "shouldn't log non-query statements when the level isn't Debug (0)" do
+      command = @connection.create_command("INSERT INTO users (name) VALUES (?)")
+      @mock_logger = mock('MockLogger', :level => 1)
+      DataObjects::Sqlite3.should_receive(:logger).and_return(@mock_logger)
+      @mock_logger.should_not_receive(:debug)
+      command.execute_non_query('Blah')
+    end
+  end
+
+end

data/spec/integration/quoting_spec.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataObjects::Sqlite3::Command do
+
+  before(:each) do
+    @connection = DataObjects::Connection.new("sqlite3://#{File.expand_path(File.dirname(__FILE__))}/test.db")
+    @command = @connection.create_command("INSERT INTO users (name) VALUES (?)")
+  end
+
+  it "should properly quote a string" do
+    @command.quote_string("O'Hare").should == "'O''Hare'"
+    @command.quote_string("Willy O'Hare & Johnny O'Toole").should == "'Willy O''Hare & Johnny O''Toole'"
+    @command.quote_string("Billy\\Bob").should == "'Billy\\Bob'"
+    @command.quote_string("The\\Backslasher\\Rises\\Again").should == "'The\\Backslasher\\Rises\\Again'"
+    @command.quote_string("Scott \"The Rage\" Bauer").should == "'Scott \"The Rage\" Bauer'"
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+$TESTING=true
+
+require 'rubygems'
+require 'spec'
+require 'date'
+require 'pathname'
+
+# put data_objects from repository in the load path
+# DO NOT USE installed gem of data_objects!
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data_objects', 'lib'))
+require 'data_objects'
+
+# put the pre-compiled extension in the path to be found
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'do_sqlite3'
+
+log_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'log', 'do.log'))
+FileUtils.mkdir_p(File.dirname(log_path))
+
+DataObjects::Sqlite3.logger = DataObjects::Logger.new(log_path, 0)
+
+at_exit { DataObjects.logger.flush }
+
+module Sqlite3SpecHelpers
+
+  def insert(query, *args)
+    result = @connection.create_command(query).execute_non_query(*args)
+    result.insert_id
+  end
+
+  def exec(query, *args)
+    @connection.create_command(query).execute_non_query(*args)
+  end
+
+  def select(query, types = nil, *args)
+    begin
+      command = @connection.create_command(query)
+      command.set_types types unless types.nil?
+      reader = command.execute_reader(*args)
+      reader.next!
+      yield reader
+    ensure
+      reader.close if reader
+    end
+  end
+
+end

data/spec/unit/transaction_spec.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataObjects::Sqlite3::Transaction do
+
+  before :each do
+    @connection = mock("connection")
+    DataObjects::Connection.should_receive(:new).with("mock://mock/mock").once.and_return(@connection)
+    @transaction = DataObjects::Sqlite3::Transaction.new("mock://mock/mock")
+    @transaction.id.replace("id")
+    @command = mock("command")
+  end
+
+  {
+    :begin => "BEGIN",
+    :commit => "COMMIT",
+    :rollback => "ROLLBACK",
+    :rollback_prepared => "ROLLBACK",
+    :prepare => nil
+  }.each do |method, commands|
+    it "should execute #{commands.inspect} on ##{method}" do
+      if commands.is_a?(String)
+        @command.should_receive(:execute_non_query).once
+        @connection.should_receive(:create_command).once.with(commands).and_return(@command)
+        @transaction.send(method)
+      elsif commands.nil?
+        @command.should_not_receive(:execute_non_query)
+        @connection.should_not_receive(:create_command)
+        @transaction.send(method)
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: do_sqlite3
+version: !ruby/object:Gem::Version 
+  version: 0.9.6
+platform: x86-mswin32-60
+authors: 
+- Bernerd Schaefer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-29 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: data_objects
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: A DataObject.rb driver for Sqlite3
+email: 
+- bj.schaefer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO
+- ext/do_sqlite3_ext.c
+- ext/do_sqlite3_ext.so
+- ext/extconf.rb
+- lib/do_sqlite3.rb
+- lib/do_sqlite3/transaction.rb
+- lib/do_sqlite3/version.rb
+- lib/sqlite3.dll
+- spec/integration/do_sqlite3_spec.rb
+- spec/integration/logging_spec.rb
+- spec/integration/quoting_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/transaction_spec.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/dorb
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dorb
+rubygems_version: 1.3.0
+signing_key: 
+specification_version: 2
+summary: A DataObject.rb driver for Sqlite3
+test_files: []
+