do_sqlite3 0.10.3-x86-mingw32 → 0.10.4.rc1-x86-mingw32

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 - 2010 Yehuda Katz, Dirkjan Bussink
+Copyright (c) 2007 - 2011 Yehuda Katz, Dirkjan Bussink
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -18,10 +18,6 @@ An example of usage:
     @reader = @connection.create_command('SELECT * FROM users').execute_reader
     @reader.next!
 
-In the future, the `Connection` constructor will be able to be passed either a
-DataObjects-style URL or JDBC style URL, when using do\_sqlite3 on JRuby.
-However, this feature is not currently working reliably and is a known issue.
-
 ## Requirements
 
 This driver is provided for the following platforms:
@@ -74,7 +70,7 @@ For more information, see the SQLite3 driver wiki page:
 ## Developers
 
 Follow the above installation instructions. Additionally, you'll need:
-  * `bacon` gem for running specs.
+  * `rspec` gem for running specs.
   * `YARD` gem for generating documentation.
 
 See the DataObjects wiki for more comprehensive information on installing and
@@ -91,10 +87,7 @@ To run specs without compiling extensions first:
 
 To run individual specs:
 
-    rake spec TEST=spec/connection_spec.rb
-
-(Note that the `rake` task uses a `TEST` parameter, not `SPEC`. This is because
-the `Rake::TestTask` is used for executing the Bacon specs).
+    rake spec SPEC=spec/connection_spec.rb
 
 ## License
 

data/Rakefile

@@ -1,5 +1,7 @@
 require 'pathname'
-require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
 require 'rake'
 require 'rake/clean'
 
@@ -11,53 +13,18 @@ JRUBY    = RUBY_PLATFORM =~ /java/
 IRONRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ironruby'
 WINDOWS  = Gem.win_platform? || (JRUBY && ENV_JAVA['os.name'] =~ /windows/i)
 SUDO     = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
