nuodb 1.0.0.rc.1 → 1.0.0.rc.2

data/.gitignore

@@ -3,6 +3,9 @@
 *.o
 *.so
 ext/nuodb/Makefile
-pkg
+coverage/
+doc/
+rdoc/
+pkg/
 tmp
 .idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-fs

data/AUTHORS

@@ -1,4 +1,4 @@
-# Authors ordered by first contribution.
+# The following people have contributed to ruby-nuodb:
 
+Robert Buck <rbuck@nuodb.com>
 Dave Meppelink <davemepp@gmail.com>
-

data/Gemfile

@@ -2,8 +2,4 @@ source 'https://rubygems.org'
 
 gemspec
 
-group(:development, :test) do
-  gem 'rake'
-  gem 'rake-compiler'
-  gem 'rdoc'
-end
+gem 'rake'

data/LICENSE

@@ -4,14 +4,14 @@ All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of NuoDB, Inc. nor the names of its contributors may
-      be used to endorse or promote products derived from this software
-      without specific prior written permission.
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of NuoDB, Inc. nor the names of its contributors may
+  be used to endorse or promote products derived from this software
+  without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
@@ -23,4 +23,3 @@ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

data/README.rdoc

@@ -2,39 +2,40 @@
 
 == DESCRIPTION
 
-This is the NuoDB API module for Ruby. It integrates the NuoDB C++
-library into Ruby.
+This is the official Ruby Gem for NuoDB. It is written as a Ruby extension that
+wraps the NuoDB C++ API, providing a natural API for Ruby developers.
 
 == BUILDING THE GEM
 
 To compile and test run this command:
 
-    rake build
+    rake clean build rdoc spec
 
 == INSTALLING THE GEM
 
-    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install nuodb-1.0.0-rc.1.gem
+    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install nuodb-1.0.0.rc.2.gem
 
 Or from the source tree:
 
-    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install pkg/nuodb-1.0.0-rc.1.gem
+    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install pkg/nuodb-1.0.0.rc.2.gem
 
 == TESTING THE GEM
 
 Start up a minimal chorus as follows:
 
-    java -jar nuoagent.jar --broker &
-    ./nuodb --chorus test --password bar --dba-user dba --dba-password baz &
+    java -jar ${NUODB_ROOT}/jar/nuoagent.jar --broker &
+    ${NUODB_ROOT}/bin/nuodb --chorus test --password bar --dba-user dba --dba-password baz --verbose debug --archive /var/tmp/nuodb --initialize --force &
+    ${NUODB_ROOT}/bin/nuodb --chorus test --password bar --dba-user dba --dba-password baz &
 
 Create a user in the database:
 
-    ./nuosql test@localhost --user dba --password baz
+    ${NUODB_ROOT}/bin/nuosql test@localhost --user dba --password baz
     > create user cloud password 'user';
     > exit
 
 Run the tests:
 
-    rake test
+    rake spec
 
 == PUBLISHING THE GEM
 
@@ -42,36 +43,34 @@ Run the tests:
 
 Tag the product using tags per the SemVer specification; our tags have a v-prefix:
 
-    git tag -a v1.0.0.rc.1 -m "SemVer Version: v1.0.0-rc.1"
+    git tag -a v1.0.0-rc.2 -m "SemVer Version: v1.0.0-rc.2"
 
 If you make a mistake, take it back quickly:
 
-    git tag -d v1.0.0.rc.1
-    git push origin :refs/tags/v1.0.0.rc.1
+    git tag -d v1.0.0-rc.2
+    git push origin :refs/tags/v1.0.0-rc.2
 
 ===PUBLISHING
 
 Here are the commands used to publish:
 
-    gem push pkg/nuodb-1.0.0.rc.1.gem
-
-If you bugger it up, pull it back quickly, or cause grief for users:
-
-    npm unpublish  db-nuodb@1.0.0.RC.1
-
-To view published versions:
-
-    npm view  db-nuodb
+    gem push pkg/nuodb-1.0.0.rc.2.gem
 
 == INSPECTING THE GEM
 
 It is often useful to inspect the contents of a Gem before distribution.
 To do this you dump the contents of a gem thus:
 
-    gem unpack pkg/nuodb-1.0.0.rc.1.gem
+    gem unpack pkg/nuodb-1.0.0.rc.2.gem
 
 == INSPECTING THE EXPORTED SYMBOLS
 
+To inspec the symbols on Linux:
+
     nm -gU ext/nuodb/nuodb.bundle
 
+To inspec the symbols on Mac:
+
+    otool -l ext/nuodb/nuodb.bundle
+
 == REFERENCES

data/Rakefile

@@ -33,6 +33,16 @@ require 'rake/testtask'
 require 'rdoc/task'
 require 'date'
 
+require 'bundler'
+require 'bundler/gem_tasks'
+
+require File.expand_path(File.dirname(__FILE__)) + "/spec/support/config"
+require File.expand_path(File.dirname(__FILE__)) + "/tasks/rspec"
+
+Bundler::GemHelper.install_tasks
+
+load 'nuodb.gemspec'
+
 #############################################################################
 #
 # Helper functions
@@ -93,20 +103,16 @@ end
 #
 #############################################################################
 
+CLEAN.include('doc/ri')
+CLEAN.include('doc/site')
 CLEAN.include('pkg')
 CLEAN.include('ext/**/*{.o,.log,.so,.bundle}')
 CLEAN.include('ext/**/Makefile')
 CLEAN.include('lib/**/*{.so,.bundle}')
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "#{name} #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+Dir['tasks/**/*.rb'].each { |file| load file }
 
-file "lib/#{name}/#{name}.#{so_ext}" => Dir.glob("ext/#{name}/*{.rb,.c}") do
+file "lib/#{name}/#{name}.#{so_ext}" => Dir.glob("ext/#{name}/*{.rb,.cpp}") do
   Dir.chdir("ext/#{name}") do
     # this does essentially the same thing
     # as what RubyGems does
@@ -116,13 +122,23 @@ file "lib/#{name}/#{name}.#{so_ext}" => Dir.glob("ext/#{name}/*{.rb,.c}") do
   cp "ext/#{name}/#{name}.#{so_ext}", "lib/#{name}"
 end
 
-task :test => "lib/#{name}/#{name}.#{so_ext}"
+namespace :nuodb do
+  task :create_user do
+    #puts %x( echo "create user arunit password 'arunit';" | nuosql arunit@localhost --user dba --password baz )
+  end
+
+  task :start_server do
+  end
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
+  task :stop_server do
+  end
+
+  task :restart_server => [:stop_server, :start_server, :create_user]
 end
 
-task :default => :test
+task :spec => "lib/#{name}/#{name}.#{so_ext}"
+
+task :default => :spec
 
 #############################################################################
 #
@@ -138,9 +154,22 @@ task :build do
 end
 
 task :install => :build do
