swift 0.13.0 → 0.14.0

data/ext/query.cc

@@ -1,7 +1,9 @@
 #include "query.h"
+#include <math.h>
 
-ID fstrftime, fto_s, fusec;
-VALUE dtformat, tzformat, utf8;
+ID fstrftime;
+VALUE dtformat, utf8;
+VALUE cDateTime;
 
 VALUE query_execute(Query *query) {
   try {
@@ -11,10 +13,24 @@ VALUE query_execute(Query *query) {
         : query->handle->conn()->execute(query->sql, query->bind)
     );
   }
+  catch (dbi::ConnectionError &e) {
+    query->error_klass = eSwiftConnectionError;
+    snprintf(query->error_message, 8192, "%s", e.what());
+  }
   catch (dbi::Error &e) {
-    snprintf(query->error, 8192, "%s", e.what());
-    return Qfalse;
+    query->error_klass = eSwiftRuntimeError;
+    snprintf(query->error_message, 8192, "%s", e.what());
+  }
+  catch (std::bad_alloc &e) {
+    query->error_klass = rb_eNoMemError;
+    snprintf(query->error_message, 8192, "%s", e.what());
   }
+  catch (std::exception &e) {
+    query->error_klass = rb_eRuntimeError;
+    snprintf(query->error_message, 8192, "%s", e.what());
+  }
+
+  return Qfalse;
 }
 
 VALUE query_execute_statement(Query *query) {
@@ -25,10 +41,24 @@ VALUE query_execute_statement(Query *query) {
         : query->statement->execute(query->bind)
     );
   }
+  catch (dbi::ConnectionError &e) {
+    query->error_klass = eSwiftConnectionError;
+    snprintf(query->error_message, 8192, "%s", e.what());
+  }
   catch (dbi::Error &e) {
-    snprintf(query->error, 8192, "%s", e.what());
-    return Qfalse;
+    query->error_klass = eSwiftRuntimeError;
+    snprintf(query->error_message, 8192, "%s", e.what());
+  }
+  catch (std::bad_alloc &e) {
+    query->error_klass = rb_eNoMemError;
+    snprintf(query->error_message, 8192, "%s", e.what());
+  }
+  catch (std::exception &e) {
+    query->error_klass = rb_eRuntimeError;
+    snprintf(query->error_message, 8192, "%s", e.what());
   }
