swift 0.13.0 → 0.14.0

data/API.rdoc

@@ -12,17 +12,18 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
 
     # Abstract.
     Adapter
-      .new         #=> Adapter
-      #begin       #=> Adapter
+      .new           #=> Adapter
+      #begin         #=> Adapter
       #commit
-      #create      #=> Scheme or Result
-      #delete      #=> Result
-      #execute     #=> Result
-      #get         #=> Scheme
-      #prepare     #=> Statement
+      #create        #=> Scheme or Result
+      #delete        #=> Result
+      #execute       #=> Result
+      #async_execute #=> Result
+      #get           #=> Scheme
+      #prepare       #=> Statement
       #rollback
-      #transaction #=> Adapter
-      #update      #=> Scheme or Result
+      #transaction   #=> Adapter
+      #update        #=> Scheme or Result
       #reconnect
 
     # Concrete.
@@ -33,9 +34,12 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
 
     # Enumerable collection of Scheme or Hash tuples.
     Result
-      .new       #=> Result
-      #insert_id #=> Numeric
-      #fields    #=> [Symbol, ...] # Field names identical to .first.keys if rows > 0
+      .new         #=> Result
+      #insert_id   #=> Numeric
+      #fields      #=> [Symbol, ...] # Field names identical to .first.keys if rows > 0
+      #field_types #=> [String, ...] # Type names: boolean, integer, float, numeric, timestamp, date, time, blob, text
+      #rows        #=> Fixnum
+      #columns     #=> Fixnum
 
     Statement
       .new     #=> Statement

data/{README.rdoc → README.md}

@@ -1,31 +1,39 @@
-= Swift
+Swift
+=====
 