-  sh %{gem install pkg/#{name}-#{version} --no-rdoc --no-ri}
+  sh %{gem install pkg/#{name}-#{version}}
 end
 
 task :uninstall do
   sh %{gem uninstall #{name} -x -v #{version}}
 end
+
+desc "Tags git with the latest gem version"
+task :tag do
+  sh %{git tag v#{version}}
+end
+
+desc "Push gem packages"
+task :push => :build do
+  sh "gem push pkg/#{name}*.gem"
+end
+
+desc "Release version #{version}"
+task :release => [:tag, :push]

data/ext/nuodb/atomic.c

@@ -0,0 +1,11 @@
+#include "atomic.h"
+
+#if !defined(_WIN32) && !defined(HAVE_GCC_ATOMIC_BUILTINS)
+rb_atomic_t
+ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val)
+{
+    rb_atomic_t old = *ptr;
+    *ptr = val;
+    return old;
+}
+#endif

data/ext/nuodb/atomic.h

@@ -0,0 +1,62 @@
+#ifndef RUBY_ATOMIC_H
+#define RUBY_ATOMIC_H
+
+#ifdef _WIN32
+#if defined _MSC_VER && _MSC_VER > 1200
+#pragma intrinsic(_InterlockedOr)
+#endif
+typedef LONG rb_atomic_t;
+
+# define ATOMIC_SET(var, val) InterlockedExchange(&(var), (val))
+# define ATOMIC_INC(var) InterlockedIncrement(&(var))
+# define ATOMIC_DEC(var) InterlockedDecrement(&(var))
+
+#if defined __GNUC__
+# define ATOMIC_OR(var, val) __asm__("lock\n\t" "orl\t%1, %0" : "=m"(var) : "Ir"(val))
+#elif defined _MSC_VER && _MSC_VER <= 1200
+# define ATOMIC_OR(var, val) rb_w32_atomic_or(&(var), (val))
+static inline void
+rb_w32_atomic_or(volatile rb_atomic_t *var, rb_atomic_t val)
+{
+#ifdef _M_IX86
+    __asm mov eax, var;
+    __asm mov ecx, val;
+    __asm lock or [eax], ecx;
+#else
+#error unsupported architecture
+#endif
+}
+#else
+# define ATOMIC_OR(var, val) _InterlockedOr(&(var), (val))
+#endif
+
+# define ATOMIC_EXCHANGE(var, val) InterlockedExchange(&(var), (val))
+
+#elif defined HAVE_GCC_ATOMIC_BUILTINS
+
+
+/* @shyouhei hack to support atomic operations in case of gcc. Gcc
+ * has its own pseudo-insns to support them.  See info, or
+ * http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html */
+
+typedef unsigned int rb_atomic_t; /* Anything OK */
+# define ATOMIC_SET(var, val)  __sync_lock_test_and_set(&(var), (val))
+# define ATOMIC_INC(var) __sync_add_and_fetch(&(var), 1)
+# define ATOMIC_DEC(var) __sync_sub_and_fetch(&(var), 1)
+# define ATOMIC_OR(var, val) __sync_or_and_fetch(&(var), (val))
+# define ATOMIC_EXCHANGE(var, val) __sync_lock_test_and_set(&(var), (val))
+
+#else
+
+typedef int rb_atomic_t;
+extern rb_atomic_t ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val);
+
+# define ATOMIC_SET(var, val) ((var) = (val))
+# define ATOMIC_INC(var) (++(var))
+# define ATOMIC_DEC(var) (--(var))
+# define ATOMIC_OR(var, val) ((var) |= (val))
+# define ATOMIC_EXCHANGE(var, val) ruby_atomic_exchange(&(var), (val))
+
+#endif
+
+#endif /* RUBY_ATOMIC_H */

data/ext/nuodb/extconf.rb

@@ -34,12 +34,23 @@ require 'find'
 nuodb_include = nil
 nuodb_lib64 = nil
 
+if ENV['MAINTAINER_MODE']
+  $stderr.puts "Maintainer mode enabled."
+  warning_flags = %w(-Wall -g -g -ggdb -pedantic -Wextra -Wshadow -Wpointer-arith -fno-strict-aliasing -fno-builtin -Wcast-qual -Wcast-align -fstrict-aliasing -Wno-long-long  -Wwrite-strings)
+  warning_flags.inject($CFLAGS) do |flags, option|
+    flags << " #{option}"
+  end
+end
+
+$CFLAGS << " -fexceptions"
+
 case RUBY_PLATFORM
   when /solaris|sunos/i
     have_library('stdc++')
     $CC = "gcc"
     $CXX = "g++"
     $LIBS << " -lstdc++ -lc"
+    $CFLAGS += " -g"
 end
 
 def dylib_extension
@@ -99,7 +110,9 @@ end
 # section below handles this special case so that we can run our test suites.
 
 if nuodb_include.nil? and nuodb_lib64.nil?
-  nuodb_include, nuodb_lib64 = nuodb_srcs? ENV['NUODB_ROOT']
+  unless ENV['NUODB_ROOT'].nil?
+    nuodb_include, nuodb_lib64 = nuodb_srcs? ENV['NUODB_ROOT']
+  end
 end
 
 # Lastly we fall back to detecting the location of installed product against
@@ -149,4 +162,12 @@ case RUBY_PLATFORM
   else
 end
 
+add_define 'HAVE_GCC_ATOMIC_BUILTINS' if try_link(<<SRC)
+  unsigned char atomic_var;
+  __sync_lock_test_and_set(&atomic_var, 0);
+  __sync_lock_test_and_set(&atomic_var, 1);
+  __sync_fetch_and_add(&atomic_var, 1);
+  __sync_fetch_and_sub(&atomic_var, 1);
+SRC
+
 create_makefile('nuodb/nuodb')

data/ext/nuodb/nuodb.cpp

@@ -31,79 +31,35 @@
  */
 
 #include <ruby.h>
+#include "atomic.h"
+#include <assert.h>
 #include <time.h>
 #include <stdio.h>
+#include <typeinfo>
 
-extern "C" struct timeval rb_time_timeval(VALUE time);
-
-//------------------------------------------------------------------------------
-// class building macros
-
-#define WRAPPER_COMMON(WT, RT)                                          \
-    private:                                                            \
-    static VALUE type;                                                  \
-    RT* ptr;                                                            \
-public:                                                                 \
-    WT(RT* arg): ptr(arg) {}                                            \
-    static VALUE getRubyType() { return type; }                         \
-    static void release(WT* self)                                       \
-{                                                                       \
-    /*delete self->ptr;*/                                               \
-    delete self;                                                        \
-}                                                                       \
-    static RT* asPtr(VALUE value)                                       \
-{                                                                       \
-    Check_Type(value, T_DATA);                                          \
-    return ((WT*)DATA_PTR(value))->ptr;                                 \
-}                                                                       \
-    static VALUE wrap(RT* value)                                        \
-{                                                                       \
-    if (value == NULL) return Qnil;                                     \
-    WT* w = new WT(value);                                              \
-    VALUE obj = Data_Wrap_Struct(WT::getRubyType(), 0, WT::release, w); \
-    rb_obj_call_init(obj, 0, 0);                                        \
-    return obj;                                                         \
-}
-
-#define WRAPPER_DEFINITION(WT)                                          \
-    VALUE WT::type = 0;
-
-#define AS_QBOOL(value)((value)? Qtrue : Qfalse)
-
-//------------------------------------------------------------------------------
-// utility function macros
-
-#define SYMBOL_OF(value)                                                \
-    ID2SYM(rb_intern(#value))
-
-#define INIT_TYPE(name)                                                 \
-    type = rb_define_class_under(module, name, rb_cObject)
-
-#define DEFINE_SINGLE(func, count)                                      \
-    rb_define_singleton_method(type, #func, RUBY_METHOD_FUNC(func), count)
+#define HAVE_CXA_DEMANGLE
 
-#define DEFINE_METHOD(func, count)                                      \
-    rb_define_method(type, #func, RUBY_METHOD_FUNC(func), count)
-
-//------------------------------------------------------------------------------
-// exception mapper
-
-static VALUE m_nuodb, c_nuodb_error;
-static ID c_error_code_assignment;
-
-static void rb_raise_nuodb_error(int code, const char * fmt, ...)
+#ifdef HAVE_CXA_DEMANGLE
+#include <cxxabi.h>
+const char * demangle(const char * name)
 {
-    va_list args;
-    char text[BUFSIZ];
+    char buf[1024];
+    size_t size = 1024;
+    int status;
+    char * res = abi::__cxa_demangle (name,
+        buf, &size, &status);
+    return res;
+}
+#else
+const char* demangle(const char* name)
+{
+  return name;
+}
+#endif
 
-    va_start(args, fmt);
-    vsnprintf(text, BUFSIZ, fmt, args);
-    va_end(args);
+extern "C" struct timeval rb_time_timeval(VALUE time);
 
-    VALUE error = rb_exc_new2(c_nuodb_error, text);
-    rb_funcall(error, c_error_code_assignment, 1, UINT2NUM(code));
-    rb_exc_raise(error);
-}
+#define AS_QBOOL(value)((value)? Qtrue : Qfalse)
 
 //------------------------------------------------------------------------------
 
@@ -130,1001 +86,2432 @@ static void rb_raise_nuodb_error(int code, const char * fmt, ...)
 #include "SqlDate.h"
 #include "SqlTime.h"
 
-using namespace NuoDB;
+// ----------------------------------------------------------------------------
+// M O D U L E S
 
-class WrapDatabaseMetaData
-{
-    WRAPPER_COMMON(WrapDatabaseMetaData, DatabaseMetaData)
+static VALUE m_nuodb;
 
-    static void init(VALUE module);
-    static VALUE getDatabaseVersion(VALUE self);
-    static VALUE getIndexInfo(VALUE self, VALUE schemaValue, VALUE tableValue, VALUE uniqueValue, VALUE approxValue);
-    static VALUE getColumns(VALUE self, VALUE schemaValue, VALUE tablePattern);
-    static VALUE getTables(VALUE self, VALUE schemaValue, VALUE table);
-};
+// ----------------------------------------------------------------------------
+// C O N S T A N T S
 
-WRAPPER_DEFINITION(WrapDatabaseMetaData);
+static VALUE c_nuodb_error;
 
-//------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// C L A S S E S
 
-class WrapResultSetMetaData
-{
-    WRAPPER_COMMON(WrapResultSetMetaData, ResultSetMetaData);
+static VALUE nuodb_connection_klass;
+static VALUE nuodb_statement_klass;
+static VALUE nuodb_prepared_statement_klass;
+static VALUE nuodb_result_klass;
 
-    static void init(VALUE module);
-    static VALUE getColumnCount(VALUE self);
-    static VALUE getColumnName(VALUE self, VALUE columnValue);
-    static VALUE getScale(VALUE self, VALUE columnValue);
-    static VALUE getPrecision(VALUE self, VALUE columnValue);
-    static VALUE isNullable(VALUE self, VALUE columnValue);
-    static VALUE getColumnTypeName(VALUE self, VALUE columnValue);
-    static VALUE getType(VALUE self, VALUE columnValue);
-};
+// ----------------------------------------------------------------------------
+// S Y M B O L S
 
-WRAPPER_DEFINITION(WrapResultSetMetaData);
+static VALUE sym_database, sym_username, sym_password, sym_schema, sym_timezone;
 
-//------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// B E H A V I O R S
 
-class WrapResultSet
-{
-    WRAPPER_COMMON(WrapResultSet, ResultSet)
-
-    static void init(VALUE module);
-    static VALUE next(VALUE self);
-    static VALUE getColumnCount(VALUE self);
-    static VALUE getMetaData(VALUE self);
-    static VALUE getBoolean(VALUE self, VALUE columnValue);
-    static VALUE getInteger(VALUE self, VALUE columnValue);
-    static VALUE getDouble(VALUE self, VALUE columnValue);
-    static VALUE getString(VALUE self, VALUE columnValue);
-    static VALUE getDate(VALUE self, VALUE columnValue);
-    static VALUE getTime(VALUE self, VALUE columnValue);
-    static VALUE getTimestamp(VALUE self, VALUE columnValue);
-    static VALUE getChar(VALUE self, VALUE columnValue);
-};
+static const bool ENABLE_CLOSE_HOOK = true;
 
-WRAPPER_DEFINITION(WrapResultSet)
+// ----------------------------------------------------------------------------
+// L O G G I N G   A N D   T R A C I N G
 
-//------------------------------------------------------------------------------
+#define ENABLE_LOGGING
 
-class WrapStatement
+enum LogLevel
 {
-    WRAPPER_COMMON(WrapStatement, Statement);
-
-    static void init(VALUE module);
-    static VALUE close(VALUE self);
-    static VALUE execute(VALUE self, VALUE sqlValue);
-    static VALUE executeQuery(VALUE self, VALUE sqlValue);
-    static VALUE executeUpdate(VALUE self, VALUE sqlValue);
-    static VALUE getResultSet(VALUE self);
-    static VALUE getUpdateCount(VALUE self);
-    static VALUE getGeneratedKeys(VALUE self);
-};
-
-WRAPPER_DEFINITION(WrapStatement);
-
-//------------------------------------------------------------------------------
-
-class WrapPreparedStatement
-{
-    WRAPPER_COMMON(WrapPreparedStatement, PreparedStatement);
-
-    static void init(VALUE module);
-    static VALUE close(VALUE self);
-    static VALUE setBoolean(VALUE self, VALUE indexValue, VALUE valueValue);
-    static VALUE setInteger(VALUE self, VALUE indexValue, VALUE valueValue);
-    static VALUE setDouble(VALUE self, VALUE indexValue, VALUE valueValue);
-    static VALUE setString(VALUE self, VALUE indexValue, VALUE valueValue);
-    static VALUE setTime(VALUE self, VALUE indexValue, VALUE valueValue);
-    static VALUE execute(VALUE self);
-    static VALUE executeQuery(VALUE self);
-    static VALUE executeUpdate(VALUE self);
-    static VALUE getResultSet(VALUE self);
-    static VALUE getUpdateCount(VALUE self);
-    static VALUE getGeneratedKeys(VALUE self);
+    ERROR,
+    WARN,
+    INFO,
+    TRACE,
+    DEBUG,
+    NONE
 };
 
-WRAPPER_DEFINITION(WrapPreparedStatement);
-
-//------------------------------------------------------------------------------
-
-class WrapConnection
-{
-    WRAPPER_COMMON(WrapConnection, Connection);
-
-    static void init(VALUE module);
-    static VALUE close(VALUE self);
-    static VALUE ping(VALUE self);
-    static VALUE createStatement(VALUE self);
-    static VALUE createPreparedStatement(VALUE self, VALUE sqlValue);
-    static VALUE setAutoCommit(VALUE self, VALUE autoCommitValue);
-    static VALUE hasAutoCommit(VALUE self);
-    static VALUE commit(VALUE self);
-    static VALUE rollback(VALUE self);
-    static VALUE getMetaData(VALUE self);
-    static VALUE getSchema(VALUE self);
-    static VALUE createSqlConnection(VALUE self,
-        VALUE databaseValue,
-        VALUE schemaValue,
-        VALUE usernameValue,
-        VALUE passwordValue);
-};
-
-WRAPPER_DEFINITION(WrapConnection);
-
-//------------------------------------------------------------------------------
-
-void WrapDatabaseMetaData::init(VALUE module)
-{
-    INIT_TYPE("DatabaseMetaData");
-    DEFINE_METHOD(getDatabaseVersion, 0);
-    DEFINE_METHOD(getIndexInfo, 4);
-    DEFINE_METHOD(getColumns, 2);
-    DEFINE_METHOD(getTables, 2);
+static LogLevel logLevel = NONE;
+
+static char const * log_level_name(LogLevel level)
+{
+    char const * level_name = NULL;
+    switch(level)
+    {
+    case NONE:
+        level_name = "NONE";
+        break;
+    case ERROR:
+        level_name = "ERROR";
+        break;
+    case WARN:
+        level_name = "WARN";
+        break;
+    case INFO:
+        level_name = "INFO";
+        break;
+    case DEBUG:
+        level_name = "DEBUG";
+        break;
+    case TRACE:
+        level_name = "TRACE";
+        break;
+    }
+    return level_name;
 }
 
-VALUE WrapDatabaseMetaData::getDatabaseVersion(VALUE self)
+static void log(LogLevel level, char const * message)
 {
-    try
+    if (level >= logLevel)
     {
-        return rb_str_new2(asPtr(self)->getDatabaseProductVersion());
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Get database metadata database version failed: %s", e.getText());
+        printf("[%s] %s\n", log_level_name(level), message);
     }
 }
 
-VALUE WrapDatabaseMetaData::getIndexInfo(VALUE self, VALUE schemaValue, VALUE tableValue, VALUE uniqueValue, VALUE approxValue)
+static void trace(char const * message)
 {
-    const char* schema = StringValuePtr(schemaValue);
-    const char* table = StringValuePtr(tableValue);
-    bool unique = !(RB_TYPE_P(uniqueValue, T_FALSE) || RB_TYPE_P(uniqueValue, T_NIL));
-    bool approx = !(RB_TYPE_P(approxValue, T_FALSE) || RB_TYPE_P(approxValue, T_NIL));
-    try
-    {
-        return WrapResultSet::wrap(asPtr(self)->getIndexInfo(NULL, schema, table, unique, approx));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Get database metadata index info failed: %s", e.getText());
-    }
+    log(TRACE, message);
 }
 
-VALUE WrapDatabaseMetaData::getColumns(VALUE self, VALUE schemaValue, VALUE tableValue)
+static void print_address(char const * context, void * address)
 {
-    const char* schema = StringValuePtr(schemaValue);
-    const char* table = StringValuePtr(tableValue);
-    try
+    if (DEBUG >= logLevel)
     {
-        return WrapResultSet::wrap(asPtr(self)->getColumns(NULL, schema, table, NULL));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Get columns failed: %s", e.getText());
+#if defined(__APPLE__)
+        printf("%s: %016" PRIxPTR "\n", context, (uintptr_t) address);
+#endif
     }
 }
 
-VALUE WrapDatabaseMetaData::getTables(VALUE self, VALUE schemaValue, VALUE tableValue)
+// ----------------------------------------------------------------------------
+// NEXT GEN GC INTEGRATION SERVICES
+
+#ifdef ENABLE_NEXTGEN_GC_INTEGRATION
+
+/*
+ * GC Notes:
+ *
+ * 1. gc_entities are placed in the Ruby object table and are freed via mark
+ *    and sweep.
+ * 2. gc_entities may be freed in any order.
+ * 3. gc_entities may be freed either before shutdown or during shutdown.
+ * 4. gc_entities may no longer be accessed once freed by the garbage
+ *    collector; once gc_entities are freed they no longer appear in the
+ *    object table. As such, calls to Data_Get_Struct on previously garbage
+ *    collected entities will cause the Ruby VM to crash; viz. SIGABRT via
+ *    EXC_BAD_ACCESS.
+ *
+ *    a. So a general observation of this is thusly: if e.g. with graphs of
+ *       child to parent relationships an orderly de-allocation is required,
+ *       as parents (gc_entities) may be freed prior to childrens (gc_entities)
+ *       it becomes imperative that the logic between freeing gc_entity objects
+ *       be kept completely and distinctly apart from the logic of the managed
+ *       entities themselves.
+ */
+
+typedef void (*callback)(void *);
+
+/*
+ * Application Rules:
+ *
+ * 1. Assign a callback for the increment and decrement refers counter so that
+ *    context specific logging and tracking may be implemented.
+ * 2. Direct access to refers should never occur.
+ * 3. The freed bit indicates that the resources associated to the data_handle
+ *    has been freed, and NOT that the os_entity struct has been freed.
+ *
+ * Logic:
+ *
+ * 1. The incr_func is called on a child when it is first created.
+ * 2. The incr_func is called on a parent when its child is first created.
+ * 3. When incr_func is called, ATOMIC_INC increments the refers field.
+ * 4. When decr_func is called, ATOMIC_DEC decrements the refers field.
+ * 5. When the refers field reaches zero (inside decr_func):
+ *    5.1. ATOMIC-CAS the freed bit, if the prior freed bit is not set:
+ *       5.1.1. ATOMIC-OR all parents freed bits and if the result does not have
+ *          the freed bit set:
+ *          5.1.1.1. Call the free function, passing the os_entity itself as a parameter.
+ *            The free function releases any resources related to the data
+ *            handle itself and sets the handle to null.
+ *    5.2. Call the decr_func on its parent (this may act recursively).
+ *    5.3. Call xfree on the os_entity structure itself.
+ * 6. When a user calls finish on an object:
+ *    6.1. ATOMIC-CAS the freed bit, if the prior freed bit is not set
+ *         perform operations 5.1.1 through 5.1.1.1.
+ *
+ * Details:
+ *
+ * 1. Regarding 5a, above, we neither want to doubly release an object, nor
+ *    call free_function when a parent has already released all the resources.
+ *    This optionally is configurable, for cases when parents forcibly close
+ *    child resources, or for cases where they don't. This is a behavioral
+ *    configuration parameter to the resource manager. But the above documentation
+ *    is tailored for cases where parents automatically release child resources
+ *    when they themselves are closed.
+ * 2. A race condition may occur between 5.1 and 5.2, above, where a parent
+ *    resource is released just after 5.1.1.1 and before 5.2; the result will
+ *    be a SEGV. This may prompt the use of a global lock for the reference
+ *    manager.
+ *
+ * Interface:
+ *
+ * 1. Structures as defined below.
+ * 2. Function to release a reference:
+ *      void rc_decr_refs (void * handle, int * err_code)
+ * 3. Function to acquire a reference:
+ *      void rc_incr_refs (void * handle, int * err_code)
+ * 4. Function to wrap an entity:
+ *      void * rc_add_object (void * object, int * err_code)
+ * 5. Function to get wrapped pointer:
+ *      void * rc_get_object (void * handle, int * err_code)
+ *
+ * Questions:
+ *
+ * 1. Do we go opaque so that the data type definition is malleable? We don't
+ *    want this any more type specific than it is.
+ */
+struct os_entity
 {
-    const char* schema = StringValuePtr(schemaValue);
-    const char* table = StringValuePtr(tableValue);
+    void * data_handle;
+    unsigned int flags;
+    rb_atomic_t refers;
 
-    try
-    {
-        return WrapResultSet::wrap(asPtr(self)->getTables(NULL, schema, table, 0, NULL));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Get tables failed: %s", e.getText());
-    }
-}
+    callback incr_func;
+    callback decr_func;
+    callback free_func;
 
-//------------------------------------------------------------------------------
+    os_entity * parent;
+};
 
-void WrapResultSet::init(VALUE module)
+/*
+ * Rules:
+ *
+ * 1. When mark is called, traverse marks list till a null is reached, for
+ *    each value call rb_gc_mark.
+ * 2. When the garbage collector frees an object, the decr_function is called
+ *    on the entity passing the entity as its parameter.
+ */
+struct gc_entity
 {
-    INIT_TYPE("ResultSet");
-    DEFINE_METHOD(next, 0);
-    DEFINE_METHOD(getMetaData, 0);
-    DEFINE_METHOD(getBoolean, 1);
-    DEFINE_METHOD(getInteger, 1);
-    DEFINE_METHOD(getDouble, 1);
-    DEFINE_METHOD(getString, 1);
-    DEFINE_METHOD(getDate, 1);
-    DEFINE_METHOD(getTime, 1);
-    DEFINE_METHOD(getTimestamp, 1);
-    DEFINE_METHOD(getChar, 1);
-}
+    os_entity * entity;
+    VALUE ** mark_refs;
+};
+
+/*
+ * A strict release strategy only permits free calls after the reference count
+ * drops to zero. A lenient release strategy permits free calls at any time,
+ * yet the entity itself is not freed until its reference count drops to zero.
+ */
+typedef enum {strict, lenient} free_strategy;
+
+#endif /* ENABLE_NEXTGEN_GC_INTEGRATION */
 
-VALUE WrapResultSet::next(VALUE self)
+// ----------------------------------------------------------------------------
+// H A N D L E S
+
+struct nuodb_handle
 {
-    try
-    {
-        return AS_QBOOL(asPtr(self)->next());
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to move the cursor forward one row: %s", e.getText());
-    }
-}
+    RUBY_DATA_FUNC free_func;
+    rb_atomic_t atomic;
+    nuodb_handle * parent_handle;
+    VALUE parent;
+};
 
-VALUE WrapResultSet::getMetaData(VALUE self)
+struct nuodb_connection_handle : nuodb_handle
 {
-    try
-    {
-        return WrapResultSetMetaData::wrap(asPtr(self)->getMetaData());
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to retrieve number, types, and properties of the result set: %s", e.getText());
-    }
-}
+    VALUE database;
+    VALUE username;
+    VALUE password;
+    VALUE schema;
+    VALUE timezone;
+
+    NuoDB::Connection * pointer;
+};
 
-VALUE WrapResultSet::getBoolean(VALUE self, VALUE columnValue)
+struct nuodb_prepared_statement_handle : nuodb_handle
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        bool value = asPtr(self)->getBoolean(column);
-        return AS_QBOOL(value);
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get boolean value for the designated column (%d): %s", column, e.getText());
-    }
-}
+    NuoDB::PreparedStatement * pointer;
+};
 