+
+  return Qfalse;
 }
 
 void query_bind_values(Query *query, VALUE bind_values) {
@@ -48,13 +78,8 @@ void query_bind_values(Query *query, VALUE bind_values) {
       bind_value = rb_funcall(bind_value, rb_intern("read"), 0);
       query->bind.push_back(dbi::PARAM_BINARY((unsigned char*)RSTRING_PTR(bind_value), RSTRING_LEN(bind_value)));
     }
-    // TODO convert timestamps to server timezone if @timezone is set in adapter.
-    else if (rb_obj_is_kind_of(bind_value, rb_cTime)) {
+    else if (rb_obj_is_kind_of(bind_value, rb_cTime) || rb_obj_is_kind_of(bind_value, cDateTime)) {
       std::string timestamp = RSTRING_PTR(rb_funcall(bind_value, fstrftime, 1, dtformat));
-
-      timestamp += RSTRING_PTR(rb_funcall(rb_funcall(bind_value, fusec, 0), fto_s, 0));
-      timestamp += RSTRING_PTR(rb_funcall(bind_value, fstrftime, 1, tzformat));
-
       query->bind.push_back(dbi::PARAM(timestamp));
     }
     else {
@@ -67,14 +92,13 @@ void query_bind_values(Query *query, VALUE bind_values) {
 }
 
 void init_swift_query() {
-  fstrftime = rb_intern("strftime");
-  fto_s     = rb_intern("to_s");
-  fusec     = rb_intern("usec");
-  dtformat  = rb_str_new2("%F %T.");
-  tzformat  = rb_str_new2("%z");
+  rb_require("date");
+
   utf8      = rb_str_new2("UTF-8");
+  fstrftime = rb_intern("strftime");
+  dtformat  = rb_str_new2("%F %T.%N %z");
+  cDateTime = CONST_GET(rb_mKernel, "DateTime");
 
   rb_global_variable(&utf8);
-  rb_global_variable(&tzformat);
   rb_global_variable(&dtformat);
 }

data/ext/query.h

@@ -8,7 +8,8 @@ struct Query {
   dbi::Handle             *handle;
   dbi::AbstractStatement  *statement;
   std::vector<dbi::Param> bind;
-  char                    error[8192];
+  char                    error_message[8192];
+  VALUE                   error_klass;
 };
 
 VALUE query_execute(Query*);

data/ext/result.cc

@@ -1,11 +1,11 @@
 #include "result.h"
+#include "datetime.h"
 #include <math.h>
 
-VALUE cBigDecimal;
-VALUE cStringIO;
-VALUE cSwiftResult;
+#define date_parse(klass, data,len) rb_funcall(datetime_parse(klass, data, len), fto_date, 0)
 
-ID fnew, fto_date, fload;
+VALUE cBigDecimal, cStringIO, cSwiftResult;
+ID fnew, fload, fto_date;
 
 void result_mark(ResultWrapper *handle) {
   if (handle)
@@ -57,13 +57,10 @@ static VALUE result_dup(VALUE self) {
 
 VALUE result_each(VALUE self) {
   uint64_t length;
-  const char *data, *tzstring;
+  const char *data;
 
   dbi::AbstractResult *result = result_handle(self);
   VALUE scheme   = rb_iv_get(self, "@scheme");
-  VALUE timezone = rb_iv_get(self, "@timezone");
-
-  tzstring = NIL_P(timezone) ? 0 : CSTRING(timezone);
 
   try {
     std::vector<string> result_fields = result->fields();
@@ -81,7 +78,7 @@ VALUE result_each(VALUE self) {
           rb_hash_aset(
             tuple,
             fields[column],
-            typecast_field(result_types[column], data, length, tzstring)
+            typecast_field(result_types[column], data, length)
           );
         }
         else {
@@ -96,134 +93,7 @@ VALUE result_each(VALUE self) {
   return Qnil;
 }
 
-// Calculates local offset at a given time, including dst.
-int64_t client_tzoffset(int64_t local, int isdst) {
-  struct tm tm;
-  gmtime_r((const time_t*)&local, &tm);
-  // TODO: This won't work in Lord Howe Island, Australia which uses half hour shift.
-  return (int64_t)(local + (isdst ? 3600 : 0) - mktime(&tm));
-}
-
-// Calculates server offset at a given time, including dst.
-int64_t server_tzoffset(struct tm* tm, const char *zone) {
-  uint64_t local;
-  int64_t  offset;
-  char buffer[512];
-  char *old, saved[512];
-  struct tm tm_copy;
-
-  // save current zone setting.
-  if ((old = getenv("TZ"))) {
-    strncpy(saved, old, 512);
-    saved[511] = 0;
-  }
-
-  // setup.
-  snprintf(buffer, 512, ":%s", zone);
-  setenv("TZ", buffer, 1);
-  tzset();
-
-  // pretend we're on server timezone and calculate offset.
-  memcpy(&tm_copy, tm, sizeof(struct tm));
-  tm_copy.tm_isdst = -1;
-  local  = mktime(&tm_copy);
-  offset = client_tzoffset(local, tm_copy.tm_isdst);
-
-  // reset timezone to what it was before.
-  old ? setenv("TZ", saved, 1) : unsetenv("TZ");
-  tzset();
-
-  return offset;
-}
-
-VALUE typecast_timestamp(const char *data, uint64_t len, const char *zone) {
-  struct   tm tm;
-  uint64_t usec   = 0;
-  int64_t  epoch, adjust, offset;
-  char     tzsign = 0, subsec[32];
-  int      tzhour = 0, tzmin = 0, lastmatch = -1;
-
-  memset(&tm, 0, sizeof(struct tm));
-  sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%n",
-      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &lastmatch);
-
-  // parse millisecs if any
-  if (lastmatch > 0 && lastmatch < len && *(data+lastmatch) == '.') {
-      lastmatch++;
-      int idx = 0;
-      const char *ptr = data + lastmatch;
-      while (*ptr && *ptr >= '0' && *ptr <= '9' && idx < 31) {
-        subsec[idx++] = *ptr;
-        ptr++;
-        lastmatch++;
-      }
-      subsec[idx] = 0;
-      usec        = round(atoll(subsec) * (1000000 / pow(10, idx)));
-  }
-
-  tm.tm_year  -= 1900;
-  tm.tm_mon   -= 1;
-  tm.tm_isdst = -1;
-  if (tm.tm_mday > 0) {
-    epoch  = mktime(&tm);
-    adjust = client_tzoffset(epoch, tm.tm_isdst);
-    offset = adjust;
-
-    // parse timezone offsets if any - matches +HH:MM +HH MM +HHMM
-    if (lastmatch > 0 && lastmatch < len) {
-      const char *ptr = data + lastmatch;
-      while(*ptr && *ptr != '+' && *ptr != '-') ptr++;
-      tzsign = *ptr++;
-      if (*ptr && *ptr >= '0' && *ptr <= '9') {
-        tzhour = *ptr++ - '0';
-        if (*ptr && *ptr >= '0' && *ptr <= '9') tzhour = tzhour*10 + *ptr++ - '0';
-        while(*ptr && (*ptr < '0' || *ptr > '9')) ptr++;
-        if (*ptr && *ptr >= '0' && *ptr <= '9') {
-          tzmin = *ptr++ - '0';
-          if (*ptr && *ptr >= '0' && *ptr <= '9') tzmin = tzmin*10 + *ptr++ - '0';
-        }
-      }
-    }
-
-    if (tzsign) {
-      offset = tzsign == '+'
-        ? (time_t)tzhour *  3600 + (time_t)tzmin *  60
-        : (time_t)tzhour * -3600 + (time_t)tzmin * -60;
-    }
-    else if (zone) {
-      if (strncasecmp(zone, "UTC", 3) == 0 || strncasecmp(zone, "GMT", 3) == 0)
-        offset = 0;
-      else if (strcmp(zone, "+00:00") == 0 || strcmp(zone, "+0000") == 0)
-        offset = 0;
-      else if (sscanf(zone, "%c%02d%02d",  &tzsign, &tzhour, &tzmin) == 3)
-        offset = tzsign == '+'
-          ? (time_t)tzhour *  3600 + (time_t)tzmin *  60
-          : (time_t)tzhour * -3600 + (time_t)tzmin * -60;
-      else if (sscanf(zone, "%c%02d:%02d", &tzsign, &tzhour, &tzmin) >= 2)
-        offset = tzsign == '+'
-          ? (time_t)tzhour *  3600 + (time_t)tzmin *  60
-          : (time_t)tzhour * -3600 + (time_t)tzmin * -60;
-      else
-        offset = server_tzoffset(&tm, zone);
-    }
-
-    return rb_time_new(epoch+adjust-offset, usec);
-  }
-
-  printf("WARNING: Unable to parse timestamp value '%s'\n", data);
-  return rb_str_new(data, len);
-}
-
-#define typecast_date(data,len,tz)   rb_funcall(typecast_timestamp(data,len,tz), fto_date, 0)
-
-/*
-  This is my wish list below for rubycore - to be built into core ruby.
-  1. Time class represents time - time zone invariant
-  2. Date class represents a date - time zone invariant
-  3. DateTime class represents a timestamp with full zoneinfo support.
-*/
-
-VALUE typecast_field(int type, const char *data, uint64_t length, const char* timezone) {
+VALUE typecast_field(int type, const char *data, uint64_t length) {
   switch(type) {
     case DBI_TYPE_BOOLEAN:
       return (data && (data[0] =='t' || data[0] == '1')) ? Qtrue : Qfalse;
@@ -232,9 +102,9 @@ VALUE typecast_field(int type, const char *data, uint64_t length, const char* ti
     case DBI_TYPE_BLOB:
       return rb_funcall(cStringIO, fnew, 1, rb_str_new(data, length));
     case DBI_TYPE_TIMESTAMP:
-      return typecast_timestamp(data, length, timezone);
+      return datetime_parse(cSwiftDateTime, data, length);
     case DBI_TYPE_DATE:
-      return typecast_date(data, length, timezone);
+      return date_parse(cSwiftDateTime, data, length);
     case DBI_TYPE_NUMERIC:
       return rb_funcall(cBigDecimal, fnew, 1, rb_str_new2(data));
     case DBI_TYPE_FLOAT:
@@ -284,29 +154,76 @@ VALUE result_fields(VALUE self) {
   CATCH_DBI_EXCEPTIONS();
 }
 
+VALUE result_field_types(VALUE self) {
+  dbi::AbstractResult *result   = result_handle(self);
+  std::vector<int> result_types = result->types();
+
+  VALUE types = rb_ary_new();
+  for (std::vector<int>::iterator it = result_types.begin(); it != result_types.end(); it++) {
+    switch(*it) {
+      case DBI_TYPE_BOOLEAN:
+        rb_ary_push(types, rb_str_new2("boolean"));
+        break;
+      case DBI_TYPE_INT:
+        rb_ary_push(types, rb_str_new2("integer"));
+        break;
+      case DBI_TYPE_BLOB:
+        rb_ary_push(types, rb_str_new2("blob"));
+        break;
+      case DBI_TYPE_TIMESTAMP:
+        rb_ary_push(types, rb_str_new2("timestamp"));
+        break;
+      case DBI_TYPE_DATE:
+        rb_ary_push(types, rb_str_new2("date"));
+        break;
+      case DBI_TYPE_NUMERIC:
+        rb_ary_push(types, rb_str_new2("numeric"));
+        break;
+      case DBI_TYPE_FLOAT:
+        rb_ary_push(types, rb_str_new2("float"));
+        break;
+      case DBI_TYPE_TIME:
+        rb_ary_push(types, rb_str_new2("time"));
+        break;
+      default:
+        rb_ary_push(types, rb_str_new2("text"));
+    }
+  }
+
+  return types;
+}
+
+VALUE result_retrieve(VALUE self) {
+  dbi::AbstractResult *result = result_handle(self);
+  while (result->consumeResult());
+  result->prepareResult();
+  return true;
+}
+
 void init_swift_result() {
   rb_require("bigdecimal");
   rb_require("stringio");
-  rb_require("date");
 
   VALUE mSwift = rb_define_module("Swift");
   cSwiftResult = rb_define_class_under(mSwift, "Result", rb_cObject);
   cStringIO    = CONST_GET(rb_mKernel, "StringIO");
   cBigDecimal  = CONST_GET(rb_mKernel, "BigDecimal");
 
-  fnew         = rb_intern("new");
   fto_date     = rb_intern("to_date");
+  fnew         = rb_intern("new");
   fload        = rb_intern("load");
 
   rb_define_alloc_func(cSwiftResult, result_alloc);
   rb_include_module(cSwiftResult, CONST_GET(rb_mKernel, "Enumerable"));
 
-  rb_define_method(cSwiftResult, "clone",      RUBY_METHOD_FUNC(result_clone),     0);
-  rb_define_method(cSwiftResult, "dup",        RUBY_METHOD_FUNC(result_dup),       0);
-  rb_define_method(cSwiftResult, "each",       RUBY_METHOD_FUNC(result_each),      0);
-  rb_define_method(cSwiftResult, "insert_id",  RUBY_METHOD_FUNC(result_insert_id), 0);
-  rb_define_method(cSwiftResult, "rows",       RUBY_METHOD_FUNC(result_rows),      0);
-  rb_define_method(cSwiftResult, "columns",    RUBY_METHOD_FUNC(result_columns),   0);
-  rb_define_method(cSwiftResult, "fields",     RUBY_METHOD_FUNC(result_fields),    0);
+  rb_define_method(cSwiftResult, "retrieve",    RUBY_METHOD_FUNC(result_retrieve),    0);
+  rb_define_method(cSwiftResult, "clone",       RUBY_METHOD_FUNC(result_clone),       0);
+  rb_define_method(cSwiftResult, "dup",         RUBY_METHOD_FUNC(result_dup),         0);
+  rb_define_method(cSwiftResult, "each",        RUBY_METHOD_FUNC(result_each),        0);
+  rb_define_method(cSwiftResult, "insert_id",   RUBY_METHOD_FUNC(result_insert_id),   0);
+  rb_define_method(cSwiftResult, "rows",        RUBY_METHOD_FUNC(result_rows),        0);
+  rb_define_method(cSwiftResult, "columns",     RUBY_METHOD_FUNC(result_columns),     0);
+  rb_define_method(cSwiftResult, "fields",      RUBY_METHOD_FUNC(result_fields),      0);
+  rb_define_method(cSwiftResult, "field_types", RUBY_METHOD_FUNC(result_field_types), 0);
 }
 

data/ext/result.h

@@ -22,6 +22,6 @@ dbi::AbstractResult* result_handle(VALUE);
 
 VALUE result_each(VALUE);
 
-VALUE typecast_field(int, const char*, uint64_t, const char*);
+VALUE typecast_field(int, const char*, uint64_t);
 
 #endif

data/ext/statement.cc

@@ -56,7 +56,7 @@ static VALUE statement_execute(int argc, VALUE *argv, VALUE self) {
     if (dbi::_trace)                 dbi::logMessage(dbi::_trace_fd, dbi::formatParams(statement->command(), query.bind));
 
     if (rb_thread_blocking_region(((VALUE (*)(void*))query_execute_statement), &query, RUBY_UBF_IO, 0) == Qfalse)
-      rb_raise(eSwiftRuntimeError, "%s", query.error);
+      rb_raise(query.error_klass, "%s", query.error_message);
   }
   CATCH_DBI_EXCEPTIONS();
 

data/ext/swift.cc

@@ -96,11 +96,10 @@ extern "C" {
 
     init_swift_adapter();
     init_swift_attribute();
-    init_swift_pool();
-    init_swift_request();
     init_swift_result();
     init_swift_statement();
     init_swift_query();
+    init_swift_datetime();
 
     rb_define_module_function(mSwift, "init",  RUBY_METHOD_FUNC(swift_init), 1);
     rb_define_module_function(mSwift, "trace", RUBY_METHOD_FUNC(swift_trace), -1);

data/ext/swift.h

@@ -28,6 +28,9 @@ extern VALUE eSwiftConnectionError;
   } \
   catch (std::bad_alloc &error) { \
     rb_raise(rb_eNoMemError, "%s", error.what()); \
+  } \
+  catch (std::exception &error) { \
+    rb_raise(rb_eRuntimeError, "%s", error.what()); \
   }
 
 
@@ -42,9 +45,8 @@ inline VALUE current_user() {
 #include "query.h"
 #include "result.h"
 #include "statement.h"
-#include "request.h"
-#include "pool.h"
 #include "attribute.h"
+#include "datetime.h"
 
 #undef SIZET2NUM
 #ifdef HAVE_LONG_LONG

data/lib/swift/adapter/sql.rb

@@ -7,6 +7,15 @@ module Swift
     #
     # @abstract
     class Sql < Adapter
+      def tables
+        raise NotImplementedError
+      end
+
+      def fields table
+        result = execute("select * from #{table} limit 0")
+        Hash[result.fields.map(&:to_sym).zip(result.field_types)]
+      end
+
       protected
         def returning?
           raise NotImplementedError
@@ -57,7 +66,8 @@ module Swift
             when Type::Integer    then attribute.serial ? 'serial' : 'integer'
             when Type::Float      then 'float'
             when Type::BigDecimal then 'numeric'
-            when Type::Time       then 'timestamp'
+            when Type::Time       then 'timestamp' # deprecated
+            when Type::DateTime   then 'timestamp'
             when Type::Date       then 'date'
             when Type::Boolean    then 'boolean'
             when Type::IO         then 'blob'

data/lib/swift/db.rb

@@ -20,6 +20,10 @@ module Swift
           else super
         end
       end
+
+      def tables
+        execute("show tables").map(&:values).flatten
+      end
     end # Mysql
 
     class Sqlite3 < Adapter::Sql
@@ -47,13 +51,18 @@ module Swift
           when Type::Integer    then attribute.serial ? 'integer primary key' : 'integer'
           when Type::Float      then 'float'
           when Type::BigDecimal then 'numeric'
-          when Type::Time       then 'timestamp'
+          when Type::Time       then 'timestamp' # deprecated
+          when Type::DateTime   then 'timestamp'
           when Type::Date       then 'date'
           when Type::Boolean    then 'boolean'
           when Type::IO         then 'blob'
           else 'text'
         end
       end
+
+      def tables
+        execute('select name from sqlite_master where type = ?', 'table').map(&:values).flatten
+      end
     end # Sqlite3
 
     class Postgres < Adapter::Sql
@@ -71,6 +80,10 @@ module Swift
           else super
         end
       end
+
+      def tables
+        execute('select tablename from pg_tables where schemaname = current_schema').map(&:values).flatten
+      end
     end # Postgres
   end # DB
 end # Swift

data/lib/swift/type.rb

@@ -3,11 +3,18 @@ module Swift
     class BigDecimal < Attribute; end
     class Boolean    < Attribute; end
     class Date       < Attribute; end
-    class Time       < Attribute; end
+    class DateTime   < Attribute; end
     class Float      < Attribute; end
     class Integer    < Attribute; end
     class IO         < Attribute; end
     class String     < Attribute; end
+
+    # deprecated
+    class Time < Attribute
+      def initialize *args
+        warn "Swift::Type::Time is deprecated. Use Swift::Type::DateTime instead"
+        super
+      end
+    end
   end # Type
 end # Swift
-

data/lib/swift.rb

@@ -1,3 +1,12 @@
+# try to require home_run in older rubies
+unless %r{^1\.9\.[3-9]|^2\.}.match(RUBY_VERSION)
+  begin
+    require 'home_run'
+  rescue LoadError => e
+    warn "WARNING: DateTime parsing will be slow without home_run gem on Rubies older than 1.9.3"
+  end
+end
+
 # Extension.
 require_relative '../ext/swift'
 require_relative 'swift/adapter'
@@ -66,7 +75,6 @@ module Swift
     # @option options [String]  :password ('')
     # @option options [String]  :host     ('localhost')
     # @option options [Integer] :port     (DB default)
-    # @option options [String]  :timezone (*nix TZ format) See http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
     # @return [Swift::Adapter]
     #
     # @see Swift::DB

data/swift.gemspec

@@ -5,22 +5,22 @@
 
 Gem::Specification.new do |s|
   s.name = %q{swift}
-  s.version = "0.13.0"
+  s.version = "0.14.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Shane Hanna}, %q{Bharanee 'Barney' Rathna}]
-  s.date = %q{2011-11-16}
+  s.date = %q{2012-03-21}
   s.description = %q{A rational rudimentary database abstraction.}
   s.email = [%q{shane.hanna@gmail.com}, %q{deepfryed@gmail.com}]
   s.extensions = [%q{ext/extconf.rb}]
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     "API.rdoc",
     "LICENSE",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "ext/adapter.cc",
@@ -29,13 +29,11 @@ Gem::Specification.new do |s|
     "ext/adapter_io.h",
     "ext/attribute.cc",
     "ext/attribute.h",
+    "ext/datetime.cc",
+    "ext/datetime.h",
     "ext/extconf.rb",
-    "ext/pool.cc",
-    "ext/pool.h",
     "ext/query.cc",
     "ext/query.h",
-    "ext/request.cc",
-    "ext/request.h",
     "ext/result.cc",
     "ext/result.h",
     "ext/statement.cc",
@@ -50,7 +48,6 @@ Gem::Specification.new do |s|
     "lib/swift/header.rb",
     "lib/swift/identity_map.rb",
     "lib/swift/migrations.rb",
-    "lib/swift/pool.rb",
     "lib/swift/scheme.rb",
     "lib/swift/type.rb",
     "lib/swift/validations.rb",
@@ -59,11 +56,12 @@ Gem::Specification.new do |s|
     "test/house-explode.jpg",
     "test/minitest_teardown_hack.rb",
     "test/test_adapter.rb",
+    "test/test_async.rb",
+    "test/test_datetime_parser.rb",
     "test/test_encoding.rb",
     "test/test_error.rb",
     "test/test_identity_map.rb",
     "test/test_io.rb",
-    "test/test_pool.rb",
     "test/test_scheme.rb",
     "test/test_swift.rb",
     "test/test_timestamps.rb",
@@ -81,14 +79,11 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<minitest>, [">= 1.7.0"])
-      s.add_development_dependency(%q<eventmachine>, [">= 0"])
     else
       s.add_dependency(%q<minitest>, [">= 1.7.0"])
-      s.add_dependency(%q<eventmachine>, [">= 0"])
     end
   else
     s.add_dependency(%q<minitest>, [">= 1.7.0"])
-    s.add_dependency(%q<eventmachine>, [">= 0"])
   end
 end
 

data/test/test_adapter.rb

@@ -26,6 +26,12 @@ describe 'Adapter' do
         Swift.trace false
       end
 
+      it 'records closed state' do
+        assert !Swift.db.closed?
+        Swift.db.close
+        assert Swift.db.closed?
+      end
+
       describe 'execute' do
         it 'executes without bind values' do
           assert @db.execute %q{select count(*) from users}
@@ -114,10 +120,18 @@ describe 'Adapter' do
         end
       end
 
+      describe 'schema information' do
+        it 'should list tables' do
+          assert_equal %w(users), @db.tables
+        end
+
+        it 'should list fields in a table with types' do
+          expect = {id: 'integer', name: 'text', email: 'text', created_at: 'timestamp'}
+          assert_equal expect, @db.fields('users')
+        end
+      end
+
 
-      #--
-      # TODO: Not sure how I feel about the block in write; feels like it's just there to get around the fields in the
-      # argument list. How about write('users', %w{name, email, balance}, data)?
       describe 'bulk writes!' do
         it 'writes from an IO object' do
           data = StringIO.new "Sally Arthurton\tsally@local\nJonas Arthurton\tjonas@local\n"
@@ -130,7 +144,7 @@ describe 'Adapter' do
         end
 
         it 'writes with no columns specified' do
-          ts   = DateTime.parse('2010-01-01 00:00:00').to_time
+          ts   = DateTime.parse('2010-01-01 00:00:00')
           data = "1\tSally Arthurton\tsally@local\t#{ts}\n"
           row  = {id: 1, name: 'Sally Arthurton', email: 'sally@local', created_at: ts}