-BINARY_VERSION = '3070400'
+BINARY_VERSION = '3070600'
 
 CLEAN.include(%w[ {tmp,pkg}/ **/*.{o,so,bundle,jar,log,a,gem,dSYM,obj,pdb,exp,DS_Store,rbc,db} ext/do_sqlite3/Makefile ext-java/target ])
 
-begin
-  gem 'jeweler', '~> 1.4'
-  require 'jeweler'
-
-  Jeweler::Tasks.new do |gem|
-    gem.name        = 'do_sqlite3'
-    gem.version     = DataObjects::Sqlite3::VERSION
-    gem.summary     = 'DataObjects Sqlite3 Driver'
-    gem.description = 'Implements the DataObjects API for Sqlite3'
-    gem.platform    = Gem::Platform::RUBY
-    gem.files       = FileList['lib/**/*.rb', 'spec/**/*.rb', 'tasks/**/*.rake',
-                               'ext/**/*.{rb,c,h}', 'LICENSE', 'Rakefile',
-                               '*.{markdown,rdoc,txt,yml}']
-    gem.extra_rdoc_files = FileList['README*', 'ChangeLog*', 'LICENSE']
-    gem.test_files  = FileList['spec/**/*.rb']
-
-    # rake-compiler should generate gemspecs for other platforms (e.g. 'java')
-    # and modify dependencies and extensions appropriately
-    gem.extensions << 'ext/do_sqlite3/extconf.rb'
-
-    gem.add_dependency 'data_objects', DataObjects::Sqlite3::VERSION
-
-    gem.add_development_dependency 'bacon',         '~>1.1'
-    gem.add_development_dependency 'rake-compiler', '= 0.7.0'
-
-    gem.has_rdoc = false
-    gem.rubyforge_project = 'dorb'
-    gem.authors     = [ 'Dirkjan Bussink' ]
-    gem.email       = 'd.bussink@gmail.com'
-  end
 
-  if JRUBY
-    Rake::Task['build'].clear_actions   if Rake::Task.task_defined?('build')
-    Rake::Task['install'].clear_actions if Rake::Task.task_defined?('install')
-    task :build => [ :java, :gem ]
-    task :install do
-      sh "#{Config::CONFIG['RUBY_INSTALL_NAME']} -S gem install pkg/do_sqlite3-#{DataObjects::Sqlite3::VERSION}-java.gem"
-    end
+if JRUBY
+  Rake::Task['build'].clear_actions   if Rake::Task.task_defined?('build')
+  Rake::Task['install'].clear_actions if Rake::Task.task_defined?('install')
+  task :build => [ :java, :gem ]
+  task :install do
+    sh "#{Config::CONFIG['RUBY_INSTALL_NAME']} -S gem install pkg/do_sqlite3-#{DataObjects::Sqlite3::VERSION}-java.gem"
   end
-
-  Jeweler::GemcutterTasks.new
-
-  FileList['tasks/**/*.rake'].each { |task| import task }
-rescue LoadError
-  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
 end
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/ext/do_sqlite3/do_common.c

@@ -0,0 +1,526 @@
+#include <ruby.h>
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+#include <time.h>
+
+#include "do_common.h"
+
+/*
+ * Common variables ("globals")
+ */
+
+// To store rb_intern values
+ID ID_NEW;
+ID ID_NEW_DATE;
+ID ID_CONST_GET;
+ID ID_RATIONAL;
+ID ID_ESCAPE;
+ID ID_STRFTIME;
+ID ID_LOG;
+
+// Reference to Extlib module
+VALUE mExtlib;
+VALUE rb_cByteArray;
+
+// References to DataObjects base classes
+VALUE mDO;
+VALUE cDO_Quoting;
+VALUE cDO_Connection;
+VALUE cDO_Command;
+VALUE cDO_Result;
+VALUE cDO_Reader;
+VALUE cDO_Logger;
+VALUE cDO_Logger_Message;
+VALUE cDO_Extension;
+VALUE eConnectionError;
+VALUE eDataError;
+
+// References to Ruby classes that we'll need
+VALUE rb_cDate;
+VALUE rb_cDateTime;
+VALUE rb_cBigDecimal;
+
+/*
+ * Common Functions
+ */
+
+void data_objects_debug(VALUE connection, VALUE string, struct timeval *start) {
+  struct timeval stop;
+  VALUE message;
+
+  gettimeofday(&stop, NULL);
+  do_int64 duration = (stop.tv_sec - start->tv_sec) * 1000000 + stop.tv_usec - start->tv_usec;
+
+  message = rb_funcall(cDO_Logger_Message, ID_NEW, 3, string, rb_time_new(start->tv_sec, start->tv_usec), INT2NUM(duration));
+
+  rb_funcall(connection, ID_LOG, 1, message);
+}
+
+void do_raise_error(VALUE self, const struct errcodes *errors, int errnum, const char *message, VALUE query, VALUE state) {
+  const char *exception_type = "SQLError";
+  const struct errcodes *e;
+
+  for (e = errors; e->error_name; e++) {
+    if (e->error_no == errnum) {
+      // return the exception type for the matching error
+      exception_type = e->exception;
+      break;
+    }
+  }
+
+  VALUE uri = rb_funcall(rb_iv_get(self, "@connection"), rb_intern("to_s"), 0);
+
+  VALUE exception = rb_funcall(
+    do_const_get(mDO, exception_type),
+    ID_NEW,
+    5,
+    rb_str_new2(message),
+    INT2NUM(errnum),
+    state,
+    query,
+    uri
+  );
+
+  rb_exc_raise(exception);
+}
+
+char *get_uri_option(VALUE query_hash, const char *key) {
+  VALUE query_value;
+  char *value = NULL;
+
+  if (!rb_obj_is_kind_of(query_hash, rb_cHash)) {
+    return NULL;
+  }
+
+  query_value = rb_hash_aref(query_hash, rb_str_new2(key));
+
+  if (Qnil != query_value) {
+    value = StringValuePtr(query_value);
+  }
+
+  return value;
+}
+
+void assert_file_exists(char *file, const char *message) {
+  if (file) {
+    if (rb_funcall(rb_cFile, rb_intern("exist?"), 1, rb_str_new2(file)) == Qfalse) {
+      rb_raise(rb_eArgError, "%s", message);
+    }
+  }
+}
+
+VALUE build_query_from_args(VALUE klass, int count, VALUE *args) {
+  VALUE array = rb_ary_new();
+  int i;
+
+  for (i = 0; i < count; i++) {
+    rb_ary_push(array, args[i]);
+  }
+
+  return rb_funcall(klass, ID_ESCAPE, 1, array);
+}
+
+// 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.
+void reduce(do_int64 *numerator, do_int64 *denominator) {
+  do_int64 a = *numerator, b = *denominator, c;
+
+  while (a != 0) {
+    c = a;
+    a = b % a;
+    b = c;
+  }
+
+  *numerator   /= b;
+  *denominator /= b;
+}
+
+// Generate the date integer which Date.civil_to_jd returns
+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 (int)(floor(365.25 * (year + 4716)) + floor(30.6001 * (month + 1)) + day + b - 1524);
+}
+
+VALUE seconds_to_offset(long seconds_offset) {
+  do_int64 num = seconds_offset;
+  do_int64 den = 86400;
+
+  reduce(&num, &den);
+  return rb_funcall(rb_mKernel, ID_RATIONAL, 2, rb_ll2inum(num), rb_ll2inum(den));
+}
+
+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);
+}
+
+VALUE parse_date(const char *date) {
+  static char const *const _fmt_date = "%4d-%2d-%2d";
+  int year = 0, month = 0, day = 0;
+  int jd, ajd;
+  VALUE rational;
+
+  switch (sscanf(date, _fmt_date, &year, &month, &day)) {
+    case 0:
+    case EOF:
+      return Qnil;
+  }
+
+  jd       = jd_from_date(year, month, day);
+  ajd      = (jd * 2) - 1;        // Math from Date.jd_to_ajd
+  rational = rb_funcall(rb_mKernel, ID_RATIONAL, 2, INT2NUM(ajd), INT2NUM(2));
+
+  return rb_funcall(rb_cDate, ID_NEW_DATE, 3, rational, INT2NUM(0), INT2NUM(2299161));
+}
+
+VALUE parse_time(const char *date) {
+  static char const* const _fmt_datetime = "%4d-%2d-%2d %2d:%2d:%2d%7lf";
+  int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0, usec = 0;
+  double subsec = 0;
+
+  switch (sscanf(date, _fmt_datetime, &year, &month, &day, &hour, &min, &sec, &subsec)) {
+    case 0:
+    case EOF:
+      return Qnil;
+  }
+
+  usec = (int) (subsec * 1000000);
+
+  /* Mysql TIMESTAMPS can default to 0 */
+  if ((year + month + day + hour + min + sec + usec) == 0) {
+    return Qnil;
+  }
+
+  return rb_funcall(rb_cTime, rb_intern("local"), 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
+}
+
+VALUE parse_date_time(const char *date) {
+  static char const* const _fmt_datetime_tz_normal = "%4d-%2d-%2d %2d:%2d:%2d%3d:%2d";
+  static char const* const _fmt_datetime_tz_subsec = "%4d-%2d-%2d %2d:%2d:%2d.%*d%3d:%2d";
+  int tokens_read;
+  const char *fmt_datetime;
+
+  VALUE ajd, offset;
+
+  int year, month, day, hour, min, sec, hour_offset, minute_offset, jd;
+  do_int64 num, den;
+
+  struct tm timeinfo;
+  time_t target_time;
+  time_t gmt_offset;
+  int dst_adjustment;
+
+  if (*date == '\0') {
+    return Qnil;
+  }
+
+  /*
+   * We handle the following cases:
+   *   - Date (default to midnight) [3 tokens, missing 5]
+   *   - DateTime [6 tokens, missing 2]
+   *   - DateTime with hour, possibly minute TZ offset [7-8 tokens]
+   */
+  fmt_datetime = strchr(date, '.') ? _fmt_datetime_tz_subsec : _fmt_datetime_tz_normal;
+  tokens_read  = sscanf(date, fmt_datetime, &year, &month, &day, &hour, &min, &sec, &hour_offset, &minute_offset);
+
+  switch (tokens_read) {
+    case 8:
+      minute_offset *= hour_offset < 0 ? -1 : 1;
+      break;
+
+    case 7: /* Only got TZ hour offset, so assume 0 for minute */
+      minute_offset = 0;
+      break;
+
+    case 3: /* Only got Date */
+      hour = 0;
+      min  = 0;
+      sec  = 0;
+      /* Fall through */
+
+    case 6: /* Only got DateTime */
+      /*
+       * Interpret the DateTime from the local system TZ.  If target date would
+       * end up in DST, assume adjustment of a 1 hour shift.
+       *
+       * FIXME: The DST adjustment calculation won't be accurate for timezones
+       * that observe fractional-hour shifts.  But that's a real minority for
+       * now..
+       */
+      timeinfo.tm_year  = year - 1900;
+      timeinfo.tm_mon   = month - 1;    // 0 - 11
+      timeinfo.tm_mday  = day;
+      timeinfo.tm_hour  = hour;
+      timeinfo.tm_min   = min;
+      timeinfo.tm_sec   = sec;
+      timeinfo.tm_isdst = -1;
+
+      target_time    = mktime(&timeinfo);
+      dst_adjustment = timeinfo.tm_isdst ? 3600 : 0;
+
+      /*
+       * Now figure out seconds from UTC.  For that we need a UTC/GMT-adjusted
+       * time_t, which we get from mktime(gmtime(current_time)).
+       *
+       * NOTE: Some modern libc's have tm_gmtoff in struct tm, but we can't count
+       * on that.
+       */
+#ifdef HAVE_GMTIME_R
+      gmtime_r(&target_time, &timeinfo);
+#else
+      timeinfo = *gmtime(&target_time);
+#endif
+
+      gmt_offset    = target_time - mktime(&timeinfo) + dst_adjustment;
+      hour_offset   = ((int)gmt_offset / 3600);
+      minute_offset = ((int)gmt_offset % 3600 / 60);
+      break;
+
+    default: /* Any other combo of missing tokens and we can't do anything */
+      rb_raise(eDataError, "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 #-.
+   *
+   * TODO: These are 64bit numbers; is reduce() really necessary?
+   */
+
+  num = (hour * 1440) + (min * 24);
+  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 * 2) - den;
+  den *= 2;
+  reduce(&num, &den);
+
+  ajd = rb_funcall(rb_mKernel, ID_RATIONAL, 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));
+}
+
+VALUE cConnection_character_set(VALUE self) {
+  return rb_iv_get(self, "@encoding");
+}
+
+VALUE cConnection_is_using_socket(VALUE self) {
+  return rb_iv_get(self, "@using_socket");
+}
+
+VALUE cConnection_ssl_cipher(VALUE self) {
+  return rb_iv_get(self, "@ssl_cipher");
+}
+
+VALUE cConnection_quote_time(VALUE self, VALUE value) {
+  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
+}
+
+VALUE cConnection_quote_date_time(VALUE self, VALUE value) {
+  // TODO: Support non-local dates. we need to call #new_offset on the date to be
+  // quoted and pass in the current locale's date offset (self.new_offset((hours * 3600).to_r / 86400)
+  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
+}
+
+VALUE cConnection_quote_date(VALUE self, VALUE value) {
+  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d'"));
+}
+
+/*
+ * Accepts an array of Ruby types (Fixnum, Float, String, etc...) and turns them
+ * into Ruby-strings so we can easily typecast later
+ */
+VALUE cCommand_set_types(int argc, VALUE *argv, VALUE self) {
+  VALUE type_strings = rb_ary_new();
+  VALUE array = rb_ary_new();
+
+  int i, j;
+
+  for (i = 0; i < argc; i++) {
+    rb_ary_push(array, argv[i]);
+  }
+
+  VALUE entry, sub_entry;
+
+  for (i = 0; i < RARRAY_LEN(array); i++) {
+    entry = rb_ary_entry(array, i);
+
+    if (TYPE(entry) == T_CLASS) {
+      rb_ary_push(type_strings, entry);
+    }
+    else if (TYPE(entry) == T_ARRAY) {
+      for (j = 0; j < RARRAY_LEN(entry); j++) {
+        sub_entry = rb_ary_entry(entry, j);
+
+        if (TYPE(sub_entry) == T_CLASS) {
+          rb_ary_push(type_strings, sub_entry);
+        }
+    else {
+          rb_raise(rb_eArgError, "Invalid type given");
+        }
+      }
+    }
+    else {
+      rb_raise(rb_eArgError, "Invalid type given");
+    }
+  }
+
+  rb_iv_set(self, "@field_types", type_strings);
+  return array;
+}
+
+VALUE cReader_values(VALUE self) {
+  VALUE state = rb_iv_get(self, "@opened");
+  VALUE values = rb_iv_get(self, "@values");
+
+  if (state == Qnil || state == Qfalse || values == Qnil) {
+    rb_raise(eDataError, "Reader is not initialized");
+  }
+
+  return rb_iv_get(self, "@values");
+}
+
+VALUE cReader_fields(VALUE self) {
+  return rb_iv_get(self, "@fields");
+}
+
+VALUE cReader_field_count(VALUE self) {
+  return rb_iv_get(self, "@field_count");
+}
+
+void common_init(void) {
+  rb_require("bigdecimal");
+  rb_require("rational");
+  rb_require("date");
+  rb_require("data_objects");
+
+  // Needed by do_const_get
+  ID_CONST_GET = rb_intern("const_get");
+
+  // Get references classes needed for Date/Time parsing
+  rb_cDate = do_const_get(rb_mKernel, "Date");
+  rb_cDateTime = do_const_get(rb_mKernel, "DateTime");
+  rb_cBigDecimal = do_const_get(rb_mKernel, "BigDecimal");
+
+  ID_NEW = rb_intern("new");
+#ifdef RUBY_LESS_THAN_186
+  ID_NEW_DATE = rb_intern("new0");
+#else
+  ID_NEW_DATE = rb_intern("new!");
+#endif
+  ID_CONST_GET = rb_intern("const_get");
+  ID_RATIONAL = rb_intern("Rational");
+  ID_ESCAPE = rb_intern("escape_sql");
+  ID_STRFTIME = rb_intern("strftime");
+  ID_LOG = rb_intern("log");
+
+  // Get references to the Extlib module
+  mExtlib = do_const_get(rb_mKernel, "Extlib");
+  rb_cByteArray = do_const_get(mExtlib, "ByteArray");
+
+  // Get references to the DataObjects module and its classes
+  mDO = do_const_get(rb_mKernel, "DataObjects");
+  cDO_Quoting = do_const_get(mDO, "Quoting");
+  cDO_Connection = do_const_get(mDO, "Connection");
+  cDO_Command = do_const_get(mDO, "Command");
+  cDO_Result = do_const_get(mDO, "Result");
+  cDO_Reader = do_const_get(mDO, "Reader");
+  cDO_Logger = do_const_get(mDO, "Logger");
+  cDO_Logger_Message = do_const_get(cDO_Logger, "Message");
+  cDO_Extension = do_const_get(mDO, "Extension");
+
+  eConnectionError = do_const_get(mDO, "ConnectionError");
+  eDataError = do_const_get(mDO, "DataError");
+
+  rb_global_variable(&ID_NEW_DATE);
+  rb_global_variable(&ID_RATIONAL);
+  rb_global_variable(&ID_CONST_GET);
+  rb_global_variable(&ID_ESCAPE);
+  rb_global_variable(&ID_LOG);
+  rb_global_variable(&ID_NEW);
+
+  rb_global_variable(&rb_cDate);
+  rb_global_variable(&rb_cDateTime);
+  rb_global_variable(&rb_cBigDecimal);
+  rb_global_variable(&rb_cByteArray);
+
+  rb_global_variable(&mDO);
+  rb_global_variable(&cDO_Logger_Message);
+
+  rb_global_variable(&eConnectionError);
+  rb_global_variable(&eDataError);
+
+  tzset();
+}
+
+/*
+ * Common typecasting logic that can be used or overriden by Adapters.
+ */
+extern VALUE do_typecast(const char *value, long length, const VALUE type, int encoding) {
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *internal_encoding = rb_default_internal_encoding();
+#else
+  void *internal_encoding = NULL;
+#endif
+
+  if (type == rb_cInteger) {
+    return rb_cstr2inum(value, 10);
+  }
+  else if (type == rb_cString) {
+    return do_str_new(value, length, encoding, internal_encoding);
+  }
+  else if (type == rb_cFloat) {
+    return rb_float_new(rb_cstr_to_dbl(value, Qfalse));
+  }
+  else if (type == rb_cBigDecimal) {
+    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, rb_str_new(value, length));
+  }
+  else if (type == rb_cDate) {
+    return parse_date(value);
+  }
+  else if (type == rb_cDateTime) {
+    return parse_date_time(value);
+  }
+  else if (type == rb_cTime) {
+    return parse_time(value);
+  }
+  else if (type == rb_cTrueClass) {
+    return (!value || strcmp("0", value) == 0) ? Qfalse : Qtrue;
+  }
+  else if (type == rb_cByteArray) {
+    return rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new(value, length));
+  }
+  else if (type == rb_cClass) {
+    return rb_funcall(mDO, rb_intern("full_const_get"), 1, rb_str_new(value, length));
+  }
+  else if (type == rb_cNilClass) {
+    return Qnil;
+  }
+  else {
+    return DO_STR_NEW(value, length, encoding, internal_encoding);
+  }
+}