-VALUE WrapResultSet::getInteger(VALUE self, VALUE columnValue)
+struct nuodb_statement_handle : nuodb_handle
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return INT2NUM(asPtr(self)->getInt(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get integer value for the designated column (%d): %s", column, e.getText());
-    }
-}
+    NuoDB::Statement * pointer;
+};
 
-VALUE WrapResultSet::getDouble(VALUE self, VALUE columnValue)
+struct nuodb_result_handle : nuodb_handle
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_float_new(asPtr(self)->getDouble(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get double value for the designated column (%d): %s", column, e.getText());
-    }
+    NuoDB::ResultSet * pointer;
+    NuoDB::Connection * connection;
+};
+
+template<typename handle_type>
+handle_type * cast_handle(VALUE value)
+{
+    Check_Type(value, T_DATA);
+    return static_cast<handle_type*>(DATA_PTR(value));
 }
 
-VALUE WrapResultSet::getString(VALUE self, VALUE columnValue)
+template<typename handle_type, typename return_type>
+return_type * cast_pointer_member(VALUE value)
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_str_new2(asPtr(self)->getString(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get string value for the designated column (%d): %s", column, e.getText());
-    }
+    Check_Type(value, T_DATA);
+    return cast_handle<handle_type>(value)->pointer;
 }
-VALUE WrapResultSet::getDate(VALUE self, VALUE columnValue)
+
+static void track_ref_count(char const * context, nuodb_handle * handle)
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_str_new2(asPtr(self)->getString(column));
-        //Date* date = asPtr(self)->getDate(column);
-        //SqlDate timestamp(date->getMilliseconds());
-        //struct tm utc;
-        //timestamp.getDate(&utc);
-        //char buffer[250];
-        //::strftime(buffer,sizeof(buffer),"%Y%m%dT%I%M%S+0000",&utc);
-        //return rb_str_new2(buffer);
-    }
-    catch (SQLException & e)
+    trace("track_ref_count");
+
+    if (handle != 0)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get date value for the designated column (%d): %s", column, e.getText());
+        int parent_count = -10;
+        if (handle->parent_handle != 0)
+        {
+            parent_count = handle->parent_handle->atomic;
+        }
+        if (logLevel <= DEBUG)
+        {
+#if defined(__APPLE__)
+            nuodb_handle * parent = handle->parent_handle;
+            printf("[REFERENCE COUNT][%s] (%s @ %016" PRIxPTR "): %d (%s @ %016" PRIxPTR "): %d\n",
+                context, demangle(typeid(*handle).name()), (uintptr_t) handle,
+                    handle->atomic, demangle(typeid(*parent).name()), (uintptr_t) parent, parent_count);
+#endif
+        }
     }
 }
 
-VALUE WrapResultSet::getTime(VALUE self, VALUE columnValue)
+void incr_reference_count(nuodb_handle * handle)
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_str_new2(asPtr(self)->getString(column));
-        //Time* time = asPtr(self)->getTime(column);
-        //SqlTime timestamp(time->getMilliseconds());
-        //struct tm utc;
-        //timestamp.getTime(&utc);
-        //char buffer[250];
-        //::strftime(buffer,sizeof(buffer),"%Y%m%dT%I%M%S+0000",&utc);
-        // Workaround until we fix the Date/Time support
-        // Convert time to local time?
-        //snprintf(buffer, sizeof(buffer), "%u:%u:%u", utc.tm_hour, utc.tm_min, utc.tm_sec);
-        //return rb_str_new2(buffer);
-    }
-    catch (SQLException & e)
+    trace("incr_reference_count");
+
+    track_ref_count("I INCR", handle);
+
+    ATOMIC_INC(handle->atomic);
+    if (handle->parent_handle != 0)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get time value for the designated column (%d): %s", column, e.getText());
+        log(DEBUG, "incrementing parent");
+        ATOMIC_INC(handle->parent_handle->atomic);
     }
+
+    track_ref_count("O INCR", handle);
 }
 
-VALUE WrapResultSet::getTimestamp(VALUE self, VALUE columnValue)
+void decr_reference_count(nuodb_handle * handle)
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_str_new2(asPtr(self)->getString(column));
-        //Timestamp* ts = asPtr(self)->getTimestamp(column);
-        //SqlTimestamp timestamp(ts->getMilliseconds());
-        //struct tm utc;
-        //timestamp.getTimestamp(&utc);
-        //char buffer[250];
-        //::strftime(buffer,sizeof(buffer),"%Y%m%dT%I%M%S+0000",&utc);
-        //return rb_str_new2(buffer);
-    }
-    catch (SQLException & e)
+    trace("decr_reference_count");
+
+    track_ref_count("I DECR", handle);
+
+    if (handle->atomic == 0)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get timestamp value for the designated column (%d): %s", column, e.getText());
+        return;
     }
-}
 
-VALUE WrapResultSet::getChar(VALUE self, VALUE columnValue)
-{
-    int column = NUM2UINT(columnValue);
-    try
+    if (ATOMIC_DEC(handle->atomic) == 0)
     {
-        return rb_str_new2(asPtr(self)->getString(column));
+        (*(handle->free_func))(handle);
+        if (handle->parent_handle != 0)
+        {
+            log(DEBUG, "decrementing parent");
+            decr_reference_count(handle->parent_handle);
+            handle->parent = Qnil;
+            handle->parent_handle = 0;
+            assert(NIL_P(handle->parent));
+        }
+        track_ref_count("O DECR", handle);
+
+        print_address("[DELETING HANDLE]", handle);
+        xfree(handle);
+        handle = NULL;
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get char value for the designated column (%d): %s", column, e.getText());
+        track_ref_count("O DECR", handle);
     }
 }
 
 //------------------------------------------------------------------------------
+// exception mapper
 
-void WrapResultSetMetaData::init(VALUE module)
-{
-    INIT_TYPE("ResultMetaData");
-    DEFINE_METHOD(getColumnCount, 0);
-    DEFINE_METHOD(getColumnName, 1);
-    DEFINE_METHOD(getType, 1);
-    DEFINE_METHOD(getColumnTypeName, 1);
-    DEFINE_METHOD(getScale, 1);
-    DEFINE_METHOD(getPrecision, 1);
-    DEFINE_METHOD(isNullable, 1);
-}
+static ID c_error_code_assignment;
 
-VALUE WrapResultSetMetaData::getColumnCount(VALUE self)
+static void rb_raise_nuodb_error(int code, const char * fmt, ...)
 {
-    try
-    {
-        return UINT2NUM(asPtr(self)->getColumnCount());
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get column count from the result set metadata: %s", e.getText());
-    }
+    va_list args;
+    char text[BUFSIZ];
+
+    va_start(args, fmt);
+    vsnprintf(text, BUFSIZ, fmt, args);
+    va_end(args);
+
+    VALUE error = rb_exc_new2(c_nuodb_error, text);
+    rb_funcall(error, c_error_code_assignment, 1, UINT2NUM(code));
+    rb_exc_raise(error);
 }
 