-* http://github.com/shanna/swift
+* [source](http://github.com/shanna/swift)
+* [documentation](http://rubydoc.info/gems/swift/file/README.md)
 
-== Description
+## Description
 
 A rational rudimentary object relational mapper.
 
-== Dependencies
+## Dependencies
 
 * ruby   >= 1.9.1
-* dbic++ >= 0.5.9 (http://github.com/deepfryed/dbicpp)
+* [dbic++](http://github.com/deepfryed/dbicpp) >= 0.6.0
 * mysql  >= 5.0.17, postgresql >= 8.4 or sqlite3 >= 3.7
 
-== Features
+## Features
 
 * Multiple databases.
 * Prepared statements.
 * Bind values.
 * Transactions and named save points.
-* EventMachine asynchronous interface (mysql and postgresql).
+* Asynchronous API for PostgreSQL and MySQL.
 * IdentityMap.
 * Migrations.
 
-== Synopsis
+## Performance notes
 
-=== DB
+1. The current version creates DateTime objects for timestamp fields and this is roughly 80% slower on
+   rubies older than 1.9.3.
+2. On rubies older than 1.9.3, Swift will try using [home_run](https://github.com/jeremyevans/home_run)
+   for performance.
 
+### DB
+
+```ruby
   require 'swift'
 
   Swift.trace true # Debugging.
@@ -52,12 +60,14 @@ A rational rudimentary object relational mapper.
     result = db.prepare('select * from users where name like ?').execute('Benny%')
     puts result.first
   end
+```
 
-=== DB Scheme Operations
+### DB Scheme Operations
 
 Rudimentary object mapping. Provides a definition to the db methods for prepared (and cached) statements plus native
 primitive Ruby type conversion.
 
+```ruby
   require 'swift'
   require 'swift/migrations'
 
@@ -69,7 +79,7 @@ primitive Ruby type conversion.
     attribute :id,         Swift::Type::Integer, serial: true, key: true
     attribute :name,       Swift::Type::String
     attribute :email,      Swift::Type::String
-    attribute :updated_at, Swift::Type::Time
+    attribute :updated_at, Swift::Type::DateTime
   end # User
 
   Swift.db do |db|
@@ -86,11 +96,13 @@ primitive Ruby type conversion.
     user = db.get(User, id: 1)
     puts user.name, user.email
   end
+```
 
-=== Scheme CRUD
+### Scheme CRUD
 
 Scheme/relation level helpers.
 
+```ruby
   require 'swift'
   require 'swift/migrations'
 
@@ -122,12 +134,14 @@ Scheme/relation level helpers.
 
   # Destroy
   user.delete
+```
 
-=== Conditions SQL syntax.
+### Conditions SQL syntax.
 
 SQL is easy and most people know it so Swift ORM provides simple #to_s
-attribute to field name typecasting.
+attribute to table and field name typecasting.
 
+```ruby
   class User < Swift::Scheme
     store     :users
     attribute :id,    Swift::Type::Integer, serial: true, key: true
@@ -142,11 +156,13 @@ attribute to field name typecasting.
     %Q{select * from #{User} where #{User.name} like ? and #{User.age} > ?},
     '%Arthurton', 20
   )
+```
 
-=== Identity Map
+### Identity Map
 
 Swift comes with a simple identity map. Just require it after you load swift.
 
+```ruby
   require 'swift'
   require 'swift/identity_map'
   require 'swift/migrations'
@@ -168,8 +184,9 @@ Swift comes with a simple identity map. Just require it after you load swift.
   find_user = User.prepare(%Q{select * from #{User} where #{User.name = ?})
   find_user.execute('James Arthurton')
   find_user.execute('James Arthurton') # Gets same object reference
+```
 
-=== Bulk inserts
+### Bulk inserts
 
 Swift comes with adapter level support for bulk inserts for MySQL and PostgreSQL. This
 is usually very fast (~5-10x faster) than regular prepared insert statements for larger
@@ -178,10 +195,13 @@ sets of data.
 MySQL adapter - Overrides the MySQL C API and implements its own _infile_ handlers. This
 means currently you *cannot* execute the following SQL using Swift
 
+```sql
   LOAD DATA LOCAL INFILE '/tmp/users.tab' INTO TABLE users;
+```
 
 But you can do it almost as fast in ruby,
 
+```ruby
   require 'swift'
 
   Swift.setup :default, Swift::DB::Mysql, db: 'swift'
@@ -192,23 +212,82 @@ But you can do it almost as fast in ruby,
       count = db.write('users', %w{name email balance}, file)
     end
   end
+```
 
 You are not just limited to files - you can stream data from anywhere into your database without
 creating temporary files.
 
-== Performance
+### Asynchronous API
+
+`Swift::Adapter#async_execute` returns a `Swift::Result` instance. You can either poll the corresponding
+`Swift::Adapter#fileno` and then call `Swift::Result#retrieve` when ready or use a block form like below
+which implicitly uses `rb_thread_wait_fd`
+
+```ruby
+  require 'swift'
+
+  pool = 3.times.map.with_index {|n| Swift.setup n, Swift::DB::Postgres, db: 'swift' }
+
+  Thread.new do
+    pool[0].async_execute('select pg_sleep(3), 1 as qid') {|row| p row}
+  end
+
+  Thread.new do
+    pool[1].async_execute('select pg_sleep(2), 2 as qid') {|row| p row}
+  end
+
+  Thread.new do
+    pool[2].async_execute('select pg_sleep(1), 3 as qid') {|row| p row}
+  end
+
+  Thread.list.reject {|thread| Thread.current == thread}.each(&:join)
+```
+
+```ruby
+  require 'swift'
+  require 'eventmachine'
+  
+  pool = 3.times.map.with_index {|n| Swift.setup n, Swift::DB::Postgres, db: 'swift'}
+  
+  module Handler
+    attr_reader :result
+  
+    def initialize result
+      @result = result
+    end
+  
+    def notify_readable
+      result.retrieve
+      result.each {|row| p row }
+      unbind
+    end
+  end
+  
+  EM.run do
+    EM.watch(pool[0].fileno, Handler, pool[0].async_execute('select pg_sleep(3), 1 as qid')){|c| c.notify_readable = true}
+    EM.watch(pool[1].fileno, Handler, pool[1].async_execute('select pg_sleep(2), 2 as qid')){|c| c.notify_readable = true}
+    EM.watch(pool[2].fileno, Handler, pool[2].async_execute('select pg_sleep(1), 3 as qid')){|c| c.notify_readable = true}
+    EM.add_timer(4) { EM.stop }
+  end
+```
+
+## Performance
 
 Swift prefers performance when it doesn't compromise the Ruby-ish interface. It's unfair to compare Swift to DataMapper
 and ActiveRecord which suffer under the weight of support for many more databases and legacy/alternative Ruby
 implementations. That said obviously if Swift were slower it would be redundant so benchmark code does exist in
 http://github.com/shanna/swift/tree/master/benchmarks
 
-=== Benchmarks
+### Benchmarks
+
+#### ORM
 
-==== ORM
+The test environment:
 
-The following bechmarks were run on a machine with 4G ram, 5200rpm sata drive,
-Intel Core2Duo P8700 2.53GHz and stock PostgreSQL 8.4.1.
+* ruby 1.9.3p0
+* Intel Core2Duo P8700 2.53GHz, 4G RAM and Kingston SATA2 SSD
+
+The test setup:
 
 * 10,000 rows are created once.
 * All the rows are selected once.
@@ -218,63 +297,38 @@ Intel Core2Duo P8700 2.53GHz and stock PostgreSQL 8.4.1.
   objects allocated and the pressure on Ruby GC if it were running. When GC is enabled,
   the actual memory consumption might be much lower than the numbers below.
 
-
+```
     ./simple.rb -n1 -r10000 -s ar -s dm -s sequel -s swift
 
-    benchmark       sys     user    total  real     rss
-    ar #create      1.01    7.91    8.92   11.426   406.22m
-    ar #select      0.02    0.31    0.33    0.378    40.69m
-    ar #update      0.88    9.64   10.52   13.908   504.93m
+    benchmark       sys     user    total  real      rss
+    ar #create      0.75    7.18    7.93   10.5043   366.95m
+    ar #select      0.07    0.26    0.33    0.3680    40.71m
+    ar #update      0.96    7.92    8.88   11.7537   436.38m
 
-    dm #create      0.23    3.52    3.75    5.405   211.00m
-    dm #select      0.11    1.67    1.78    1.912   114.57m
-    dm #update      0.54    7.34    7.88    9.453   531.30m
+    dm #create      0.33    3.73    4.06    5.0908   245.68m
+    dm #select      0.08    1.51    1.59    1.6154    87.95m
+    dm #update      0.44    7.09    7.53    8.8685   502.77m
 
-    sequel #create  0.77    4.61    5.38    8.194   235.50m
-    sequel #select  0.01    0.13    0.14    0.180    12.73m
-    sequel #update  0.64    4.76    5.40    7.790   229.69m
+    sequel #create  0.60    5.07    5.67    7.9804   236.69m
+    sequel #select  0.02    0.12    0.14    0.1778    12.75m
+    sequel #update  0.82    4.95    5.77    8.2062   230.00m
 
-    swift #create   0.13    0.66    0.79    1.463    85.77m
-    swift #select   0.01    0.10    0.11    0.135     8.92m
-    swift #update   0.14    0.75    0.89    1.585    59.56m
+    swift #create   0.27    0.59    0.86    1.5085    84.85m
+    swift #select   0.03    0.06    0.09    0.1037    11.24m
+    swift #update   0.20    0.69    0.89    1.5867    62.19m
 
     -- bulk insert api --
-    swift #write    0.00    0.10    0.10    0.180    14.79m
-
-
-==== Adapter
+    swift #write    0.04    0.06    0.10    0.1699    14.05m
+```
 
-The adapter level SELECT benchmarks without using ORM.
-
-* Same dataset as above.
-* All rows are selected 5 times.
-* The pg benchmark uses pg_typecast gem to provide typecasting support
-  for pg gem and also makes the benchmarks more fair.
-
-===== PostgreSQL
-
-    benchmark       sys       user      total     real      rss
-    do #select      0.020000  1.250000  1.270000  1.441281  71.98m
-    pg #select      0.000000  0.580000  0.580000  0.769186  42.93m
-    swift #select   0.040000  0.510000  0.550000  0.627581  43.23m
-
-===== MySQL
-
-    benchmark       sys       user      total     real      rss
-    do #select      0.030000  1.130000  1.160000  1.172205  71.86m
-    mysql2 #select  0.040000  0.660000  0.700000  0.704414  72.72m
-    swift #select   0.010000  0.480000  0.490000  0.499643  42.03m
-
-== TODO
+## TODO
 
 * More tests.
 * Assertions for dumb stuff.
+* Auto-generate schema?
+* Move examples to Wiki. Examples of models built on top of Schema.
 
-== Contributing
+## Contributing
 
 Go nuts! There is no style guide and I do not care if you write tests or comment code. If you write something neat just
 send a pull request, tweet, email or yell it at me line by line in person.
-
-== Feature suggestions and support
-
-{Suggest features and support Swift ORM on fundry.}[https://fundry.com/project/14-swift-orm]

data/Rakefile

@@ -13,7 +13,6 @@ begin
     gem.files.reject!{|f| f =~ %r{\.gitignore|examples|benchmarks|memory/.*}}
 
     gem.add_development_dependency 'minitest', '>= 1.7.0'
-    gem.add_development_dependency 'eventmachine'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.13.0
+0.14.0

data/ext/adapter.cc

@@ -1,4 +1,7 @@
+// vim:ts=2:sts=2:sw=2:expandtab
+
 #include "adapter.h"
+#include "sys/select.h"
 
 // Extend the default dbi::FieldSet class with some ruby love.
 class Fields : public dbi::FieldSet {
@@ -71,9 +74,21 @@ static VALUE adapter_begin(int argc, VALUE *argv, VALUE self) {
 static VALUE adapter_close(VALUE self) {
   dbi::Handle *handle = adapter_handle(self);
   try { handle->close(); } CATCH_DBI_EXCEPTIONS();
+  rb_iv_set(self, "@closed", true);
   return Qtrue;
 }
 
+
+/*
+  Check if connection is closed.
+*/
+static VALUE adapter_closed(VALUE self) {
+  return rb_iv_get(self, "@closed");
+}
+
+
+
+
 /*
   Shallow copy of adapter.
 
@@ -166,7 +181,7 @@ static VALUE adapter_execute(int argc, VALUE *argv, VALUE self) {
     if (dbi::_trace)                 dbi::logMessage(dbi::_trace_fd, dbi::formatParams(query.sql, query.bind));
 
     if ((rows = rb_thread_blocking_region(((VALUE (*)(void*))query_execute), &query, RUBY_UBF_IO, 0)) == Qfalse)
-      rb_raise(eSwiftRuntimeError, "%s", query.error);
+      rb_raise(query.error_klass, "%s", query.error_message);
 
     VALUE result = result_wrap_handle(cSwiftResult, self, handle->conn()->result(), true);
     if (!NIL_P(scheme))
@@ -181,7 +196,11 @@ static VALUE adapter_execute(int argc, VALUE *argv, VALUE self) {
 */
 static VALUE adapter_reconnect(VALUE self) {
   dbi::Handle *handle = adapter_handle(self);
-  try { handle->reconnect(); } CATCH_DBI_EXCEPTIONS();
+  try {
+    handle->reconnect();
+    rb_iv_set(self, "@closed", false);
+  }
+  CATCH_DBI_EXCEPTIONS();
   return Qtrue;
 }
 
@@ -202,7 +221,6 @@ static VALUE adapter_reconnect(VALUE self) {
     @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
@@ -225,7 +243,6 @@ static VALUE adapter_initialize(VALUE self, VALUE options) {
   rb_hash_delete(extra, ID2SYM(rb_intern("password")));
   rb_hash_delete(extra, ID2SYM(rb_intern("host")));
   rb_hash_delete(extra, ID2SYM(rb_intern("port")));
-  rb_hash_delete(extra, ID2SYM(rb_intern("timezone")));
 
   std::string extra_options_string = parse_extra_options(extra);
 
@@ -243,7 +260,6 @@ static VALUE adapter_initialize(VALUE self, VALUE options) {
   CATCH_DBI_EXCEPTIONS();
 
   rb_iv_set(self, "@options",  options);
-  rb_iv_set(self, "@timezone", rb_hash_aref(options, ID2SYM(rb_intern("timezone"))));
 
   return Qnil;
 }
@@ -377,6 +393,64 @@ static VALUE adapter_write(int argc, VALUE *argv, VALUE self) {
   CATCH_DBI_EXCEPTIONS();
 }
 
+/*
+  Returns the socket fileno for the connection.
+
+  @overload fileno()
+    @return [Fixnum]
+*/
+VALUE adapter_fileno(VALUE self) {
+  dbi::Handle *handle = adapter_handle(self);
+  return INT2NUM(handle->conn()->socket());
+}
+
+/*
+  Executes a query asynchronously and returns the result instance.
+
+  @example
+
+  @overload async_execute(statement = '', *binds, &block)
+    @param  [String]  statement Query statement.
+    @param  [*Object] binds     Bind values.
+    @return [Swift::Result]
+*/
+VALUE adapter_async_execute(int argc, VALUE *argv, VALUE self) {
+  VALUE statement, bind_values, block, scheme = Qnil, result;
+
+  dbi::Handle *handle = adapter_handle(self);
+  rb_scan_args(argc, argv, "1*&", &statement, &bind_values, &block);
+
+  if (TYPE(statement) == T_CLASS) {
+    scheme    = statement;
+    statement = rb_ary_shift(bind_values);
+  }
+
+  try {
+    dbi::AbstractResult *dbi_result;
+    if (RARRAY_LEN(bind_values) > 0) {
+      Query query;
+      query_bind_values(&query, bind_values);
+      dbi_result = handle->conn()->aexecute(CSTRING(statement), query.bind);
+    }
+    else
+      dbi_result = handle->conn()->aexecute(CSTRING(statement));
+
+    result = result_wrap_handle(cSwiftResult, self, dbi_result, true);
+    if (!NIL_P(scheme))
+      rb_iv_set(result, "@scheme", scheme);
+
+    // if block given, just use rb_thread_select
+    if (rb_block_given_p()) {
+      rb_thread_wait_fd(handle->socket());
+      while (dbi_result->consumeResult());
+      dbi_result->prepareResult();
+    }
+  }
+  CATCH_DBI_EXCEPTIONS();
+
+  return rb_block_given_p() ? result_each(result) : result;
+}
+
 void init_swift_adapter() {
   VALUE mSwift   = rb_define_module("Swift");
   cSwiftAdapter = rb_define_class_under(mSwift, "Adapter", rb_cObject);
@@ -384,6 +458,7 @@ void init_swift_adapter() {
   rb_define_method(cSwiftAdapter, "begin",       RUBY_METHOD_FUNC(adapter_begin),       -1);
   rb_define_method(cSwiftAdapter, "clone",       RUBY_METHOD_FUNC(adapter_clone),        0);
   rb_define_method(cSwiftAdapter, "close",       RUBY_METHOD_FUNC(adapter_close),        0);
+  rb_define_method(cSwiftAdapter, "closed?",     RUBY_METHOD_FUNC(adapter_closed),       0);
   rb_define_method(cSwiftAdapter, "commit",      RUBY_METHOD_FUNC(adapter_commit),      -1);
   rb_define_method(cSwiftAdapter, "dup",         RUBY_METHOD_FUNC(adapter_dup),          0);
   rb_define_method(cSwiftAdapter, "escape",      RUBY_METHOD_FUNC(adapter_escape),       1);
@@ -395,6 +470,10 @@ void init_swift_adapter() {
   rb_define_method(cSwiftAdapter, "write",       RUBY_METHOD_FUNC(adapter_write),       -1);
   rb_define_method(cSwiftAdapter, "reconnect",   RUBY_METHOD_FUNC(adapter_reconnect),    0);
 
+  // stuff you need for async
+  rb_define_method(cSwiftAdapter, "fileno",         RUBY_METHOD_FUNC(adapter_fileno),         0);
+  rb_define_method(cSwiftAdapter, "async_execute",  RUBY_METHOD_FUNC(adapter_async_execute), -1);
+
   rb_define_alloc_func(cSwiftAdapter, adapter_alloc);
 }
 

data/ext/datetime.cc

@@ -0,0 +1,96 @@
+#include "datetime.h"
+
+extern VALUE dtformat;
+
+VALUE cSwiftDateTime, day_seconds;
+ID fcivil, fparse, fstrptime;
+
+// NOTE: only parses '%F %T.%N %z' format and falls back to the built-in DateTime#parse
+//       and is almost 2x faster than doing:
+//
+//       rb_funcall(klass, fstrptime, 2, rb_str_new(data, size), dtformat);
+//
+VALUE datetime_parse(VALUE klass, const char *data, uint64_t size) {
+  struct tm tm;
+  double seconds;
+  const char *ptr;
+  char tzsign = 0, fraction[32];
+  int  tzhour = 0, tzmin = 0, lastmatch = -1, offset = 0, idx;
+
+  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);
+
+  // fallback to default datetime parser, this is more expensive.
+  if (tm.tm_mday == 0)
+    return Qnil;
+
+  seconds = tm.tm_sec;
+
+  // parse millisecs if any -- tad faster than using %lf in sscanf above.
+  if (lastmatch > 0 && lastmatch < size && *(data + lastmatch) == '.') {
+      idx = 0;
+      ptr = data + ++lastmatch;
+      while (*ptr && isdigit(*ptr) && idx < 31) {
+        lastmatch++;
+        fraction[idx++] = *ptr++;
+      }
+
+      fraction[idx] = 0;
+      seconds += (double)atoll(fraction) / pow(10, idx);
+  }
+
+  // parse timezone offsets if any - matches +HH:MM +HH MM +HHMM
+  if (lastmatch > 0 && lastmatch < size) {
+    const char *ptr = data + lastmatch;
+    while(*ptr && *ptr != '+' && *ptr != '-') ptr++;
+    tzsign = *ptr++;
+    if (*ptr && isdigit(*ptr)) {
+      tzhour = *ptr++ - '0';
+      if (*ptr && isdigit(*ptr)) tzhour = tzhour * 10 + *ptr++ - '0';
+      while(*ptr && !isdigit(*ptr)) ptr++;
+      if (*ptr) {
+        tzmin = *ptr++ - '0';
+        if (*ptr && isdigit(*ptr)) 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;
+  }
+
+  return rb_funcall(klass, fcivil, 7,
+    INT2FIX(tm.tm_year), INT2FIX(tm.tm_mon), INT2FIX(tm.tm_mday),
+    INT2FIX(tm.tm_hour), INT2FIX(tm.tm_min), DBL2NUM(seconds),
+    offset == 0 ? INT2FIX(0) : rb_Rational(INT2FIX(offset), day_seconds)
+  );
+}
+
+VALUE rb_datetime_parse(VALUE self, VALUE string) {
+  const char *data = CSTRING(string);
+  int size = TYPE(string) == T_STRING ? RSTRING_LEN(string) : strlen(data);
+
+  if (NIL_P(string))
+    return Qnil;
+
+  VALUE datetime = datetime_parse(self, data, size);
+  return NIL_P(datetime) ? rb_call_super(1, &string) : datetime;
+}
+
+void init_swift_datetime() {
+  rb_require("date");
+
+  VALUE mSwift    = rb_define_module("Swift");
+  VALUE cDateTime = CONST_GET(rb_mKernel, "DateTime");
+  cSwiftDateTime  = rb_define_class_under(mSwift, "DateTime", cDateTime);
+  fcivil          = rb_intern("civil");
+  fparse          = rb_intern("parse");
+  fstrptime       = rb_intern("strptime");
+  day_seconds     = INT2FIX(86400);
+
+  rb_global_variable(&day_seconds);
+  rb_define_singleton_method(cSwiftDateTime, "parse", RUBY_METHOD_FUNC(rb_datetime_parse), 1);
+}

data/ext/datetime.h

@@ -0,0 +1,12 @@
+#ifndef SWIFT_DATETIME_H
+#define SWIFT_DATETIME_H
+
+#include "swift.h"
+#include <math.h>
+
+void init_swift_datetime();
+VALUE datetime_parse(VALUE klass, const char *data, uint64_t size);
+
+extern VALUE cSwiftDateTime;
+
+#endif

data/ext/extconf.rb

@@ -1,8 +1,10 @@
 #!/usr/bin/env ruby
 require 'mkmf'
 
-Config::CONFIG['CC']  = 'g++'
-Config::CONFIG['CPP'] = 'g++'
+ConfigClass = defined?(RbConfig) ? RbConfig : Config
+
+ConfigClass::CONFIG['CC']  = 'g++'
+ConfigClass::CONFIG['CPP'] = 'g++'
 
 $CFLAGS  = '-fPIC -Os -I/usr/include -I/opt/local/include -I/usr/local/include'
 
@@ -55,6 +57,5 @@ exit 1 unless library_installed? 'pcrecpp', apt_install_hint('libpcre3-dev')
 exit 1 unless library_installed? 'uuid',    apt_install_hint('uuid-dev')
 exit 1 unless library_installed? 'dbic++',  apt_install_hint('dbic++-dev')
 
-assert_dbicpp_version '0.5.9'
-
+assert_dbicpp_version '0.6.0'
 create_makefile 'swift'