swift 0.6.1 → 0.7.0

data/ext/result.cc

@@ -1,26 +1,51 @@
 #include "result.h"
+#include <math.h>
 
 VALUE cBigDecimal;
-VALUE cDate;
-VALUE cDateTime;
 VALUE cStringIO;
 VALUE cSwiftResult;
 
-VALUE fNew, fNewBang;
+ID fnew, fto_date, fload;
 
-uint64_t epoch_ajd_n, epoch_ajd_d;
-VALUE daysecs, sg;
+void result_mark(ResultWrapper *handle) {
+  if (handle)
+    rb_gc_mark(handle->adapter);
+}
 
-void result_free(dbi::AbstractResultSet *result) {
-  if (result) {
-    result->cleanup();
-    delete result;
+void result_free(ResultWrapper *handle) {
+  if (handle) {
+    if (handle->free) {
+      handle->result->cleanup();
+      delete handle->result;
+    }
+    delete handle;
   }
 }
 
 VALUE result_alloc(VALUE klass) {
-  dbi::AbstractResultSet *result = 0;
-  return Data_Wrap_Struct(klass, 0, result_free, result);
+  ResultWrapper *handle = 0;
+  return Data_Wrap_Struct(klass, result_mark, result_free, handle);
+}
+
+VALUE result_wrap_handle(VALUE klass, VALUE adapter, dbi::AbstractResult *result, bool free) {
+  ResultWrapper *handle = new ResultWrapper;
+  handle->result  = result;
+  handle->adapter = adapter;
+  handle->free    = free;
+
+  VALUE obj = Data_Wrap_Struct(klass, result_mark, result_free, handle);
+  if (!NIL_P(adapter))
+    rb_iv_set(obj, "@timezone", rb_iv_get(adapter, "@timezone"));
+
+  return obj;
+}
+
+dbi::AbstractResult* result_handle(VALUE self) {
+  ResultWrapper *handle;
+  Data_Get_Struct(self, ResultWrapper, handle);
+  if (!handle) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super?");
+
+  return handle->result;
 }
 
 // TODO:
@@ -35,18 +60,20 @@ static VALUE result_dup(VALUE self) {
 
 VALUE result_each(VALUE self) {
   uint64_t length;
-  const char *data;
+  const char *data, *tzstring;
+
+  dbi::AbstractResult *result = result_handle(self);
+  VALUE scheme   = rb_iv_get(self, "@scheme");
+  VALUE timezone = rb_iv_get(self, "@timezone");
 
-  dbi::AbstractResultSet *result = result_handle(self);
-  VALUE scheme = rb_iv_get(self, "@scheme");
+  tzstring = NIL_P(timezone) ? 0 : CSTRING(timezone);
 
   try {
-    VALUE fields                      = rb_ary_new();
     std::vector<string> result_fields = result->fields();
     std::vector<int>    result_types  = result->types();
-    for (uint32_t i = 0; i < result_fields.size(); i++) {
-      rb_ary_push(fields, ID2SYM(rb_intern(result_fields[i].c_str())));
-    }
+    std::vector<VALUE>  fields;
+    for (uint32_t i = 0; i < result_fields.size(); i++)
+      fields.push_back(ID2SYM(rb_intern(result_fields[i].c_str())));
 
     result->seek(0);
     for (uint32_t row = 0; row < result->rows(); row++) {
@@ -56,15 +83,15 @@ VALUE result_each(VALUE self) {
         if (data) {
           rb_hash_aset(
             tuple,
-            rb_ary_entry(fields, column),
-            typecast_field(result_types[column], data, length)
+            fields[column],
+            typecast_field(result_types[column], data, length, tzstring)
           );
         }
         else {
-          rb_hash_aset(tuple, rb_ary_entry(fields, column), Qnil);
+          rb_hash_aset(tuple, fields[column], Qnil);
         }
       } // column loop
-      NIL_P(scheme) ? rb_yield(tuple) : rb_yield(rb_funcall(scheme, rb_intern("load"), 1, tuple));
+      NIL_P(scheme) ? rb_yield(tuple) : rb_yield(rb_funcall(scheme, fload, 1, tuple));
     } // row loop
   }
   CATCH_DBI_EXCEPTIONS();
@@ -72,16 +99,8 @@ VALUE result_each(VALUE self) {
   return Qnil;
 }
 
-dbi::AbstractResultSet* result_handle(VALUE self) {
-  dbi::AbstractResultSet *result;
-  Data_Get_Struct(self, dbi::AbstractResultSet, result);
-  if (!result) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super?");
-
-  return result;
-}
-
 static VALUE result_finish(VALUE self) {
-  dbi::AbstractResultSet *result = result_handle(self);
+  dbi::AbstractResult *result = result_handle(self);
   try {
     result->finish();
   }
@@ -96,31 +115,53 @@ int64_t client_tzoffset(int64_t local, int isdst) {
   return (int64_t)(local + (isdst ? 3600 : 0) - mktime(&tm));
 }
 
-// pinched from do_postgres
-static void reduce(uint64_t *numerator, uint64_t *denominator) {
-  uint64_t a, b, c;
-  a = *numerator;
-  b = *denominator;
-  while (a) {
-    c = a; a = b % a; b = c;
+// 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;
   }
-  *numerator   = *numerator   / b;
-  *denominator = *denominator / b;
-}
 
-VALUE typecast_timestamp(VALUE klass, const char *data, uint64_t len) {
-  struct tm tm;
-  int64_t epoch, adjust, offset;
+  // 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();
 
-  double usec = 0;
-  char tzsign = 0;
-  int tzhour  = 0, tzmin = 0;
+  return offset;
+}
+
+VALUE typecast_timestamp(const char *data, uint64_t len, const char *zone) {
+  struct   tm tm;
+  int64_t  epoch, adjust, offset;
+  uint64_t usec   = 0;
+  char     tzsign = 0, subsec[32];
+  int      tzhour = 0, tzmin = 0;
 
   memset(&tm, 0, sizeof(struct tm));
+  // Based on github.com/jeremyevans/sequel_pg. atoll & pow seem to be tad faster than sscanf %Lf
+  // NOTE: Reading subsec as string means malformed subsec > 32 digits could break this.
   if (strchr(data, '.')) {
-    sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%lf%c%02d:%02d",
-      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec,
-      &usec, &tzsign, &tzhour, &tzmin);
+    sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d.%s%c%02d:%02d",
+      &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec, subsec,
+      &tzsign, &tzhour, &tzmin);
+      usec = atoll(subsec)*(uint64_t)pow(10, 6 - strlen(subsec));
   }
   else {
     sscanf(data, "%04d-%02d-%02d %02d:%02d:%02d%c%02d:%02d",
@@ -136,53 +177,70 @@ VALUE typecast_timestamp(VALUE klass, const char *data, uint64_t len) {
     adjust = client_tzoffset(epoch, tm.tm_isdst);
     offset = adjust;
 
-    if (tzsign == '+' || tzsign == '-') {
+    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);
+    }
 
-    // 32bit platforms are for weenies
-    uint64_t ajd_n = (epoch + adjust - offset)*1000000 + usec*1000000, ajd_d = DAYMICROSECS;
-    reduce(&ajd_n, &ajd_d);
-    ajd_n = epoch_ajd_n*ajd_d  + ajd_n*epoch_ajd_d;
-    ajd_d = epoch_ajd_d*ajd_d;
-    reduce(&ajd_n, &ajd_d);
-
-    VALUE ajd = rb_rational_new(SIZET2NUM(ajd_n), SIZET2NUM(ajd_d));
-    return rb_funcall(klass, fNewBang, 3, ajd, rb_rational_new(INT2FIX(adjust), daysecs), sg);
+    return rb_time_new(epoch+adjust-offset, usec);
   }
 
-  // TODO: throw a warning ?
+  printf("WARNING: Unable to parse timestamp value '%s'\n", data);
   return rb_str_new(data, len);
 }
 
-#define typecast_datetime(data,len) typecast_timestamp(cDateTime, data, len)
-#define typecast_date(data,len)     typecast_timestamp(cDate,     data, len)
+#define typecast_date(data,len,tz)   rb_funcall(typecast_timestamp(data,len,tz), fto_date, 0)
 
-VALUE typecast_field(int type, const char *data, uint64_t length) {
+/*
+  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) {
   switch(type) {
     case DBI_TYPE_BOOLEAN:
       return (data && (data[0] =='t' || data[0] == '1')) ? Qtrue : Qfalse;
     case DBI_TYPE_INT:
       return rb_cstr2inum(data, 10);
     case DBI_TYPE_BLOB:
-      return rb_funcall(cStringIO, fNew, 1, rb_str_new(data, length));
-    case DBI_TYPE_TEXT:
-      return rb_enc_str_new(data, length, rb_utf8_encoding());
-    case DBI_TYPE_TIME:
-      return typecast_datetime(data, length);
+      return rb_funcall(cStringIO, fnew, 1, rb_str_new(data, length));
+    case DBI_TYPE_TIMESTAMP:
+      return typecast_timestamp(data, length, timezone);
     case DBI_TYPE_DATE:
-      return typecast_date(data, length);
+      return typecast_date(data, length, timezone);
     case DBI_TYPE_NUMERIC:
-      return rb_funcall(cBigDecimal, fNew, 1, rb_str_new2(data));
+      return rb_funcall(cBigDecimal, fnew, 1, rb_str_new2(data));
     case DBI_TYPE_FLOAT:
       return rb_float_new(atof(data));
+
+    // DBI_TYPE_TIME
+    // DBI_TYPE_TEXT
+    default:
+      return rb_enc_str_new(data, length, rb_utf8_encoding());
   }
 }
 
 VALUE result_insert_id(VALUE self) {
-  dbi::AbstractResultSet *result = result_handle(self);
+  dbi::AbstractResult *result = result_handle(self);
   try {
     return SIZET2NUM(result->lastInsertID());
   }
@@ -191,7 +249,7 @@ VALUE result_insert_id(VALUE self) {
 }
 
 VALUE result_rows(VALUE self) {
-  dbi::AbstractResultSet *result = result_handle(self);
+  dbi::AbstractResult *result = result_handle(self);
   try {
     return SIZET2NUM(result->rows());
   }
@@ -199,7 +257,7 @@ VALUE result_rows(VALUE self) {
 }
 
 VALUE result_columns(VALUE self) {
-  dbi::AbstractResultSet *result = result_handle(self);
+  dbi::AbstractResult *result = result_handle(self);
   try {
     return SIZET2NUM(result->columns());
   }
@@ -207,7 +265,7 @@ VALUE result_columns(VALUE self) {
 }
 
 VALUE result_fields(VALUE self) {
-  dbi::AbstractResultSet *result = result_handle(self);
+  dbi::AbstractResult *result = result_handle(self);
   try {
     std::vector<string> result_fields = result->fields();
     VALUE fields = rb_ary_new();
@@ -225,13 +283,12 @@ void init_swift_result() {
 
   VALUE mSwift = rb_define_module("Swift");
   cSwiftResult = rb_define_class_under(mSwift, "Result", rb_cObject);
-  cDateTime    = CONST_GET(rb_mKernel, "DateTime");
-  cDate        = CONST_GET(rb_mKernel, "Date");
   cStringIO    = CONST_GET(rb_mKernel, "StringIO");
   cBigDecimal  = CONST_GET(rb_mKernel, "BigDecimal");
 
-  fNew         = rb_intern("new");
-  fNewBang     = rb_intern("new!");
+  fnew         = rb_intern("new");
+  fto_date     = rb_intern("to_date");
+  fload        = rb_intern("load");
 
   rb_define_alloc_func(cSwiftResult, result_alloc);
   rb_include_module(cSwiftResult, CONST_GET(rb_mKernel, "Enumerable"));
@@ -244,11 +301,5 @@ void init_swift_result() {
   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);
-
-  // typecast_datetime setup.
-  epoch_ajd_d = 2;
-  epoch_ajd_n = 4881175L;            // 1970-01-01 00:00:00 is 2440587.5 in ajd
-  daysecs     = SIZET2NUM(86400L);
-  sg          = SIZET2NUM(2299161L); // day of calendar reform Date::ITALY
 }
 

data/ext/result.h

@@ -3,15 +3,25 @@
 
 #include "swift.h"
 
+struct ResultWrapper {
+  dbi::AbstractResult *result;
+  VALUE adapter;
+  bool free;
+};
+
 extern VALUE cSwiftResult;
 extern VALUE cStringIO;
 
 void init_swift_result();
-void result_free(dbi::AbstractResultSet*);
+
+void  result_free(ResultWrapper *);
+void  result_mark(ResultWrapper *);
+
+VALUE result_wrap_handle(VALUE, VALUE, dbi::AbstractResult *, bool free);
+dbi::AbstractResult* result_handle(VALUE);
+
 VALUE result_each(VALUE);
-dbi::AbstractResultSet* result_handle(VALUE);
 
-VALUE typecast_field(int, const char*, uint64_t);
-VALUE typecast_datetime(const char*, uint64_t);
+VALUE typecast_field(int, const char*, uint64_t, const char*);
 
 #endif

data/ext/statement.cc

@@ -5,24 +5,45 @@
 
 VALUE cSwiftStatement;
 
-void statement_free(dbi::AbstractStatement *statement) {
-  if (statement) {
-    statement->cleanup();
-    delete statement;
+void statement_mark(StatementWrapper *handle) {
+  if (handle)
+    rb_gc_mark(handle->adapter);
+}
+
+void statement_free(StatementWrapper *handle) {
+  if (handle) {
+    if (handle->free) {
+      handle->statement->cleanup();
+      delete handle->statement;
+    }
+    delete handle;
   }
 }
 
 VALUE statement_alloc(VALUE klass) {
-  dbi::AbstractStatement *statement = 0;
-  return Data_Wrap_Struct(klass, 0, statement_free, statement);
+  StatementWrapper *handle = 0;
+  return Data_Wrap_Struct(klass, statement_mark, statement_free, handle);
+}
+
+VALUE statement_wrap_handle(VALUE klass, VALUE adapter, dbi::AbstractStatement *statement) {
+  StatementWrapper *handle = new StatementWrapper;
+  handle->statement = statement;
+  handle->adapter   = adapter;
+  handle->free      = true;
+
+  VALUE obj = Data_Wrap_Struct(klass, statement_mark, statement_free, handle);
+  if (!NIL_P(adapter))
+    rb_iv_set(obj, "@timezone", rb_iv_get(adapter, "@timezone"));
+
+  return obj;
 }
 
 dbi::AbstractStatement* statement_handle(VALUE self) {
-  dbi::AbstractStatement *handle;
-  Data_Get_Struct(self, dbi::AbstractStatement, handle);
+  StatementWrapper *handle;
+  Data_Get_Struct(self, StatementWrapper, handle);
   if (!handle) rb_raise(eSwiftRuntimeError, "Invalid object, did you forget to call #super?");
 
-  return handle;
+  return handle->statement;
 }
 
 // TODO: Change bind_values to an array in the interface? Avoid array -> splat -> array.
@@ -34,7 +55,7 @@ static VALUE statement_execute(int argc, VALUE *argv, VALUE self) {
   try {
     Query query;
     query.statement = statement;
-    if (RARRAY_LEN(bind_values) > 0) query_bind_values(&query, bind_values);
+    if (RARRAY_LEN(bind_values) > 0) query_bind_values(&query, bind_values, statement->driver());
     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)
@@ -53,7 +74,13 @@ VALUE statement_initialize(VALUE self, VALUE adapter, VALUE sql) {
   if (NIL_P(sql))     rb_raise(eSwiftArgumentError, "Statement#new called without a command.");
 
   try {
-    DATA_PTR(self) = handle->conn()->prepare(CSTRING(sql));
+    // needs to happen before wrapping in case it raises errors.
+    dbi::AbstractStatement *statement  = handle->conn()->prepare(CSTRING(sql));
+    StatementWrapper *statement_handle = new StatementWrapper;
+    statement_handle->statement        = statement;
+    statement_handle->adapter          = adapter;
+    statement_handle->free             = true;
+    DATA_PTR(self)                     = statement_handle;
   }
   CATCH_DBI_EXCEPTIONS();
 

data/ext/statement.h

@@ -3,10 +3,20 @@
 
 #include "swift.h"
 
+struct StatementWrapper {
+  dbi::AbstractStatement *statement;
+  VALUE adapter;
+  bool free;
+};
+
 extern VALUE cSwiftStatement;
 
 void init_swift_statement();
-void statement_free(dbi::AbstractStatement*);
+void statement_free(StatementWrapper *);
+void statement_mark(StatementWrapper *);
+
+VALUE statement_wrap_handle(VALUE, VALUE, dbi::AbstractStatement *);
+dbi::AbstractStatement* statement_handle(VALUE);
 
 #endif
 

data/ext/swift.cc

@@ -7,10 +7,6 @@ VALUE eSwiftArgumentError;
 VALUE eSwiftRuntimeError;
 VALUE eSwiftConnectionError;
 
-VALUE rb_special_constant(VALUE self, VALUE obj) {
-  return rb_special_const_p(obj) ? Qtrue : Qfalse;
-}
-
 VALUE swift_init(VALUE self, VALUE path) {
   try { dbi::dbiInitialize(CSTRING(path)); } CATCH_DBI_EXCEPTIONS();
   return Qtrue;
@@ -35,6 +31,15 @@ VALUE swift_trace(int argc, VALUE *argv, VALUE self) {
     return flag;
 }
 
+VALUE atexit_gc(...) {
+  rb_gc();
+  return Qnil;
+}
+
+void atexit_caller(VALUE data) {
+  rb_proc_call(data, rb_ary_new());
+}
+
 extern "C" {
   void Init_swift(void) {
     mSwift = rb_define_module("Swift");
@@ -45,14 +50,21 @@ extern "C" {
     eSwiftConnectionError = rb_define_class("SwiftConnectionError", eSwiftError);
 
     init_swift_adapter();
+    init_swift_attribute();
+    init_swift_pool();
+    init_swift_request();
     init_swift_result();
     init_swift_statement();
-    init_swift_request();
-    init_swift_pool();
+    init_swift_query();
 
     rb_define_module_function(mSwift, "init",  RUBY_METHOD_FUNC(swift_init), 1);
     rb_define_module_function(mSwift, "trace", RUBY_METHOD_FUNC(swift_trace), -1);
-    rb_define_module_function(mSwift, "special_constant?", RUBY_METHOD_FUNC(rb_special_constant), 1);
+
+    // NOTE
+    // Swift adapter and statement objects need to be deallocated or garbage collected in the reverse
+    // allocation order. rb_gc() does that but gc at exit time seems to do it in allocation order which
+    // stuffs up dbic++ destructors.
+    rb_set_end_proc(atexit_caller, rb_proc_new(atexit_gc, mSwift));
   }
 }
 

data/ext/swift.h

@@ -30,6 +30,7 @@ extern VALUE eSwiftConnectionError;
 #include "statement.h"
 #include "request.h"
 #include "pool.h"
+#include "attribute.h"
 
 #undef SIZET2NUM
 #ifdef HAVE_LONG_LONG

data/lib/swift/adapter.rb

@@ -53,10 +53,14 @@ module Swift
       fields =  scheme.header.map{|p| field_definition(p)}.join(', ')
       fields += ", primary key (#{keys.join(', ')})" unless keys.empty?
 
-      execute("drop table if exists #{scheme.store}")
+      drop_store scheme.store
       execute("create table #{scheme.store} (#{fields})")
     end
 
+    def drop_store name
+      execute("drop table if exists #{name}")
+    end
+
     protected
       def exchange_names scheme, query
         query.gsub(/:(\w+)/){ scheme.send($1.to_sym).field }
@@ -102,12 +106,17 @@ module Swift
       end
 
       def field_definition attribute
-        "#{attribute.field} " + case attribute
+        "#{attribute.field} " + field_type(attribute)
+      end
+
+      def field_type attribute
+        case attribute
           when Type::String     then 'text'
           when Type::Integer    then attribute.serial ? 'serial' : 'integer'
           when Type::Float      then 'float'
           when Type::BigDecimal then 'numeric'
-          when Type::DateTime   then 'timestamp'
+          when Type::Time       then 'timestamp'
+          when Type::Date       then 'date'
           when Type::Boolean    then 'boolean'
           when Type::IO         then 'blob'
           else 'text'

data/lib/swift/attribute.rb

@@ -1,26 +1,18 @@
 module Swift
+  #--
+  # NOTE: Default method is defined in the extension.
   class Attribute
     attr_reader :name, :field, :key, :serial
 
     def initialize scheme, name, options = {}
-      @name      = name
-      @default   = options.fetch(:default, nil)
-      @field     = options.fetch(:field,   name)
-      @key       = options.fetch(:key,     false)
-      @serial    = options.fetch(:serial,  false)
+      @name    = name
+      @default = options.fetch(:default, nil)
+      @field   = options.fetch(:field,   name)
+      @key     = options.fetch(:key,     false)
+      @serial  = options.fetch(:serial,  false)
       define_scheme_methods(scheme)
     end
 
-    def default
-      if @default.respond_to?(:call)
-        @default.call
-      elsif Swift.special_constant?(@default)
-        @default
-      else
-        @default.dup
-      end
-    end
-
     def define_scheme_methods scheme
       scheme.class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name};        tuple.fetch(:#{field}, nil)   end

data/lib/swift/db.rb

@@ -19,12 +19,51 @@ module Swift
         true
       end
 
-      def field_definition attribute
+      def field_type attribute
         case attribute
-          when Type::IO then '%s bytea' % attribute.field
+          when Type::IO then 'bytea'
           else super
         end
       end
     end # Postgres
+
+    class DB2 < Adapter
+      def initialize options = {}
+        super options.update(driver: 'db2')
+      end
+
+      def returning?
+        false
+      end
+
+      def drop_store name
+        exists_sql =<<-SQL
+          select count(*) as exists from syscat.tables where tabschema = CURRENT_SCHEMA and tabname = '#{name.upcase}'
+        SQL
+
+        execute(exists_sql.strip) do |r|
+          execute("drop table #{name}") if r[:exists] > 0
+        end
+      end
+
+      def field_type attribute
+        case attribute
+          when Type::String     then 'clob(2g)'
+          when Type::Integer    then attribute.serial ? 'integer not null generated by default as identity' : 'integer'
+          when Type::Boolean    then 'char(1)'
+          when Type::Float      then 'real'
+          when Type::BigDecimal then 'double'
+          else super
+        end
+      end
+
+      def prepare_create scheme
+        prepare_cached(scheme, :create) do
+          values = (['?'] * scheme.header.insertable.size).join(', ')
+          sql    = "insert into #{scheme.store} (#{scheme.header.insertable.join(', ')}) values (#{values})"
+          scheme.header.serial ? "select #{scheme.header.serial} from final table (#{sql})" : sql
+        end
+      end
+    end # DB2
   end # DB
 end # Swift