-VALUE WrapResultSetMetaData::getColumnName(VALUE self, VALUE columnValue)
-{
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_str_new2(asPtr(self)->getColumnName(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get column name from the result set metadata: %s", e.getText());
-    }
+//------------------------------------------------------------------------------
+
+using namespace NuoDB;
+
+//------------------------------------------------------------------------------
+
+static
+VALUE nuodb_result_free_protect(VALUE value)
+{
+    trace("nuodb_result_free_protect");
+    nuodb_result_handle * handle = reinterpret_cast<nuodb_result_handle *>(value);
+    if (handle != NULL)
+    {
+        if (handle->pointer != NULL)
+        {
+            try
+            {
+                track_ref_count("CLOSE RESULT", handle);
+                log(INFO, "closing result");
+                handle->pointer->close();
+                handle->pointer = NULL;
+            }
+            catch (SQLException & e)
+            {
+                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close result: %s", e.getText());
+            }
+        }
+    }
+    return Qnil;
 }
 
-VALUE WrapResultSetMetaData::getScale(VALUE self, VALUE columnValue)
+static
+void nuodb_result_free(void * ptr)
 {
-    int column = NUM2UINT(columnValue);
-    try
+    trace("nuodb_result_free");
+    if (ptr != NULL)
     {
-        return UINT2NUM(asPtr(self)->getScale(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get scale from the result set metadata: %s", e.getText());
+        int exception = 0;
+        rb_protect(nuodb_result_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
     }
 }
 
-VALUE WrapResultSetMetaData::getPrecision(VALUE self, VALUE columnValue)
+static
+void nuodb_result_mark(void * ptr)
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return UINT2NUM(asPtr(self)->getPrecision(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get precision from the result set metadata: %s", e.getText());
-    }
+    trace("nuodb_result_mark");
+    nuodb_result_handle * handle = static_cast<nuodb_result_handle *>(ptr);
+    rb_gc_mark(handle->parent);
 }
 
-VALUE WrapResultSetMetaData::isNullable(VALUE self, VALUE columnValue)
+static
+void nuodb_result_decr_reference_count(nuodb_handle * handle)
 {
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return AS_QBOOL(asPtr(self)->isNullable(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to determine nullability from the result set metadata: %s", e.getText());
-    }
+    trace("nuodb_result_decr_reference_count");
+    decr_reference_count(handle);
 }
 
-VALUE WrapResultSetMetaData::getColumnTypeName(VALUE self, VALUE columnValue)
-{
-    int column = NUM2UINT(columnValue);
-    try
-    {
-        return rb_str_new2(asPtr(self)->getColumnTypeName(column));
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get column type name from the result set metadata for the designated column (%d): %s", column, e.getText());
-    }
+/*
+ * call-seq:
+ *  finish()
+ *
+ * Releases the result set and any associated resources.
+ */
+static
+VALUE nuodb_result_finish(VALUE self)
+{
+    trace("nuodb_result_free_protect");
+    nuodb_result_handle * handle = cast_handle<nuodb_result_handle>(self);//reinterpret_cast<nuodb_result_handle *>(value);
+    nuodb_result_free(handle);
+//    if (handle != NULL)
+//    {
+//        if (handle->pointer != NULL)
+//        {
+//            try
+//            {
+//                //handle->pointer->close();
+//                //handle->pointer = NULL;
+//            }
+//            catch (SQLException & e)
+//            {
+//                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close result: %s", e.getText());
+//            }
+//        }
+//    }
+    return Qnil;
+//
+//
+//
+//    trace("nuodb_result_finish");
+//    if (ENABLE_CLOSE_HOOK)
+//    {
+//        //nuodb_result_decr_reference_count(cast_handle<nuodb_result_handle>(self));
+//    }
+//    nuodb_result_handle * handle = ;
+//    if (handle != NULL && handle->pointer != NULL)
+//    {
+//        if (ATOMIC_DEC(handle->atomic) == 0)
+//        {
+//            try
+//            {
+//                //handle->pointer->close();
+//                //handle->pointer = NULL;
+//            }
+//            catch (SQLException & e)
+//            {
+//                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close result set: %s", e.getText());
+//            }
+//        }
+//    }
+//    return Qnil;
 }
 
-VALUE WrapResultSetMetaData::getType(VALUE self, VALUE columnValue)
+static
+VALUE nuodb_map_sql_type(int type)
 {
-    int column = NUM2UINT(columnValue);
-    SqlType t = (SqlType)asPtr(self)->getColumnType(column);
-
-    switch(t)
+    VALUE symbol = Qnil;
+    switch(type)
     {
-    case NUOSQL_NULL:
-        return SYMBOL_OF(SQL_NULL);
-    case NUOSQL_BIT:
-        return SYMBOL_OF(SQL_BIT);
     case NUOSQL_TINYINT:
-        return SYMBOL_OF(SQL_TINYINT);
     case NUOSQL_SMALLINT:
-        return SYMBOL_OF(SQL_SMALLINT);
     case NUOSQL_INTEGER:
-        return SYMBOL_OF(SQL_INTEGER);
     case NUOSQL_BIGINT:
-        return SYMBOL_OF(SQL_BIGINT);
+        symbol = ID2SYM(rb_intern("integer"));
+        break;
+
     case NUOSQL_FLOAT:
-        return SYMBOL_OF(SQL_FLOAT);
     case NUOSQL_DOUBLE:
-        return SYMBOL_OF(SQL_DOUBLE);
+        symbol = ID2SYM(rb_intern("float"));
+        break;
+
     case NUOSQL_CHAR:
-        return SYMBOL_OF(SQL_CHAR);
     case NUOSQL_VARCHAR:
-        return SYMBOL_OF(SQL_STRING);
     case NUOSQL_LONGVARCHAR:
-        return SYMBOL_OF(SQL_LONGVARCHAR);
+        symbol = ID2SYM(rb_intern("string"));
+        break;
+
+    case NUOSQL_BIT:
+    case NUOSQL_BOOLEAN:
+        symbol = ID2SYM(rb_intern("boolean"));
+        break;
+
     case NUOSQL_DATE:
-        return SYMBOL_OF(SQL_DATE);
-    case NUOSQL_TIME:
-        return SYMBOL_OF(SQL_TIME);
+        symbol = ID2SYM(rb_intern("date"));
+        break;
+
     case NUOSQL_TIMESTAMP:
-        return SYMBOL_OF(SQL_TIMESTAMP);
+        symbol = ID2SYM(rb_intern("timestamp"));
+        break;
+
+    case NUOSQL_TIME:
+        symbol = ID2SYM(rb_intern("time"));
+        break;
+
+    case NUOSQL_DECIMAL:
+        symbol = ID2SYM(rb_intern("decimal"));
+        break;
+
+    case NUOSQL_NUMERIC:
+        symbol = ID2SYM(rb_intern("numeric"));
+        break;
+
+//    case NUOSQL_BLOB:
+//        symbol = ID2SYM(rb_intern("blob"));
+//        break;
+//
+//    case NUOSQL_CLOB:
+//        symbol = ID2SYM(rb_intern("clob"));
+//        break;
+
+    case NUOSQL_NULL:
     case NUOSQL_BLOB:
-        return SYMBOL_OF(SQL_BLOB);
     case NUOSQL_CLOB:
-        return SYMBOL_OF(SQL_CLOB);
-    case NUOSQL_NUMERIC:
-        return SYMBOL_OF(SQL_NUMERIC);
-    case NUOSQL_DECIMAL:
-        return SYMBOL_OF(SQL_DECIMAL);
-    case NUOSQL_BOOLEAN:
-        return SYMBOL_OF(SQL_BOOLEAN);
     case NUOSQL_BINARY:
-        return SYMBOL_OF(SQL_BINARY);
     case NUOSQL_LONGVARBINARY:
-        return SYMBOL_OF(SQL_LONGVARBINARY);
     default:
-        // raise FEATURE_NOT_YET_IMPLEMENTED for unsupported types
-        rb_raise_nuodb_error(-2, "Invalid SQL type: %d", t);
+        rb_raise(rb_eNotImpError, "Unsupported SQL type: %d", type);
+    }
+    return symbol;
+}
+static
+VALUE nuodb_result_alloc(VALUE parent, NuoDB::ResultSet * results, NuoDB::Connection * connection)
+{
+    trace("nuodb_result_alloc");
+    nuodb_handle * parent_handle = cast_handle<nuodb_handle>(parent);
+    if (parent_handle != NULL)
+    {
+        nuodb_result_handle * handle = ALLOC(struct nuodb_result_handle);
+        handle->free_func = RUBY_DATA_FUNC(nuodb_result_free);
+        handle->atomic = 0;
+        handle->parent = parent;
+        handle->parent_handle = parent_handle;
+        handle->pointer = results;
+        handle->connection = connection;
+        incr_reference_count(handle);
+        VALUE self = Data_Wrap_Struct(nuodb_result_klass, nuodb_result_mark, nuodb_result_decr_reference_count, handle);
+
+        rb_iv_set(self, "@columns", Qnil);
+        rb_iv_set(self, "@rows", Qnil);
+
+        if (!rb_block_given_p()) {
+            trace("nuodb_result_alloc: no block");
+
+            return self;
+        }
+
+        trace("nuodb_result_alloc: begin block");
+
+        int exception = 0;
+        VALUE result = rb_protect(rb_yield, self, &exception);
+
+        trace("nuodb_result_alloc: end block");
+
+        //nuodb_result_finish(self);
+
+        trace("nuodb_result_alloc: auto finish");
+
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
+        else
+        {
+            return result;
+        }
     }
+    else
+    {
+        rb_raise(rb_eArgError, "invalid state: statement handle nil");
+    }
+    return Qnil;
+}
+
+static int64_t
+nuodb_get_rb_timezone_offset()
+{
+    VALUE time = rb_funcall(rb_cTime, rb_intern("at"), 1, rb_float_new(0));
+    VALUE offset = rb_funcall(time, rb_intern("utc_offset"), 0);
+    return NUM2LONG(offset);
+}
+
+static VALUE
+nuodb_get_rb_value(int column, SqlType type, ResultSet * results)
+{
+    VALUE value = Qnil;
+
+    switch (type)
+    {
+        case NUOSQL_BIT:
+        case NUOSQL_BOOLEAN:
+        {
+            // try-catch b.c. http://tools/jira/browse/DB-2379
+            try
+            {
+                bool field = results->getBoolean(column);
+                if (!results->wasNull())
+                {
+                    value = AS_QBOOL(field);
+                }
+            }
+            catch (SQLException & e)
+            {
+                 // see JDBC spec, DB-2379, however, according to RoR rules this
+                 // should return nil. See the following test case:
+                 // test_default_values_on_empty_strings(BasicsTest) [test/cases/base_test.rb:]
+            }
+            break;
+        }
+        case NUOSQL_FLOAT:
+        case NUOSQL_DOUBLE:
+        {
+            double field = results->getDouble(column);
+            if (!results->wasNull())
+            {
+                value = rb_float_new(field);
+            }
+            break;
+        }
+        case NUOSQL_TINYINT:
+        case NUOSQL_SMALLINT:
+        case NUOSQL_INTEGER:
+        {
+            int field = results->getInt(column);
+            if (!results->wasNull())
+            {
+                value = INT2NUM(field);
+            }
+            break;
+        }
+        case NUOSQL_BIGINT:
+        {
+            int64_t field = results->getLong(column);
+            if (!results->wasNull())
+            {
+                value = LONG2NUM(field);
+            }
+            break;
+        }
+        case NUOSQL_CHAR:
+        case NUOSQL_VARCHAR:
+        case NUOSQL_LONGVARCHAR:
+        {
+            char const * field = results->getString(column);
+            if (!results->wasNull())
+            {
+                value = rb_str_new2(field);
+            }
+            break;
+        }
+        case NUOSQL_DATE:
+        {
+            NuoDB::Date * field = results->getDate(column);
+            if (!results->wasNull())
+            {
+                double secs = (double) field->getSeconds();
+                VALUE time = rb_funcall(rb_cTime, rb_intern("at"), 1, rb_float_new(secs - nuodb_get_rb_timezone_offset()));
+                value = rb_funcall(time, rb_intern("to_date"), 0);
+            }
+            break;
+        }
+        case NUOSQL_TIME:
+        case NUOSQL_TIMESTAMP:
+        {
+            NuoDB::Timestamp * field = results->getTimestamp(column);
+            if (!results->wasNull())
+            {
+                double secs = ((double) field->getSeconds()) + (((double) field->getNanos()) / 1000000);
+                value = rb_funcall(rb_cTime, rb_intern("at"), 1, rb_float_new(secs)); //  - nuodb_get_rb_timezone_offset()
+            }
+            break;
+        }
+        case NUOSQL_NUMERIC:
+        {
+            char const * field = results->getString(column);
+            if (!results->wasNull())
+            {
+                rb_require("bigdecimal");
+                VALUE klass = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+                VALUE args[1];
+                args[0] = rb_str_new2(field);
+                value = rb_class_new_instance(1, args, klass);
+            }
+            break;
+        }
+        default:
+        {
+            rb_raise(rb_eTypeError, "not a supported ruby type: %d", type);
+            break;
+        }
+    }
+    return value;
+}
+
+/*
+ * call-seq:
+ *      result.columns -> ary
+ *
+ * Returns an array of Column objects.
+ *
+ *      results = statement.results
+ *      ...
+ *      results.columns.each do |column|
+ *          puts "#{column.name}, #{column.default}, #{column.type}, #{column.null}"
+ *      end
+ */
+static VALUE
+nuodb_result_columns(VALUE self)
+{
+    trace("nuodb_result_columns");
+    nuodb_result_handle * handle = cast_handle<nuodb_result_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
+    {
+        VALUE columns = rb_iv_get(self, "@columns");
+        if (NIL_P(columns))
+        {
+            try
+            {
+                ResultSetMetaData * result_metadata = handle->pointer->getMetaData();
+                DatabaseMetaData * database_metadata = handle->connection->getMetaData();
+
+                VALUE array = rb_ary_new();
+                rb_require("nuodb/column");
+                VALUE column_klass = rb_const_get(m_nuodb, rb_intern("Column"));
+
+                int column_count = result_metadata->getColumnCount();
+                for (int column_index = 1; column_index < column_count + 1; ++column_index)
+                {
+                    char const * schema_name = result_metadata->getSchemaName(column_index);
+                    char const * table_name = result_metadata->getTableName(column_index);
+                    char const * column_name = result_metadata->getColumnName(column_index);
+
+                    // args: [name, default, sql_type, null]
+                    VALUE args[4];
+
+                    args[0] = rb_str_new2(result_metadata->getColumnLabel(column_index));
+
+                    ResultSet * database_metadata_results = database_metadata->getColumns(NULL,
+                        schema_name, table_name, column_name);
+
+                    if(database_metadata_results->next())
+                    {
+                        try
+                        {
+                            args[1] = nuodb_get_rb_value(database_metadata_results->findColumn("COLUMN_DEF"),
+                                (SqlType) result_metadata->getColumnType(column_index), database_metadata_results);
+                        }
+                        catch (SQLException & e)
+                        {
+                            args[1] = Qnil;
+                        }
+                    }
+                    else
+                    {
+                        args[1] = Qnil;
+                    }
+                    database_metadata_results->close();
+
+                    args[2] = nuodb_map_sql_type(result_metadata->getColumnType(column_index));
+                    args[3] = result_metadata->isNullable(column_index) ? Qtrue : Qfalse;
+
+                    VALUE column = rb_class_new_instance(4, args, column_klass);
+                    rb_ary_push(array, column);
+                }
+
+                rb_iv_set(self, "@columns", array);
+
+                return array;
+            }
+            catch (SQLException & e)
+            {
+                rb_raise_nuodb_error(e.getSqlcode(), "Failed to create column info: %s", e.getText());
+            }
+        }
+        else
+        {
+            return columns;
+        }
+    }
+    else
+    {
+        rb_raise(rb_eArgError, "invalid state: result handle nil");
+    }
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *      result.rows -> ary
+ *
+ * Returns an array of rows, each of which is an array of values.
+ *
+ * Note that calling #rows for large result sets is sub-optimal as it will load
+ * the entire dataset into memory. Users should prefer calling #each over #rows.
+ *
+ *      results = statement.results
+ *      ...
+ *      results.rows.each do |row|
+ *          row.each do |value|
+ *              puts value
+ *          end
+ *      end
+ */
+static VALUE
+nuodb_result_rows(VALUE self)
+{
+    trace("nuodb_result_rows");
+    nuodb_result_handle * handle = cast_handle<nuodb_result_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
+    {
+        VALUE rows = rb_iv_get(self, "@rows");
+        if (NIL_P(rows))
+        {
+            try
+            {
+                rows = rb_ary_new();
+
+                while (handle->pointer->next())
+                {
+                    VALUE row = rb_ary_new();
+
+                    NuoDB::ResultSetMetaData * metadata = handle->pointer->getMetaData();
+                    int32_t column_count = metadata->getColumnCount();
+                    for (int32_t column = 1; column < column_count + 1; column++)
+                    {
+                        SqlType type = (SqlType) metadata->getColumnType(column);
+                        rb_ary_push(row, nuodb_get_rb_value(column, type, handle->pointer));
+                    }
+
+                    rb_ary_push(rows, row);
+                }
+
+                rb_iv_set(self, "@rows", rows);
+            }
+            catch (SQLException & e)
+            {
+                rb_raise_nuodb_error(e.getSqlcode(), "Failed to create a rows array: %s", e.getText());
+            }
+        }
+        return rows;
+    }
+    else
+    {
+        rb_raise(rb_eArgError, "invalid state: result handle nil");
+    }
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *      result.each { |tuple| ... }
+ *
+ * Invokes the block for each tuple in the result set.
+ *
+ *      connection.prepare select_dml do |select|
+ *          ...
+ *          if select.execute
+ *              select.results.each do |row|
+ *                  ...
+ *              end
+ *          end
+ *      end
+ */
+static VALUE
+nuodb_result_each(VALUE self)
+{
+    trace("nuodb_result_each");
+    nuodb_result_handle * handle = cast_handle<nuodb_result_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
+    {
+        VALUE rows = rb_iv_get(self, "@rows");
+        if (NIL_P(rows))
+        {
+            while (handle->pointer->next())
+            {
+                VALUE array = rb_ary_new();
+
+                NuoDB::ResultSetMetaData * metadata = handle->pointer->getMetaData();
+                int32_t column_count = metadata->getColumnCount();
+                for (int32_t column = 1; column < column_count + 1; column++)
+                {
+                    SqlType type = (SqlType) metadata->getColumnType(column);
+                    rb_ary_push(array, nuodb_get_rb_value(column, type, handle->pointer));
+                }
+
+                rb_yield(array);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < RARRAY_LEN(rows); i++)
+            {
+                rb_yield(rb_ary_entry(rows, i));
+            }
+        }
+        return self;
+    }
+    return Qnil;
 }
 
-//------------------------------------------------------------------------------
+static
+void nuodb_define_result_api()
+{
+    /*
+     * A Result object maintains a connection to a specific database. SQL
+     * statements are executed and results are returned within the context of
+     * a connection.
+     */
+    nuodb_result_klass = rb_define_class_under(m_nuodb, "Result", rb_cObject);
+    rb_include_module(nuodb_result_klass, rb_mEnumerable);
+
+    rb_define_attr(nuodb_result_klass, "columns", 1, 0);
+    rb_define_attr(nuodb_result_klass, "rows", 1, 0);
+
+    // DBI
+
+    rb_define_method(nuodb_result_klass, "each", RUBY_METHOD_FUNC(nuodb_result_each), 0);
+    rb_define_method(nuodb_result_klass, "columns", RUBY_METHOD_FUNC(nuodb_result_columns), 0);
+    rb_define_method(nuodb_result_klass, "rows", RUBY_METHOD_FUNC(nuodb_result_rows), 0);
+    //rb_define_method(nuodb_result_klass, "finish", RUBY_METHOD_FUNC(nuodb_result_finish), 0);
+}
+
+//------------------------------------------------------------------------------
+
+static
+VALUE nuodb_statement_free_protect(VALUE value)
+{
+    trace("nuodb_statement_free_protect");
+    nuodb_statement_handle * handle = reinterpret_cast<nuodb_statement_handle*>(value);
+    if (handle != NULL)
+    {
+        if (handle->pointer != NULL)
+        {
+            try
+            {
+                log(INFO, "closing statement");
+                handle->pointer->close();
+                handle->pointer = NULL;
+            }
+            catch (SQLException & e)
+            {
+                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close statement: %s", e.getText());
+            }
+        }
+    }
+    return Qnil;
+}
+
+static
+void nuodb_statement_free(void * ptr)
+{
+    trace("nuodb_statement_free");
+    if (ptr != NULL)
+    {
+        int exception = 0;
+        rb_protect(nuodb_statement_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
+    }
+}
+
+static
+void nuodb_statement_mark(void * ptr)
+{
+    trace("nuodb_statement_mark");
+
+    nuodb_statement_handle * handle = static_cast<nuodb_statement_handle *>(ptr);
+    rb_gc_mark(handle->parent);
+}
 
-void WrapStatement::init(VALUE module)
+static
+void nuodb_statement_decr_reference_count(void * ptr)
 {
-    INIT_TYPE("Statement");
-    DEFINE_METHOD(close, 0);
-    DEFINE_METHOD(execute, 1);
-    DEFINE_METHOD(executeQuery, 1);
-    DEFINE_METHOD(executeUpdate, 1);
-    DEFINE_METHOD(getResultSet, 0);
-    DEFINE_METHOD(getUpdateCount, 0);
-    DEFINE_METHOD(getGeneratedKeys, 0);
+    trace("nuodb_statement_decr_reference_count");
+    decr_reference_count(static_cast<nuodb_statement_handle *>(ptr));
+}
+
+/*
+ * call-seq:
+ *  finish()
+ *
+ * Releases the statement and any associated resources.
+ */
+static
+VALUE nuodb_statement_finish(VALUE self)
+{
+    trace("nuodb_statement_finish");
+    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);//reinterpret_cast<nuodb_statement_handle*>(value);
+    nuodb_statement_free(handle);
+//    if (handle != NULL)
+//    {
+//        if (handle->pointer != NULL)
+//        {
+//            try
+//            {
+//                log(INFO, "closing statement");
+//                handle->pointer->close();
+//                handle->pointer = NULL;
+//            }
+//            catch (SQLException & e)
+//            {
+//                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close statement: %s", e.getText());
+//            }
+//        }
+//    }
+    return Qnil;
+//
+//    if (ENABLE_CLOSE_HOOK)
+//    {
+//        nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+//        if (handle != NULL && handle->pointer != NULL)
+//        {
+//            nuodb_statement_decr_reference_count(handle);
+//        }
+//        else
+//        {
+//            rb_raise(rb_eArgError, "invalid state: statement handle nil");
+//        }
+//    }
+//    return Qnil;
 }
 
-VALUE WrapStatement::close(VALUE self)
+static
+VALUE nuodb_statement_initialize(VALUE parent)
 {
-    try
+    trace("nuodb_statement_initialize");
+
+    nuodb_connection_handle * parent_handle = cast_handle<nuodb_connection_handle>(parent);
+    if (parent_handle != NULL && parent_handle->pointer != NULL)
     {
-        asPtr(self)->close();
-        return Qnil;
+        NuoDB::Statement * statement = NULL;
+        try
+        {
+            statement = parent_handle->pointer->createStatement();
+        }
+        catch (SQLException & e)
+        {
+            log(ERROR, "rb_raise");
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to create statement: %s", e.getText());
+        }
+
+        nuodb_statement_handle * handle = ALLOC(nuodb_statement_handle);
+
+        handle->free_func = RUBY_DATA_FUNC(&nuodb_statement_free);
+        handle->atomic = 0;
+        handle->parent = parent;
+        handle->parent_handle = parent_handle;
+        handle->pointer = statement;
+        incr_reference_count(handle);
+        assert(handle->atomic = 1);
+        VALUE self = Data_Wrap_Struct(nuodb_statement_klass, nuodb_statement_mark, nuodb_statement_decr_reference_count, handle);
+        if (!rb_block_given_p()) {
+            trace("nuodb_statement_initialize: no block");
+            track_ref_count("ALLOC STMT S", cast_handle<nuodb_handle>(self));
+            return self;
+        }
+
+        trace("nuodb_statement_initialize: begin block");
+
+        int exception = 0;
+        VALUE result = rb_protect(rb_yield, self, &exception);
+
+        trace("nuodb_statement_initialize: end block");
+
+        // n.b. don't do this as it may introduce crashes of the ruby process !!!
+        //nuodb_statement_finish(self);
+
+        trace("nuodb_statement_initialize: auto finish");
+
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
+        else
+        {
+            return result;
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapStatement::execute(VALUE self, VALUE sqlValue)
+/*
+ * call-seq:
+ *  execute(sql) -> Bool
+ *
+ * Executes a statement.
+ *
+ * Returns true if the result is a Result object; returns false if the result is
+ * an update count or there is no result. For the latter case, count() should be
+ * called next, for the former case each() should be called.
+ */
+static
+VALUE nuodb_statement_execute(VALUE self, VALUE sql)
 {
-    const char* sql = StringValuePtr(sqlValue);
-    try
+    if (TYPE(sql) != T_STRING)
     {
-        return AS_QBOOL(asPtr(self)->execute(sql, NuoDB::RETURN_GENERATED_KEYS ));
+        rb_raise(rb_eTypeError, "wrong sql argument type %s (String expected)", rb_class2name(CLASS_OF(sql)));
     }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL statement (\"%s\"): %s", sql, e.getText());
-    }
-}
 
-VALUE WrapStatement::executeQuery(VALUE self, VALUE sqlValue)
-{
-    const char* sql = StringValuePtr(sqlValue);
-    try
+    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return WrapResultSet::wrap(asPtr(self)->executeQuery(sql));
+        try
+        {
+            return AS_QBOOL(handle->pointer->execute(StringValuePtr(sql),
+                NuoDB::RETURN_GENERATED_KEYS));
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL query statement (\"%s\"): %s", sql, e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapStatement::executeUpdate(VALUE self, VALUE sqlValue)
+/*
+ * call-seq:
+ *  count() -> Number
+ *
+ * Returns the update count for an update statement.
+ */
+static
+VALUE nuodb_statement_update_count(VALUE self)
 {
-    const char* sql = StringValuePtr(sqlValue);
-    try
+    trace("nuodb_statement_update_count");
+
+    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return INT2NUM(asPtr(self)->executeUpdate(sql));
+        try
+        {
+            return INT2NUM(handle->pointer->getUpdateCount());
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the update count for the statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL update statement (\"%s\"): %s", sql, e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapStatement::getResultSet(VALUE self)
+/*
+ * call-seq:
+ *  results() -> Results
+ *
+ * Retrieves a result set containing rows for the related query.
+ */
+static VALUE nuodb_statement_results(VALUE self)
 {
-    try
+    trace("nuodb_statement_results");
+
+    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return WrapResultSet::wrap(asPtr(self)->getResultSet());
+        try
+        {
+            return nuodb_result_alloc(self, handle->pointer->getResultSet(), handle->pointer->getConnection());
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the result set for the statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get statement result set: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapStatement::getUpdateCount(VALUE self)
+/*
+ * call-seq:
+ *  generated_keys() -> Results
+ *
+ * Retrieves a result set containing the generated keys related to the
+ * previously executed insert.
+ */
+static VALUE nuodb_statement_generated_keys(VALUE self)
 {
-    try
+    trace("nuodb_statement_generated_keys");
+
+    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return INT2NUM(asPtr(self)->getUpdateCount());
+        try
+        {
+            // this hack should not have been necessary; it should never have
+            // returned null, this is a product defect.
+            ResultSet * results = handle->pointer->getGeneratedKeys();
+            if (results != NULL)
+            {
+                return nuodb_result_alloc(self, results, handle->pointer->getConnection());
+            }
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the generated keys for the statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get update count for statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapStatement::getGeneratedKeys(VALUE self)
+static
+void nuodb_define_statement_api()
 {
-    try
-    {
-        return WrapResultSet::wrap(asPtr(self)->getGeneratedKeys());
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get generated keys for statement: %s", e.getText());
-    }
+    /*
+     * Document-class: NuoDB::Statement
+     *
+     * A Statement object maintains a connection to a specific database. SQL
+     * statements are executed and results are returned within the context of
+     * a connection.
+     */
+    nuodb_statement_klass = rb_define_class_under(m_nuodb, "Statement", rb_cObject);
+
+    // DBI
+
+    rb_define_method(nuodb_statement_klass, "execute", RUBY_METHOD_FUNC(nuodb_statement_execute), 1);
+    //rb_define_method(nuodb_statement_klass, "finish", RUBY_METHOD_FUNC(nuodb_statement_finish), 0);
+
+    // NUODB EXTENSIONS
+
+    rb_define_method(nuodb_statement_klass, "count", RUBY_METHOD_FUNC(nuodb_statement_update_count), 0);
+    rb_define_method(nuodb_statement_klass, "generated_keys", RUBY_METHOD_FUNC(nuodb_statement_generated_keys), 0);
+    rb_define_method(nuodb_statement_klass, "results", RUBY_METHOD_FUNC(nuodb_statement_results), 0);
 }
 
 //------------------------------------------------------------------------------
 
-void WrapPreparedStatement::init(VALUE module)
-{
-    INIT_TYPE("PreparedStatement");
-    DEFINE_METHOD(close, 0);
-    DEFINE_METHOD(setBoolean, 2);
-    DEFINE_METHOD(setInteger, 2);
-    DEFINE_METHOD(setDouble, 2);
-    DEFINE_METHOD(setString, 2);
-    DEFINE_METHOD(setTime, 2);
-    DEFINE_METHOD(execute, 0);
-    DEFINE_METHOD(executeQuery, 0);
-    DEFINE_METHOD(executeUpdate, 0);
-    DEFINE_METHOD(getResultSet, 0);
-    DEFINE_METHOD(getUpdateCount, 0);
-    DEFINE_METHOD(getGeneratedKeys, 0);
+static
+VALUE nuodb_prepared_statement_free_protect(VALUE value)
+{
+    trace("nuodb_prepared_statement_free_protect");
+    nuodb_prepared_statement_handle * handle = reinterpret_cast<nuodb_prepared_statement_handle *>(value);
+    track_ref_count("PS FREE PROTECT", handle);
+    if (handle != NULL)
+    {
+        if (handle->pointer != NULL)
+        {
+            try
+            {
+                log(INFO, "closing prepared statement");
+                handle->pointer->close();
+                handle->pointer = NULL;
+            }
+            catch (SQLException & e)
+            {
+                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close statement: %s", e.getText());
+            }
+        }
+    }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::close(VALUE self)
+static
+void nuodb_prepared_statement_free(void * ptr)
 {
-    try
-    {
-        asPtr(self)->close();
-        return Qnil;
-    }
-    catch (SQLException & e)
+    trace("nuodb_prepared_statement_free");
+
+    if (ptr != NULL)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close prepared statement: %s", e.getText());
+        int exception = 0;
+        rb_protect(nuodb_prepared_statement_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
     }
 }
 
-VALUE WrapPreparedStatement::setTime(VALUE self, VALUE indexValue, VALUE valueValue)
+static
+void nuodb_prepared_statement_mark(void * ptr)
 {
-    int32_t index = NUM2UINT(indexValue);
-    struct timeval tv = rb_time_timeval(valueValue);
+    trace("nuodb_prepared_statement_mark");
 
-    SqlDate d( (((int64_t)tv.tv_sec)* 1000)+ (((int64_t)tv.tv_usec)/ 1000));
-    try
-    {
-        asPtr(self)->setDate(index, &d);
-        return Qnil;
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set prepared statement setTime(%d, %lld) failed: %s",
-            index, d.getMilliseconds(), e.getText());
-    }
+    nuodb_prepared_statement_handle * handle = static_cast<nuodb_prepared_statement_handle *>(ptr);
+    rb_gc_mark(handle->parent);
 }
 
-VALUE WrapPreparedStatement::setBoolean(VALUE self, VALUE indexValue, VALUE valueValue)
+static
+void nuodb_prepared_statement_decr_reference_count(nuodb_handle * handle)
 {
-    int32_t index = NUM2UINT(indexValue);
-    bool value = valueValue ? true : false;
-    try
-    {
-        asPtr(self)->setInt(index, value);
-        return Qnil;
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set prepared statement boolean value (%d, %s): %s",
-            index, (value ? "true" : "false"), e.getText());
-    }
+    trace("nuodb_prepared_statement_decr_reference_count");
+    decr_reference_count(handle);
 }
 
-VALUE WrapPreparedStatement::setInteger(VALUE self, VALUE indexValue, VALUE valueValue)
+/*
+ * call-seq:
+ *  finish()
+ *
+ * Releases the prepared statement and any associated resources.
+ */
+static
+VALUE nuodb_prepared_statement_finish(VALUE self)
+{
+    trace("nuodb_prepared_statement_finish");
+    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);//reinterpret_cast<nuodb_prepared_statement_handle *>(value);
+    track_ref_count("FINISH PSTMT", handle);
+    nuodb_prepared_statement_free(handle);
+//    if (handle != NULL)
+//    {
+//        if (handle->pointer != NULL)
+//        {
+//            try
+//            {
+//                track_ref_count("CLOSE PSTMT", handle);
+//                log(INFO, "closing prepared statement");
+//                handle->pointer->close();
+//                handle->pointer = NULL;
+//            }
+//            catch (SQLException & e)
+//            {
+//                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close statement: %s", e.getText());
+//            }
+//        }
+//    }
+    return Qnil;
+//
+//    if (ENABLE_CLOSE_HOOK)
+//    {
+//        nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+//        if (handle != NULL && handle->pointer != NULL)
+//        {
+//            nuodb_prepared_statement_decr_reference_count(handle);
+//        }
+//        else
+//        {
+//            rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
+//        }
+//    }
+//    return Qnil;
+}
+
+static
+VALUE nuodb_prepared_statement_initialize(VALUE parent, VALUE sql)
 {
-    int32_t index = NUM2UINT(indexValue);
-    int32_t value = NUM2INT(valueValue);
-    try
-    {
-        asPtr(self)->setInt(index, value);
-        return Qnil;
-    }
-    catch (SQLException & e)
+    trace("nuodb_prepared_statement_initialize");
+
+    if (TYPE(sql) != T_STRING)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set prepared statement integer value (%d, %d): %s", index, value, e.getText());
+        rb_raise(rb_eTypeError, "wrong sql argument type %s (String expected)", rb_class2name(CLASS_OF(sql)));
     }
-}
 
-VALUE WrapPreparedStatement::setDouble(VALUE self, VALUE indexValue, VALUE valueValue)
-{
-    int32_t index = NUM2UINT(indexValue);
-    double value = NUM2DBL(valueValue);
-    try
+    nuodb_connection_handle * parent_handle = cast_handle<nuodb_connection_handle>(parent);
+    if (parent_handle != NULL && parent_handle->pointer != NULL)
     {
-        asPtr(self)->setDouble(index, value);
-        return Qnil;
+        NuoDB::PreparedStatement * statement = NULL;
+        try
+        {
+            statement = parent_handle->pointer->prepareStatement(StringValuePtr(sql),
+                    NuoDB::RETURN_GENERATED_KEYS);
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to create prepared statement (%s): %s", sql, e.getText());
+        }
+
+        nuodb_prepared_statement_handle * handle = ALLOC(struct nuodb_prepared_statement_handle);
+        handle->free_func = RUBY_DATA_FUNC(&nuodb_prepared_statement_free);
+        handle->atomic = 0;
+        handle->parent = parent;
+        handle->parent_handle = parent_handle;
+        handle->pointer = statement;
+        incr_reference_count(handle);
+        assert(handle->atomic == 1);
+        VALUE self = Data_Wrap_Struct(nuodb_prepared_statement_klass, nuodb_prepared_statement_mark, nuodb_prepared_statement_decr_reference_count, handle);
+
+        if (!rb_block_given_p()) {
+            trace("nuodb_prepared_statement_initialize: no block");
+
+            return self;
+        }
+
+        trace("nuodb_prepared_statement_initialize: begin block");
+
+        int exception = 0;
+        VALUE result = rb_protect(rb_yield, self, &exception);
+
+        trace("nuodb_prepared_statement_initialize: end block");
+
+        // n.b. don't do this as it may introduce crashes of the ruby process !!!
+        //nuodb_prepared_statement_finish(self);
+
+        trace("nuodb_prepared_statement_initialize: auto finish");
+
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
+        else
+        {
+            return result;
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set prepared statement double value (%d, %g): %s", index, value, e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::setString(VALUE self, VALUE indexValue, VALUE valueValue)
+static
+void raise_unsupported_type_at_index(char const * type_name, int32_t index)
 {
-    int32_t index = NUM2UINT(indexValue);
-    char const* value = RSTRING_PTR(valueValue);
-    try
-    {
-        asPtr(self)->setString(index, value);
-        return Qnil;
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set prepared statement string value (%d, \"%s\"): %s", index, value, e.getText());
-    }
+    rb_raise(rb_eTypeError, "unsupported type %s at %d", type_name, index);
 }
 
-VALUE WrapPreparedStatement::execute(VALUE self)
+/*
+ * call-seq:
+ *  bind_param(param, value)
+ *
+ * Attempts to bind the value to this statement as the parameter number specified.
+ *
+ *  connection.prepare insert_dml do |statement|
+ *      statement.bind_param(1, "Joe Smith")
+ *      statement.execute
+ *  end  #=> implicit statement.finish
+ */
+static
+VALUE nuodb_prepared_statement_bind_param(VALUE self, VALUE param, VALUE value)
 {
+    trace("nuodb_prepared_statement_bind_param");
+
+    if (TYPE(param) != T_FIXNUM)
+    {
+        rb_raise(rb_eTypeError, "index must be a number");
+    }
+    int32_t index = NUM2UINT(param);
+
+    NuoDB::PreparedStatement * statement = cast_pointer_member<
+                                           nuodb_prepared_statement_handle, NuoDB::PreparedStatement>(self);
+
     try
     {
-        return AS_QBOOL(asPtr(self)->execute());
+        switch (TYPE(value))
+        {
+        case T_FLOAT: // 0x04
+            {
+                log(DEBUG, "supported: T_FLOAT");
+                double real_value = NUM2DBL(value);
+                statement->setDouble(index, real_value);
+            }
+            break;
+        case T_STRING: // 0x05
+            {
+                log(DEBUG, "supported: T_STRING");
+                char const * real_value = RSTRING_PTR(value);
+                statement->setString(index, real_value);
+            }
+            break;
+        case T_NIL: // 0x11
+            {
+                log(DEBUG, "supported: T_NIL");
+                statement->setNull(index, 0);
+            }
+            break;
+        case T_TRUE: // 0x12
+            {
+                log(DEBUG, "supported: T_TRUE");
+                statement->setBoolean(index, true);
+            }
+            break;
+        case T_FALSE: // 0x13
+            {
+                log(DEBUG, "supported: T_FALSE");
+                statement->setBoolean(index, false);
+            }
+            break;
+        case T_FIXNUM: // 0x15
+            {
+                log(DEBUG, "supported: T_FIXNUM");
+                int64_t real_value = NUM2LONG(value);
+                statement->setLong(index, real_value);
+            }
+            break;
+        case T_DATA: // 0x22
+            {
+                log(DEBUG, "supported: T_DATA");
+                if (rb_obj_is_instance_of(value, rb_cTime))
+                {
+                    log(DEBUG, "supported Time");
+                    VALUE sec = rb_funcall(value, rb_intern("tv_sec"), 0);
+                    //VALUE offset = rb_funcall(value, rb_intern("utc_offset"), 0);
+                    VALUE usec = rb_funcall(value, rb_intern("tv_usec"), 0);
+                    SqlTimestamp sqlTimestamp(NUM2INT(sec), NUM2INT(usec) * 1000); //  + NUM2INT(offset)
+                    statement->setTimestamp(index, &sqlTimestamp);
+                    break;
+                }
+                VALUE cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+                if (rb_obj_is_instance_of(value, cDate))
+                {
+                    log(DEBUG, "supported Date");
+                    VALUE time = rb_funcall(value, rb_intern("to_time"), 0);
+                    VALUE sec = rb_funcall(time, rb_intern("tv_sec"), 0);
+                    //VALUE offset = rb_funcall(time, rb_intern("utc_offset"), 0);
+                    VALUE usec = rb_funcall(time, rb_intern("tv_usec"), 0);
+                    SqlTimestamp sqlTimestamp(NUM2LONG(sec), NUM2INT(usec) * 1000);//  + NUM2INT(offset)
+                    statement->setTimestamp(index, &sqlTimestamp);
+                    break;
+                }
+                break;
+            }
+        case T_OBJECT: // 0x01
+            {
+                log(WARN, "unsupported: T_OBJECT");
+                raise_unsupported_type_at_index("T_OBJECT", index);
+            }
+            break;
+        case T_BIGNUM: // 0x0a
+            {
+                log(DEBUG, "supported: T_BIGNUM");
+                int64_t real_value = NUM2LONG(value);
+                statement->setLong(index, real_value);
+            }
+            break;
+        case T_ARRAY: // 0x07
+            {
+                log(WARN, "unsupported: T_ARRAY");
+                raise_unsupported_type_at_index("T_ARRAY", index);
+            }
+            break;
+        case T_HASH: // 0x08
+            {
+                log(WARN, "unsupported: T_HASH");
+                raise_unsupported_type_at_index("T_HASH", index);
+            }
+            break;
+        case T_STRUCT: // 0x09
+            {
+                log(WARN, "unsupported: T_STRUCT");
+                raise_unsupported_type_at_index("T_STRUCT", index);
+            }
+            break;
+        case T_FILE: // 0x0e
+            {
+                log(WARN, "unsupported: T_FILE");
+                raise_unsupported_type_at_index("T_FILE", index);
+            }
+            break;
+        case T_MATCH: // 0x23
+            {
+                log(WARN, "unsupported: T_MATCH");
+                raise_unsupported_type_at_index("T_MATCH", index);
+            }
+            break;
+        case T_SYMBOL: // 0x24
+            {
+                log(WARN, "unsupported: T_SYMBOL");
+                raise_unsupported_type_at_index("T_SYMBOL", index);
+                break;
+            }
+            break;
+        default:
+            rb_raise(rb_eTypeError, "unsupported type: %d", TYPE(value));
+            break;
+        }
     }
     catch (SQLException & e)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL prepared statement: %s", e.getText());
+        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set prepared statement parameter(%d, %lld) failed: %s",
+                             index, param, e.getText());
     }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::executeQuery(VALUE self)
+/*
+ * call-seq:
+ *  bind_params(*binds)
+ *
+ * Attempts to bind the list of values successively using bind_param.
+ *
+ *  connection.prepare insert_dml do |statement|
+ *      statement.bind_params([56, 6.7, "String", Date.new(2001, 12, 3), Time.new])
+ *      statement.execute
+ *  end  #=> implicit statement.finish
+ */
+static
+VALUE nuodb_prepared_statement_bind_params(VALUE self, VALUE array)
 {
-    try
+    trace("nuodb_prepared_statement_bind_params");
+
+    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return WrapResultSet::wrap(asPtr(self)->executeQuery());
+        for (int i = 0; i < RARRAY_LEN(array); ++i)
+        {
+            VALUE value = RARRAY_PTR(array)[i];
+            nuodb_prepared_statement_bind_param(self, UINT2NUM(i+1), value);
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL query prepared statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::executeUpdate(VALUE self)
+/*
+ * call-seq:
+ *  execute() -> Bool
+ *
+ * Executes a prepared statement. Returns true if the result is a Result object;
+ * returns false if the result is an update count or there is no result. For the
+ * latter case, count() should be called next, for the former case each() should
+ * be called.
+ */
+static
+VALUE nuodb_prepared_statement_execute(VALUE self)
 {
-    try
+    trace("nuodb_prepared_statement_execute");
+
+    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return INT2NUM(asPtr(self)->executeUpdate());
+        try
+        {
+            return AS_QBOOL(handle->pointer->execute());
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL prepared statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to execute SQL update prepared statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::getResultSet(VALUE self)
+/*
+ * call-seq:
+ *  count() -> Number
+ *
+ * Returns the update count for an update statement.
+ */
+static
+VALUE nuodb_prepared_statement_update_count(VALUE self)
 {
-    try
+    trace("nuodb_prepared_statement_update_count");
+
+    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return WrapResultSet::wrap(asPtr(self)->getResultSet());
+        try
+        {
+            return INT2NUM(handle->pointer->getUpdateCount());
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the update count for the prepared statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the result set for the prepared statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::getUpdateCount(VALUE self)
+/*
+ * call-seq:
+ *  results() -> Results
+ *
+ * Retrieves a result set containing rows for the related query.
+ */
+static VALUE nuodb_prepared_statement_results(VALUE self)
 {
-    try
+    trace("nuodb_prepared_statement_results");
+
+    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return INT2NUM(asPtr(self)->getUpdateCount());
+        try
+        {
+            return nuodb_result_alloc(self, handle->pointer->getResultSet(), handle->pointer->getConnection());
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the result set for the prepared statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the update count for the prepared statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapPreparedStatement::getGeneratedKeys(VALUE self)
+/*
+ * call-seq:
+ *  generated_keys() -> Results
+ *
+ * Retrieves a result set containing the generated keys related to the
+ * previously executed insert.
+ */
+static VALUE nuodb_prepared_statement_generated_keys(VALUE self)
 {
-    try
+    trace("nuodb_prepared_statement_generated_keys");
+
+    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return WrapResultSet::wrap(asPtr(self)->getGeneratedKeys());
+        try
+        {
+            // this hack should not have been necessary; it should never have
+            // returned null, this is a product defect.
+            ResultSet * results = handle->pointer->getGeneratedKeys();
+            if (results != NULL)
+            {
+                return nuodb_result_alloc(self, results, handle->pointer->getConnection());
+            }
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the generated keys for the prepared statement: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the generated keys for the prepared statement: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
+    return Qnil;
 }
 
-//------------------------------------------------------------------------------
-
-void WrapConnection::init(VALUE module)
+static
+void nuodb_define_prepared_statement_api()
 {
-    type = rb_define_class_under(module, "Connection", rb_cObject);
+    /*
+     * Document-class: NuoDB::PreparedStatement
+     *
+     * A PreparedStatement object maintains a connection to a specific database.
+     * SQL statements are executed and results are returned within the context of a
+     * connection.
+     */
+    nuodb_prepared_statement_klass = rb_define_class_under(m_nuodb, "PreparedStatement", rb_cObject);
 
     // DBI
 
-    // todo add .columns, or not? If we did: .columns(table_name)
-    // todo and tie this into the SchemaCache on the Ruby side.
-    rb_define_method(type, "commit", RUBY_METHOD_FUNC(commit), 0);
-    rb_define_method(type, "disconnect", RUBY_METHOD_FUNC(close), 0);
-    rb_define_method(type, "ping", RUBY_METHOD_FUNC(ping), 0);
-    rb_define_method(type, "prepare", RUBY_METHOD_FUNC(createPreparedStatement), 1);
-    rb_define_method(type, "rollback", RUBY_METHOD_FUNC(rollback), 0);
-    // todo add .tables, definitely!
+    rb_define_method(nuodb_prepared_statement_klass, "bind_param", RUBY_METHOD_FUNC(nuodb_prepared_statement_bind_param), 2);
+    rb_define_method(nuodb_prepared_statement_klass, "bind_params", RUBY_METHOD_FUNC(nuodb_prepared_statement_bind_params), 1);
+    rb_define_method(nuodb_prepared_statement_klass, "execute", RUBY_METHOD_FUNC(nuodb_prepared_statement_execute), 0);
+    //rb_define_method(nuodb_prepared_statement_klass, "finish", RUBY_METHOD_FUNC(nuodb_prepared_statement_finish), 0);
 
     // NUODB EXTENSIONS
 
-    rb_define_method(type, "autocommit=", RUBY_METHOD_FUNC(setAutoCommit), 1);
-    rb_define_method(type, "autocommit?", RUBY_METHOD_FUNC(hasAutoCommit), 0);
+    rb_define_method(nuodb_prepared_statement_klass, "count", RUBY_METHOD_FUNC(nuodb_prepared_statement_update_count), 0);
+    rb_define_method(nuodb_prepared_statement_klass, "generated_keys", RUBY_METHOD_FUNC(nuodb_prepared_statement_generated_keys), 0);
+    rb_define_method(nuodb_prepared_statement_klass, "results", RUBY_METHOD_FUNC(nuodb_prepared_statement_results), 0);
+}
+
+//------------------------------------------------------------------------------
 
-    // DEPRECATED, going away shortly...
+/*
+ * Class NuoDB::Connection
+ */
 
-    // todo use .new and .initialize instead...
-    DEFINE_SINGLE(createSqlConnection, 4);
-    DEFINE_METHOD(createStatement, 0);
-    DEFINE_METHOD(createPreparedStatement, 1);
-    DEFINE_METHOD(setAutoCommit, 1);
-    DEFINE_METHOD(hasAutoCommit, 0);
-    DEFINE_METHOD(getMetaData, 0);
-    DEFINE_METHOD(close, 0);
-    DEFINE_METHOD(getSchema, 0);
+static
+VALUE nuodb_connection_free_protect(VALUE value)
+{
+    trace("nuodb_connection_free_protect");
+
+    nuodb_connection_handle * handle = reinterpret_cast<nuodb_connection_handle *>(value);
+    track_ref_count("FREE CONN CHECK", handle);
+    if (handle != NULL)
+    {
+        track_ref_count("FREE CONN", handle);
+        if (handle->pointer != NULL)
+        {
+            try
+            {
+                track_ref_count("CLOSE CONN", handle);
+                log(INFO, "closing connection");
+                handle->pointer->close();
+                handle->pointer = NULL;
+            }
+            catch (SQLException & e)
+            {
+                log(DEBUG, "rb_raise");
+                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close connection: %s", e.getText());
+            }
+        }
+    }
+    return Qnil;
 }
 
-VALUE WrapConnection::getSchema(VALUE self)
+static
+void nuodb_connection_free(void * ptr)
 {
-    try
-    {
-        return rb_str_new2(asPtr(self)->getSchema());
-    }
-    catch (SQLException & e)
+    trace("nuodb_connection_free");
+    if (ptr != NULL)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get schema for connection: %s", e.getText());
+        int exception = 0;
+        rb_protect(nuodb_connection_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
+        if (exception)
+        {
+            rb_jump_tag(exception);
+        }
     }
 }
 
-VALUE WrapConnection::close(VALUE self)
+static
+void nuodb_connection_mark(void * ptr)
 {
-    try
-    {
-        asPtr(self)->close();
-        return Qnil;
-    }
-    catch (SQLException & e)
-    {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully disconnect connection: %s", e.getText());
+    trace("nuodb_connection_mark");
+
+    nuodb_connection_handle * handle = static_cast<nuodb_connection_handle *>(ptr);
+    track_ref_count("MARK CONN", handle);
+
+    rb_gc_mark(handle->database);
+    rb_gc_mark(handle->username);
+    rb_gc_mark(handle->password);
+    rb_gc_mark(handle->schema);
+}
+
+static
+void nuodb_connection_decr_reference_count(nuodb_handle * handle)
+{
+    trace("nuodb_connection_decr_reference_count");
+    decr_reference_count(handle);
+}
+
+static
+VALUE nuodb_connection_alloc(VALUE klass)
+{
+    trace("nuodb_connection_alloc");
+
+    nuodb_connection_handle * handle = ALLOC(struct nuodb_connection_handle);
+    handle->database = Qnil;
+    handle->username = Qnil;
+    handle->password = Qnil;
+    handle->schema = Qnil;
+    handle->timezone = Qnil;
+
+    handle->free_func = RUBY_DATA_FUNC(&nuodb_connection_free);
+    handle->atomic = 0;
+    handle->parent = Qnil;
+    handle->parent_handle = 0;
+    handle->pointer = 0;
+    incr_reference_count(handle);
+
+    print_address("[ALLOC] connection", handle);
+
+    return Data_Wrap_Struct(klass, nuodb_connection_mark, nuodb_connection_decr_reference_count, handle);
+}
+
+static void internal_connection_connect_or_raise(nuodb_connection_handle * handle)
+{
+    trace("internal_connection_connect_or_raise");
+
+    if (handle->schema != Qnil)
+    {
+        try
+        {
+            handle->pointer = Connection::create();
+            Properties * props = handle->pointer->allocProperties();
+            props->putValue("user", StringValuePtr(handle->username));
+            props->putValue("password", StringValuePtr(handle->password));
+            props->putValue("schema", StringValuePtr(handle->schema));
+            if (!NIL_P(handle->timezone))
+            {
+                props->putValue("TimeZone", StringValuePtr(handle->timezone));
+            }
+            handle->pointer->openDatabase(StringValuePtr(handle->database), props);
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(),
+                                 "Failed to create database connection (\"%s\", \"%s\", ********, \"%s\"): %s",
+                                 StringValuePtr(handle->database),
+                                 StringValuePtr(handle->username),
+                                 StringValuePtr(handle->schema),
+                                 e.getText());
+        }
+    }
+    else
+    {
+        try
+        {
+            handle->pointer = Connection::create();
+            Properties * props = handle->pointer->allocProperties();
+            props->putValue("user", StringValuePtr(handle->username));
+            props->putValue("password", StringValuePtr(handle->password));
+            if (!NIL_P(handle->timezone))
+            {
+                props->putValue("TimeZone", StringValuePtr(handle->timezone));
+            }
+            handle->pointer->openDatabase(StringValuePtr(handle->database), props);
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(),
+                                 "Failed to create database connection (\"%s\", \"%s\", ********): %s",
+                                 StringValuePtr(handle->database),
+                                 StringValuePtr(handle->username),
+                                 e.getText());
+        }
     }
 }
 
-VALUE WrapConnection::ping(VALUE self)
+/*
+ * call-seq:
+ *  commit()
+ *
+ * Commit the database transaction.
+ *
+ *      NuoDB::Connection.new (hash) do |connection|
+ *          ...
+ *          connection.commit
+ *      end  #=> automatically disconnected connection
+ */
+static VALUE nuodb_connection_commit(VALUE self)
 {
-    try
+    trace("nuodb_connection_commit");
+
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        asPtr(self)->ping();
-        return Qtrue;
+        try
+        {
+            handle->pointer->commit();
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to commit transaction: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        return Qfalse;
+        rb_raise(rb_eArgError, "invalid state: connection handle nil");
     }
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *  disconnect()
+ *
+ * Disconnects the connection.
+ */
+static VALUE nuodb_connection_disconnect(VALUE self)
+{
+    trace("nuodb_connection_disconnect");
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);//;
+    track_ref_count("CONN DISCONNECT", handle);
+    nuodb_connection_free(handle);
+//    if (handle != NULL)
+//    {
+//        track_ref_count("FREE CONN", handle);
+//        if (handle->pointer != NULL)
+//        {
+//            try
+//            {
+//                track_ref_count("CLOSE CONN", handle);
+//                handle->pointer->close();
+//                handle->pointer = NULL;
+//            }
+//            catch (SQLException & e)
+//            {
+//                log(DEBUG, "rb_raise");
+//                rb_raise_nuodb_error(e.getSqlcode(), "Failed to successfully close connection: %s", e.getText());
+//            }
+//        }
+//    }
+    return Qnil;
+//
+//
+//
+//    if (ENABLE_CLOSE_HOOK)
+//    {
+//        nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+//        if (handle != NULL && handle->pointer != NULL)
+//        {
+//            nuodb_connection_decr_reference_count(handle);
+//        }
+//        else
+//        {
+//            rb_raise(rb_eArgError, "invalid state: connection handle nil");
+//        }
+//    }
+//    return Qnil;
 }
 
-VALUE WrapConnection::createStatement(VALUE self)
+/*
+ * call-seq:
+ *  connection.ping         -> boolean
+ *  connection.connected?   -> boolean
+ *
+ * Returns true if the connection is still alive, otherwise false.
+ *
+ *  connection.connected?   #=> true
+ */
+static VALUE nuodb_connection_ping(VALUE self)
 {
-    try
-    {
-        return WrapStatement::wrap(asPtr(self)->createStatement());
-    }
-    catch (SQLException & e)
+    trace("nuodb_connection_ping");
+
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to create statement: %s", e.getText());
+        try
+        {
+            handle->pointer->ping();
+            return Qtrue;
+        }
+        catch (SQLException & e)
+        {
+        }
     }
+    return Qfalse;
 }
 
-VALUE WrapConnection::createPreparedStatement(VALUE self, VALUE sqlValue)
+/*
+ * call-seq:
+ *  prepare(sql) -> PreparedStatement
+ *
+ * Creates a prepared statement.
+ *
+ *      NuoDB::Connection.new (hash) do |connection|
+ *          connection.prepare 'insert into foo (f1,f2) values (?, ?)' do |statement|
+ *              statement.bind_params [...]
+ *              statement.execute
+ *          end
+ *      end  #=> automatically disconnected connection
+ */
+static VALUE nuodb_connection_prepare(VALUE self, VALUE sql)
 {
-    const char * sql = StringValuePtr(sqlValue);
-    try
+    trace("nuodb_connection_prepare");
+
+    return nuodb_prepared_statement_initialize(self, sql);
+}
+
+/*
+ * call-seq:
+ *  statement -> Statement
+ *
+ * Creates a statement.
+ *
+ * <b>This is a NuoDB-specific extension.</b>
+ *
+ *      NuoDB::Connection.new (hash) do |connection|
+ *          connection.statement do |statement|
+ *              statement.execute sql
+ *          end
+ *      end  #=> automatically disconnected connection
+ */
+static VALUE nuodb_connection_statement(VALUE self)
+{
+    trace("nuodb_connection_statement");
+
+    return nuodb_statement_initialize(self);
+}
+
+/*
+ * call-seq:
+ *  rollback()
+ *
+ * Rollback the database transaction.
+ *
+ *      NuoDB::Connection.new (hash) do |connection|
+ *          ...
+ *          connection.rollback
+ *      end  #=> automatically disconnected connection
+ */
+static VALUE nuodb_connection_rollback(VALUE self)
+{
+    trace("nuodb_connection_rollback");
+
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return WrapPreparedStatement::wrap( asPtr(self)->prepareStatement(sql, NuoDB::RETURN_GENERATED_KEYS));
+        try
+        {
+            handle->pointer->rollback();
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to rollback transaction: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to create prepared statement (%s): %s", sql, e.getText());
+        rb_raise(rb_eArgError, "invalid state: connection handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapConnection::setAutoCommit(VALUE self, VALUE autoCommitValue)
+/*
+ * call-seq:
+ *  autocommit= boolean
+ *
+ * Sets the connections autocommit state.
+ *
+ *      NuoDB::Connection.new (hash) do |connection|
+ *          connection.autocommit = false
+ *          ...
+ *          connection.commit
+ *      end  #=> automatically disconnected connection
+ *
+ * <b>This is a NuoDB-specific extension.</b>
+ */
+static VALUE nuodb_connection_autocommit_set(VALUE self, VALUE value)
 {
-    bool autoCommit = !(RB_TYPE_P(autoCommitValue, T_FALSE) || RB_TYPE_P(autoCommitValue, T_NIL));
-    try
+    trace("nuodb_connection_autocommit_set");
+
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        asPtr(self)->setAutoCommit(autoCommit);
-        return Qnil;
+        bool auto_commit = !(RB_TYPE_P(value, T_FALSE) || RB_TYPE_P(value, T_NIL));
+        try
+        {
+            handle->pointer->setAutoCommit(auto_commit);
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to set autocommit (%d) for connection: %s", auto_commit, e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to set auto-commit (%d) for connection: %s", autoCommit, e.getText());
+        rb_raise(rb_eArgError, "invalid state: connection handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapConnection::hasAutoCommit(VALUE self)
+/*
+ * call-seq:
+ *  autocommit? -> boolean
+ *
+ * Gets the connections autocommit state.
+ *
+ *  unless connection.autocommit? do    #=> false
+ *      connection.commit
+ *  end
+ *
+ * <b>This is a NuoDB-specific extension.</b>
+ */
+static VALUE nuodb_connection_autocommit_get(VALUE self)
 {
-    try
+    trace("nuodb_connection_autocommit_get");
+
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    if (handle != NULL && handle->pointer != NULL)
     {
-        return AS_QBOOL(asPtr(self)->getAutoCommit());
+        try
+        {
+            bool current = handle->pointer->getAutoCommit();
+            return AS_QBOOL(current);
+        }
+        catch (SQLException & e)
+        {
+            rb_raise_nuodb_error(e.getSqlcode(), "Failed to determine autocommit state for connection: %s", e.getText());
+        }
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to determine auto-commit state for connection: %s", e.getText());
+        rb_raise(rb_eArgError, "invalid state: connection handle nil");
     }
+    return Qnil;
 }
 
-VALUE WrapConnection::commit(VALUE self)
+/*
+ * call-seq:
+ *
+ *  Connection.new(key, value, ...) -> new_connection
+ *  Connection.new(key, value, ...) { |connection| block }
+ *
+ * Creates a new connection using the specified connection parameters. In the
+ * first form a new connection is created but the caller is responsible for
+ * calling disconnect. In the second form a new connection is created but the
+ * caller is not responsible for calling disconnect; the connection is
+ * automatically closed after the block exits.
+ *
+ *      NuoDB::Connection.new (
+ *          :database => 'hockey',
+ *          :username => 'gretzky',
+ *          :password => 'goal!',
+ *          :schema   => 'players')     #=> connection
+ *      NuoDB::Connection.new (
+ *          :database => 'hockey',
+ *          :username => 'gretzky',
+ *          :password => 'goal!',
+ *          :schema   => 'players') { |connection| ... }    #=> automatically disconnected connection
+ */
+static VALUE nuodb_connection_initialize(VALUE self, VALUE hash)
 {
-    try
+    trace("nuodb_connection_initialize");
+
+    if (TYPE(hash) != T_HASH)
     {
-        asPtr(self)->commit();
-        return Qnil;
+        rb_raise(rb_eTypeError, "wrong argument type %s (Hash expected)", rb_class2name(CLASS_OF(hash)));
     }
-    catch (SQLException & e)
+
+    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    if (NIL_P(handle->database))
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to commit transaction: %s", e.getText());
+        VALUE value = rb_hash_aref(hash, sym_database);
+        if (value == Qnil)
+        {
+            rb_raise(rb_eArgError, "missing database argument for connection: please specify :database => 'your_db_name'");
+        }
+        if (TYPE(value) != T_STRING)
+        {
+            rb_raise(rb_eTypeError, "wrong database argument type %s (String expected)", rb_class2name(CLASS_OF(value)));
+        }
+        handle->database = value;
     }
-}
-
-VALUE WrapConnection::rollback(VALUE self)
-{
-    try
+    if (handle->username == Qnil)
     {
-        asPtr(self)->rollback();
-        return Qnil;
+        VALUE value = rb_hash_aref(hash, sym_username);
+        if (value == Qnil)
+        {
+            rb_raise(rb_eArgError, "missing username argument for connection: please specify :username => 'your_db_username'");
+        }
+        if (TYPE(value) != T_STRING)
+        {
+            rb_raise(rb_eTypeError, "wrong username argument type %s (String expected)", rb_class2name(CLASS_OF(value)));
+        }
+        handle->username = value;
     }
-    catch (SQLException & e)
+    if (handle->password == Qnil)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to rollback transaction: %s", e.getText());
+        VALUE value = rb_hash_aref(hash, sym_password);
+        if (value == Qnil)
+        {
+            rb_raise(rb_eArgError, "missing password argument for connection: please specify :password => 'your_db_password'");
+        }
+        if (TYPE(value) != T_STRING)
+        {
+            rb_raise(rb_eTypeError, "wrong password argument type %s (String expected)", rb_class2name(CLASS_OF(value)));
+        }
+        handle->password = value;
     }
-}
-
-VALUE WrapConnection::getMetaData(VALUE self)
-{
-    try
+    if (handle->schema == Qnil)
     {
-        return WrapDatabaseMetaData::wrap( asPtr(self)->getMetaData());
+        VALUE value = rb_hash_aref(hash, sym_schema);
+        if (TYPE(value) != T_STRING)
+        {
+            rb_raise(rb_eTypeError, "wrong schema argument type %s (String expected)", rb_class2name(CLASS_OF(value)));
+        }
+        handle->schema = value;
     }
-    catch (SQLException & e)
+    if (handle->timezone == Qnil)
     {
-        rb_raise_nuodb_error(e.getSqlcode(), "Failed to get database metadata: %s", e.getText());
+        VALUE value = rb_hash_aref(hash, sym_timezone);
+        if (value != Qnil)
+        {
+            if (TYPE(value) != T_STRING)
+            {
+                rb_raise(rb_eTypeError, "wrong timezone argument type %s (String expected)", rb_class2name(CLASS_OF(value)));
+            }
+            handle->timezone = value;
+        }
     }
-}
 
-VALUE WrapConnection::createSqlConnection(VALUE self,
-    VALUE databaseValue,
-    VALUE schemaValue,
-    VALUE usernameValue,
-    VALUE passwordValue)
-{
-    char const* database = StringValuePtr(databaseValue);
-    char const* schema = StringValuePtr(schemaValue);
-    char const* username = StringValuePtr(usernameValue);
-    char const* password = StringValuePtr(passwordValue);
+    internal_connection_connect_or_raise(handle);
 
-    try
+    if (!rb_block_given_p()) {
+
+        trace("nuodb_connection_initialize: no block");
+
+        return self;
+    }
+
+    trace("nuodb_connection_initialize: begin block");
+
+    int state = 0;
+    VALUE result = rb_protect(rb_yield, self, &state);
+
+    trace("nuodb_connection_initialize: end block");
+
+    // n.b. don't do this as it may introduce crashes of the ruby process !!!
+    //nuodb_connection_disconnect(self);
+
+    trace("nuodb_connection_initialize: auto disconnect");
+
+    if (state)
     {
-        return WrapConnection::wrap( getDatabaseConnection(database,
-            username,
-            password,
-            1,
-            "schema",
-            schema));
+        rb_jump_tag(state);
     }
-    catch (SQLException & e)
+    else
     {
-        rb_raise_nuodb_error(e.getSqlcode(),
-            "Failed to create database connection (\"%s\", \"%s\", ********, \"%s\"): %s",
-            database,
-            username,
-            schema,
-            e.getText());
+        return result;
     }
+
+    return Qnil;
+}
+
+///*
+// * call-seq:
+// *  tables(schema = nil) -> Results
+// *
+// * Retrieves a result set containing the tables associated to the specified schema,
+// * or if the specified schema is nil, return a result set of tables for the schema
+// * associated with the connection.
+// */
+//static VALUE nuodb_connection_tables(VALUE self, VALUE schema)
+//{
+//    trace("nuodb_connection_tables");
+//
+//    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+//    if (handle != NULL && handle->pointer != NULL)
+//    {
+//        if (schema == Qnil)
+//        {
+//            schema = handle->schema;
+//        }
+////        char const * sql = "SELECT tablename FROM system.tables WHERE schema = ?"
+////        try
+////        {
+////            return nuodb_result_alloc(self, handle->pointer->getGeneratedKeys());
+////        }
+////        catch (SQLException & e)
+////        {
+////            rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the tables keys for the schema: %s", e.getText());
+////        }
+//    }
+//    else
+//    {
+//        rb_raise(rb_eArgError, "invalid state: connection handle nil");
+//    }
+//    return Qnil;
+//}
+
+void nuodb_define_connection_api()
+{
+    /*
+     * Document-class: NuoDB::Connection
+     *
+     * A Connection object maintains a connection to a specific database.
+     * SQL statements are executed and results are returned within the context of a
+     * connection.
+     */
+    nuodb_connection_klass = rb_define_class_under(m_nuodb, "Connection", rb_cObject);
+
+    rb_define_alloc_func(nuodb_connection_klass, nuodb_connection_alloc);
+    rb_define_method(nuodb_connection_klass, "initialize", RUBY_METHOD_FUNC(nuodb_connection_initialize), 1);
+
+    sym_username = ID2SYM(rb_intern("username"));
+    sym_password = ID2SYM(rb_intern("password"));
+    sym_database = ID2SYM(rb_intern("database"));
+    sym_schema = ID2SYM(rb_intern("schema"));
+    sym_timezone = ID2SYM(rb_intern("timezone"));
+
+    // DBI
+
+    rb_define_method(nuodb_connection_klass, "commit", RUBY_METHOD_FUNC(nuodb_connection_commit), 0);
+    //rb_define_method(nuodb_connection_klass, "disconnect", RUBY_METHOD_FUNC(nuodb_connection_disconnect), 0);
+    rb_define_method(nuodb_connection_klass, "ping", RUBY_METHOD_FUNC(nuodb_connection_ping), 0);
+    rb_define_method(nuodb_connection_klass, "prepare", RUBY_METHOD_FUNC(nuodb_connection_prepare), 1);
+    rb_define_method(nuodb_connection_klass, "rollback", RUBY_METHOD_FUNC(nuodb_connection_rollback), 0);
+    // todo add .tables, definitely!
+    // todo add .columns, or not? If we did: .columns(table_name)
+    // todo and tie this into the SchemaCache on the Ruby side.
+
+    // NUODB EXTENSIONS
+
+    //rb_define_method(nuodb_connection_klass, "tables", RUBY_METHOD_FUNC(nuodb_connection_tables), 1);
+    rb_define_method(nuodb_connection_klass, "autocommit=", RUBY_METHOD_FUNC(nuodb_connection_autocommit_set), 1);
+    rb_define_method(nuodb_connection_klass, "autocommit?", RUBY_METHOD_FUNC(nuodb_connection_autocommit_get), 0);
+    rb_define_method(nuodb_connection_klass, "statement", RUBY_METHOD_FUNC(nuodb_connection_statement), 0);
+    rb_define_method(nuodb_connection_klass, "connected?", RUBY_METHOD_FUNC(nuodb_connection_ping), 0);
 }
 
 //------------------------------------------------------------------------------
 
+/*
+ * The NuoDB package provides a Ruby interface to the NuoDB database.
+ */
 extern "C" void Init_nuodb(void)
 {
+    /*
+     * The NuoDB module contains classes and function definitions enabling use
+     * of the NuoDB database.
+     */
     m_nuodb = rb_define_module("NuoDB");
-    c_nuodb_error = rb_const_get(m_nuodb, rb_intern("Error"));
+
+    c_nuodb_error = rb_const_get(m_nuodb, rb_intern("DatabaseError"));
+
     c_error_code_assignment = rb_intern("error_code=");
 
-    WrapConnection::init(m_nuodb);
-    WrapDatabaseMetaData::init(m_nuodb);
-    WrapStatement::init(m_nuodb);
-    WrapPreparedStatement::init(m_nuodb);
-    WrapResultSet::init(m_nuodb);
-    WrapResultSetMetaData::init(m_nuodb);
+    nuodb_define_connection_api();
+
+    nuodb_define_statement_api();
+
+    nuodb_define_prepared_statement_api();
+
+    nuodb_define_result_api();
 }