nuodb 1.0.2 → 1.1

data/.gitignore

@@ -9,3 +9,4 @@ rdoc/
 pkg/
 tmp
 .idea
+.DS_Store

data/.travis.yml

@@ -1,10 +1,15 @@
 language: ruby
 
 rvm:
+  - 2.0.0
   - 1.9.3
 
 env:
-  - NUODB_ROOT=/opt/nuodb
+  - NUODB_ROOT=/opt/nuodb NUODB_VERSION=1.2
+  - NUODB_ROOT=/opt/nuodb NUODB_VERSION=1.1.1
+  - NUODB_ROOT=/opt/nuodb NUODB_VERSION=1.1 
+  - NUODB_ROOT=/opt/nuodb NUODB_VERSION=1.0.2
+  - NUODB_ROOT=/opt/nuodb NUODB_VERSION=1.0.1
 
 notifications:
   recipients:
@@ -13,19 +18,19 @@ notifications:
     - lbayas@nuodb.com
 
 before_install:
-  - wget http://www.nuodb.com/latest/nuodb-1.0.2.linux.x64.deb --output-document=/var/tmp/nuodb.deb
+  - wget http://www.nuodb.com/latest/releases/nuodb-${NUODB_VERSION}.linux.x64.deb --output-document=/var/tmp/nuodb.deb
   - sudo dpkg -i /var/tmp/nuodb.deb
   - sleep 2
 
 before_script:
   - ${NUODB_ROOT}/bin/nuodb --chorus test --password bar --dba-user dba --dba-password baz --verbose debug --archive /var/tmp/nuodb --initialize --force &
-  - sleep 2
+  - sleep 4
   - ${NUODB_ROOT}/bin/nuodb --chorus test --password bar --dba-user dba --dba-password baz &
-  - sleep 2
+  - sleep 4
   - echo "create user cloud password 'user';" | ${NUODB_ROOT}/bin/nuosql test@localhost --user dba --password baz
 
 script:
-  - NUODB_ROOT=/opt/nuodb bundle exec rake spec install
+  - NUODB_ROOT=/opt/nuodb bundle exec rake spec
 
 after_script:
-  - sudo dpkg -r nuodb
+  - sudo dpkg -r nuodb

data/{CONTRIBUTION.rdoc → CONTRIBUTION.md}

@@ -1,20 +1,20 @@
-= Contributing to the Ruby NuoDB Driver
+# Contributing to the Ruby NuoDB Driver
 
-== BUILDING THE GEM
+## BUILDING THE GEM
 
 To compile and test run this command:
 
     rake clean build rdoc spec
 
-== INSTALLING THE GEM
+## INSTALLING THE GEM
 
-    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install nuodb-1.0.2.gem
+    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install nuodb-1.1.gem
 
 Or from the source tree:
 
-    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install pkg/nuodb-1.0.2.gem
+    NUODB_ROOT=/Users/rbuck/tmp/nuodb gem install pkg/nuodb-1.1.gem
 
-== TESTING THE GEM
+## TESTING THE GEM
 
 Start up a minimal chorus as follows:
 
@@ -32,33 +32,34 @@ Run the tests:
 
     rake spec
 
-== PUBLISHING THE GEM
+## PUBLISHING THE GEM
 
-=== TAGGING
+### TAGGING
 
-Tag the product using tags per the SemVer specification; our tags have a v-prefix:
+Tag the product using tags per the SemVer specification; our tags have a
+v-prefix:
 
-    git tag -a v1.0.2 -m "SemVer Version: v1.0.2"
+    git tag -a v1.1 -m "SemVer Version: v1.1"
 
 If you make a mistake, take it back quickly:
 
-    git tag -d v1.0.2
-    git push origin :refs/tags/v1.0.2
+    git tag -d v1.1
+    git push origin :refs/tags/v1.1
 
-===PUBLISHING
+### PUBLISHING
 
 Here are the commands used to publish:
 
-    gem push pkg/nuodb-1.0.2.gem
+    gem push pkg/nuodb-1.1.gem
 
-== INSPECTING THE 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:
+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.2.gem
+    gem unpack pkg/nuodb-1.1.gem
 
-== INSPECTING THE EXPORTED SYMBOLS
+## INSPECTING THE EXPORTED SYMBOLS
 
 To inspec the symbols on Linux:
 

data/Gemfile

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rake'
+gem 'rake', '~>10.1.0'

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    nuodb (1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    haml (3.0.25)
+    hanna-nouveau (0.2.7)
+      haml (= 3.0.25)
+      rdoc (~> 3.1)
+    json (1.8.0)
+    multi_json (1.7.9)
+    optiflag (0.7)
+    rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    ruby-prof (0.13.0)
+    rubydoc (0.0.1)
+      optiflag (~> 0.7)
+    sdoc (0.3.20)
+      json (>= 1.1.3)
+      rdoc (~> 3.10)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  erubis (~> 2.7.0)
+  hanna-nouveau
+  nuodb!
+  rake (~> 10.1.0)
+  rdoc
+  rspec (~> 2.11.0)
+  rspec-core (~> 2.11.0)
+  rspec-expectations (~> 2.11.0)
+  rspec-mocks (~> 2.11.0)
+  ruby-prof
+  rubydoc
+  sdoc
+  simplecov

data/History.txt

@@ -1,3 +1,6 @@
+=== 1.1
+- Refactored C++ code with metadata enhancements
+
 === 1.0.2
 - Fixed each iteration bug
 

data/README.md

@@ -0,0 +1,43 @@
+# Ruby/NuoDB Interface [<img src="https://api.travis-ci.org/nuodb/ruby-nuodb.png?branch=master" alt="Build Status" />](http://travis-ci.org/nuodb/ruby-nuodb) [<img src="https://gemnasium.com/nuodb/ruby-nuodb.png?travis" alt="Dependency Status" />](https://gemnasium.com/nuodb/ruby-nuodb) [<img src="https://codeclimate.com/github/nuodb/ruby-nuodb.png" />](https://codeclimate.com/github/nuodb/ruby-nuodb)
+
+This is the official Ruby Gem for [NuoDB](http://www.nuodb.com/). It wraps the
+NuoDB C++ API, providing a natural API for Ruby.
+
+To use NuoDB with Rails you will also want the [ActiveRecord NuoDB
+Adapter](https://github.com/nuodb/ruby-activerecord-nuodb-adapter)
+
+Note: At this time the Ruby/NuoDB Interface does not support Windows.
+
+## Getting Started
+
+1.  If you haven't already, [Download and Install NuoDB](http://nuodb.com/download-nuodb/)
+
+2.  Install the gem
+
+        gem install nuodb
+
+3.  Use NuoDB in Ruby
+
+        require "nuodb"
+
+        conn = NuoDB::Connection.new(:database => 'test@localhost', :username => 'dba', :password => 'goalie', :schema => 'hockey')
+        stmt = conn.statement
+        stmt.execute("SELECT * FROM hockey")
+        stmt.results.each do |res|
+            puts res.inspect
+        end
+
+
+## More Information
+
+*   [Ruby/NuoDB Interface Rdoc](http://nuodb.github.io/ruby-nuodb/rdoc/)
+*   [NuoDB Community Forum](http://www.nuodb.com/community/forum.php)
+*   [NuoDB Online Documentation](http://www.nuodb.com/community/documentation.php)
+
+
+## Contributing
+
+See [Contribution](CONTRIBUTION.md) for information about contributing to
+the Ruby ActiveRecord NuoDB Adapter.
+
+[![githalytics.com alpha](https://cruel-carlota.pagodabox.com/9acbb24d79760ffb071e5e653305e21e "githalytics.com")](http://githalytics.com/nuodb/ruby-nuodb)

data/Rakefile

@@ -129,7 +129,7 @@ namespace :nuodb do
       case RUBY_PLATFORM
         when /linux/i
           unless File.exists? '/etc/redhat-release'
-            puts %x(wget http://www.nuodb.com/latest/nuodb-1.0-GA.linux.x86_64.deb --output-document=/var/tmp/nuodb.deb)
+            puts %x(wget http://www.nuodb.com/latest/releases/nuodb-1.1.linux.x64.deb --output-document=/var/tmp/nuodb.deb)
             puts %x(sudo dpkg -i /var/tmp/nuodb.deb)
           end
         else

data/ext/nuodb/nuodb.cpp

@@ -36,17 +36,21 @@
 #include <time.h>
 #include <stdio.h>
 #include <typeinfo>
+#include <stdarg.h>
+
+#define NANOS_PER_SECOND 1000000000
+#define NANOS_PER_MICRO 1000
 
 #define HAVE_CXA_DEMANGLE
 
 #ifdef HAVE_CXA_DEMANGLE
 #include <cxxabi.h>
-const char * demangle(const char * name)
+const char* demangle(const char* name)
 {
     char buf[1024];
     size_t size = 1024;
     int status;
-    char * res = abi::__cxa_demangle (name,
+    char* res = abi::__cxa_demangle (name,
         buf, &size, &status);
     return res;
 }
@@ -121,19 +125,19 @@ static const bool ENABLE_CLOSE_HOOK = true;
 
 enum LogLevel
 {
-    ERROR,
-    WARN,
-    INFO,
     TRACE,
     DEBUG,
+    INFO,
+    WARN,
+    ERROR,
     NONE
 };
 
-static LogLevel logLevel = NONE;
+static LogLevel logLevel = ERROR;
 
-static char const * log_level_name(LogLevel level)
+static char const* log_level_name(LogLevel level)
 {
-    char const * level_name = NULL;
+    char const* level_name = NULL;
     switch(level)
     {
     case NONE:
@@ -158,7 +162,7 @@ static char const * log_level_name(LogLevel level)
     return level_name;
 }
 
-static void log(LogLevel level, char const * message)
+static void log(LogLevel level, char const* message)
 {
     if (level >= logLevel)
     {
@@ -166,17 +170,17 @@ static void log(LogLevel level, char const * message)
     }
 }
 
-static void trace(char const * message)
+static void trace(char const* message)
 {
     log(TRACE, message);
 }
 
-static void print_address(char const * context, void * address)
+static void print_address(char const* context, void* address)
 {
     if (DEBUG >= logLevel)
     {
 	    unsigned char *p = (unsigned char *)&address;
-	    int i;
+	    unsigned int i;
 		printf("%s: ", context);
 	    for (i = 0; i < sizeof address; i++)
 	    {
@@ -187,137 +191,35 @@ static void print_address(char const * context, void * address)
 }
 
 // ----------------------------------------------------------------------------
-// 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
-{
-    void * data_handle;
-    unsigned int flags;
-    rb_atomic_t refers;
-
-    callback incr_func;
-    callback decr_func;
-    callback free_func;
-
-    os_entity * parent;
-};
+// H A N D L E S
+//
+//
 
 /*
- * Rules:
+ * Each nuodb client datatype that we need to expose to ruby will be done via a handle object. The handle contains
+ * two kinds of things, a pointer to a client instance and GC handling information. The GC information is there to 
+ * deal with the fact that the nuodb client API requires that things be closed before they are deallocated and that 
+ * the closures happen in a very specific order. Namely, that all result sets are closed before their creating 
+ * statement can be closed. And that all statements are closed before their creating connection may be closed. 
+ * Ruby's GC hooks allow us to hook into the MARK phase so that all objects may mark their parents to prevent that 
+ * out-of-order condition. However, ruby guarantees no particular order when freeing objects determined to be 
+ * garbage. Therefore the GC thread may invoke free on a statement before it's result set even though both are 
+ * garbage and will eventually be freed in the same sweep. Therefore, each handle also has a numUsed reference 
+ * count. On creation, a handle increments its parent's numUsed. On free, a handle decrements its parent's numUsed.
+ * A handle cannot be freed if its numUsed is greater than 0. Therefore, it is the responsibility of every child to 
+ * check if it needs to clean up its parent.
  *
- * 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.
+ * When a handle has finally been deemed to be free-able, the cleanupFunc needs to be called to actually close out 
+ * the handle's client instances.
  */
-struct gc_entity
-{
-    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 */
-
-// ----------------------------------------------------------------------------
-// H A N D L E S
 
 struct nuodb_handle
 {
-    RUBY_DATA_FUNC free_func;
-    rb_atomic_t atomic;
-    nuodb_handle * parent_handle;
-    VALUE parent;
+    bool freePending;                    //GC wants to free us, but we still have some children outstanding
+    void (*cleanupFunc)(nuodb_handle*);  //cleanup function
+
+    int numUsed;                         //number of surviving children to prevent premature free
+    nuodb_handle* parent;
 };
 
 struct nuodb_connection_handle : nuodb_handle
@@ -328,128 +230,59 @@ struct nuodb_connection_handle : nuodb_handle
     VALUE schema;
     VALUE timezone;
 
-    NuoDB::Connection * pointer;
+    NuoDB::Connection* pointer;
 };
 
 struct nuodb_prepared_statement_handle : nuodb_handle
 {
-    NuoDB::PreparedStatement * pointer;
+    NuoDB::PreparedStatement* pointer;
+
+    VALUE connection;
+    nuodb_connection_handle* connection_handle;
 };
 
 struct nuodb_statement_handle : nuodb_handle
 {
-    NuoDB::Statement * pointer;
+    NuoDB::Statement* pointer;
+
+    VALUE connection;
+    nuodb_connection_handle* connection_handle;
 };
 
 struct nuodb_result_handle : nuodb_handle
 {
-    NuoDB::ResultSet * pointer;
-    NuoDB::Connection * connection;
+    NuoDB::ResultSet* pointer;
+    NuoDB::Connection* connection;
+
+    VALUE                      statement;
+    int                        columnCount;
+    NuoDB::SqlType*            types;
+    NuoDB::ResultSetMetaData*  resultMetaData;
+
+    nuodb_prepared_statement_handle* prepStmt;
+    nuodb_statement_handle*	     stmt;
 };
 
 template<typename handle_type>
-handle_type * cast_handle(VALUE value)
+handle_type* cast_handle(VALUE value)
 {
     Check_Type(value, T_DATA);
     return static_cast<handle_type*>(DATA_PTR(value));
 }
 
 template<typename handle_type, typename return_type>
-return_type * cast_pointer_member(VALUE value)
+return_type* cast_pointer_member(VALUE value)
 {
     Check_Type(value, T_DATA);
     return cast_handle<handle_type>(value)->pointer;
 }
 
-static void track_ref_count(char const * context, nuodb_handle * handle)
-{
-    trace("track_ref_count");
-
-    if (handle != 0)
-    {
-        int parent_count = -10;
-        if (handle->parent_handle != 0)
-        {
-            parent_count = handle->parent_handle->atomic;
-        }
-        if (logLevel <= DEBUG)
-        {
-            nuodb_handle  * parent = handle->parent_handle;
-		    unsigned char *p = (unsigned char *)&handle;
-		    unsigned char *q = (unsigned char *)&parent;
-		    int i;
-			printf("[REFERENCE COUNT][%s] (%s @ ", context, demangle(typeid(*handle).name()));
-		    for (i = 0; i < sizeof handle; i++)
-		    {
-		        printf("%02x ", p[i]);
-		    }
-		    printf("): %d (%s @ ", handle->atomic, demangle(typeid(*parent).name()));
-		    for (i = 0; i < sizeof parent; i++)
-		    {
-		        printf("%02x ", q[i]);
-		    }
-		    printf("): %d", parent_count);
-		    putchar('\n');
-        }
-    }
-}
-
-void incr_reference_count(nuodb_handle * handle)
-{
-    trace("incr_reference_count");
-
-    track_ref_count("I INCR", handle);
-
-    ATOMIC_INC(handle->atomic);
-    if (handle->parent_handle != 0)
-    {
-        log(DEBUG, "incrementing parent");
-        ATOMIC_INC(handle->parent_handle->atomic);
-    }
-
-    track_ref_count("O INCR", handle);
-}
-
-void decr_reference_count(nuodb_handle * handle)
-{
-    trace("decr_reference_count");
-
-    track_ref_count("I DECR", handle);
-
-    if (handle->atomic == 0)
-    {
-        return;
-    }
-
-    if (ATOMIC_DEC(handle->atomic) == 0)
-    {
-        (*(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;
-    }
-    else
-    {
-        track_ref_count("O DECR", handle);
-    }
-}
-
 //------------------------------------------------------------------------------
 // exception mapper
 
 static ID c_error_code_assignment;
 
-static void rb_raise_nuodb_error(int code, const char * fmt, ...)
+static void rb_raise_nuodb_error(int code, const char* fmt, ...)
 {
     va_list args;
     char text[BUFSIZ];
@@ -468,60 +301,124 @@ static void rb_raise_nuodb_error(int code, const char * fmt, ...)
 using namespace NuoDB;
 
 //------------------------------------------------------------------------------
+//
+//
+static
+void handle_init(nuodb_handle* self, nuodb_handle* parent, int initialChildren, void (*cleaner)(nuodb_handle*))
+{
+    self->numUsed = 0;
+    self->freePending = false;
+    self->cleanupFunc = NULL;
+    self->parent = parent;
+    self->cleanupFunc = cleaner;
+}
 
+/*
+ * Adjusts the parent's reference count
+ */
 static
-VALUE nuodb_result_free_protect(VALUE value)
+int add_child(nuodb_handle* parent, nuodb_handle* child)
 {
-    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());
-            }
-        }
+    parent->numUsed++;
+
+    return parent->numUsed;
+}
+
+/*
+ * Decrements the parent's reference count. Returns whether or not this child was the last one.
+ * If true, that means the responsibility for freeing the parent rests with the child handle
+ * calling this function.
+ */
+static
+bool remove_from_parent(nuodb_handle* child, nuodb_handle* parent)
+{
+    //parent may be NULL
+    if (parent) {
+        parent->numUsed--;
+        assert(parent->numUsed >= 0);
+        return parent->numUsed == 0 && parent->freePending;
     }
-    return Qnil;
+
+    return false;
 }
 
+/*
+ * Method attempts to free handle and recursively free its parent if necessary. Returns a pointer
+ * to any exception encoundered while executing cleanup functions. Errors do not stop recursion.
+ * An error in the child won't stop this from attempting to free the parent. To do otherwise would
+ * cause a leak.
+ */
 static
-void nuodb_result_free(void * ptr)
+NuoDB::SQLException* handle_free(nuodb_handle* handle, nuodb_handle* parent)
 {
-    trace("nuodb_result_free");
-    if (ptr != NULL)
-    {
-        int exception = 0;
-        rb_protect(nuodb_result_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
-        if (exception)
-        {
-            rb_jump_tag(exception);
+    if (handle->numUsed == 0) {
+        bool needToRemoveParent = remove_from_parent(handle, parent);
+
+        NuoDB::SQLException* caughtError = NULL;
+
+        try {
+            //clean up ourselves
+            handle->cleanupFunc(handle);
+        } catch (NuoDB::SQLException& err) {
+            caughtError = &err;
+        }
+
+        try {
+            //clean up parent if we're the last ones out
+            if (needToRemoveParent) {
+                handle_free(parent, parent->parent);
+            }
+        } catch (NuoDB::SQLException& err) {
+            if (!caughtError) {
+                caughtError = &err;
+            }
         }
+
+        //free ourselves
+        trace("freeing object");
+        free(handle);
+
+        return caughtError;
+    } else {
+        handle->freePending = true;
+        return NULL;
     }
 }
 
 static
-void nuodb_result_mark(void * ptr)
+void nuodb_result_mark(void* ptr)
 {
     trace("nuodb_result_mark");
-    nuodb_result_handle * handle = static_cast<nuodb_result_handle *>(ptr);
-    rb_gc_mark(handle->parent);
+    nuodb_result_handle* handle = static_cast<nuodb_result_handle *>(ptr);
+    rb_gc_mark(handle->statement);
 }
 
 static
-void nuodb_result_decr_reference_count(nuodb_handle * handle)
+void nuodb_result_cleanup(nuodb_handle* handle)
 {
-    trace("nuodb_result_decr_reference_count");
-    decr_reference_count(handle);
+    nuodb_result_handle* resultHandle = (nuodb_result_handle*)handle;
+
+    if (resultHandle && resultHandle->pointer) {
+        resultHandle->pointer->close();
+    }
+}
+
+static
+void nuodb_result_free(nuodb_handle* handle)
+{
+    trace("nuodb_result_free");
+    nuodb_result_handle* result_handle = (nuodb_result_handle*)handle;
+
+    if (result_handle) {
+        NuoDB::SQLException* err = handle_free(handle, (result_handle->prepStmt != NULL ? (nuodb_handle*)result_handle->prepStmt : (nuodb_handle*)result_handle->stmt));
+
+        if (err) {
+            //Not ok to raise an error during GC
+            //rb_raise_nuodb_error(err->getSqlcode(), "Failed to successfully close result set: %s", err->getText());
+            log(ERROR, "Failed to successfully close result set");
+            log(ERROR, err->getText());
+        }
+    }
 }
 
 /*
@@ -534,49 +431,9 @@ 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_handle* handle = cast_handle<nuodb_result_handle>(self);
     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;
 }
 
 static
@@ -592,6 +449,10 @@ VALUE nuodb_map_sql_type(int type)
         symbol = ID2SYM(rb_intern("integer"));
         break;
 
+    case NUOSQL_BINARY:
+	    symbol = ID2SYM(rb_intern("binary"));
+	    break;
+    
     case NUOSQL_FLOAT:
     case NUOSQL_DOUBLE:
         symbol = ID2SYM(rb_intern("float"));
@@ -628,18 +489,16 @@ VALUE nuodb_map_sql_type(int type)
         symbol = ID2SYM(rb_intern("numeric"));
         break;
 
-//    case NUOSQL_BLOB:
-//        symbol = ID2SYM(rb_intern("blob"));
-//        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:
+    //case NUOSQL_BLOB:
     case NUOSQL_CLOB:
-    case NUOSQL_BINARY:
     case NUOSQL_LONGVARBINARY:
     default:
         rb_raise(rb_eNotImpError, "Unsupported SQL type: %d", type);
@@ -647,53 +506,51 @@ VALUE nuodb_map_sql_type(int 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;
+VALUE nuodb_result_init(VALUE parent, NuoDB::ResultSet* results, NuoDB::Connection* connection)
+{
+    trace("nuodb_result_init");
+    nuodb_handle* parent_handle = cast_handle<nuodb_handle>(parent);
+    if (parent_handle != NULL) {
+        trace("alloc result set");
+        nuodb_result_handle* handle = ALLOC(struct nuodb_result_handle);
+        handle_init(handle, parent_handle, 0, nuodb_result_cleanup);
+        handle->statement = parent;
+        add_child(parent_handle, handle);
+
+        handle->prepStmt = NULL;
+        handle->stmt = NULL;
+        handle->columnCount = -1;
+        handle->types = NULL;
+        handle->resultMetaData = NULL;
         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);
+        VALUE self = Data_Wrap_Struct(nuodb_result_klass, nuodb_result_mark, nuodb_result_free, handle);
 
         rb_iv_set(self, "@columns", Qnil);
         rb_iv_set(self, "@rows", Qnil);
 
         if (!rb_block_given_p()) {
-            trace("nuodb_result_alloc: no block");
+            trace("nuodb_result_init: no block");
 
             return self;
         }
 
-        trace("nuodb_result_alloc: begin block");
+        trace("nuodb_result_init: begin block");
 
         int exception = 0;
         VALUE result = rb_protect(rb_yield, self, &exception);
 
-        trace("nuodb_result_alloc: end block");
+        trace("nuodb_result_init: end block");
 
-        //nuodb_result_finish(self);
+        trace("nuodb_result_init: auto finish");
 
-        trace("nuodb_result_alloc: auto finish");
-
-        if (exception)
-        {
+        if (exception) {
+            //@TODO - don't we need to free here?
             rb_jump_tag(exception);
-        }
-        else
-        {
+        } else {
             return result;
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: statement handle nil");
     }
     return Qnil;
@@ -708,10 +565,9 @@ nuodb_get_rb_timezone_offset()
 }
 
 static VALUE
-nuodb_get_rb_value(int column, SqlType type, ResultSet * results)
+nuodb_get_rb_value(int column, SqlType type, ResultSet* results)
 {
     VALUE value = Qnil;
-
     switch (type)
     {
         case NUOSQL_BIT:
@@ -764,11 +620,13 @@ nuodb_get_rb_value(int column, SqlType type, ResultSet * results)
             }
             break;
         }
-        case NUOSQL_CHAR:
+
+	case NUOSQL_BLOB:
+	case NUOSQL_BINARY:
         case NUOSQL_VARCHAR:
         case NUOSQL_LONGVARCHAR:
         {
-            char const * field = results->getString(column);
+            char const* field = results->getString(column);
             if (!results->wasNull())
             {
                 value = rb_str_new2(field);
@@ -777,7 +635,7 @@ nuodb_get_rb_value(int column, SqlType type, ResultSet * results)
         }
         case NUOSQL_DATE:
         {
-            NuoDB::Date * field = results->getDate(column);
+            NuoDB::Date* field = results->getDate(column);
             if (!results->wasNull())
             {
                 double secs = (double) field->getSeconds();
@@ -789,17 +647,17 @@ nuodb_get_rb_value(int column, SqlType type, ResultSet * results)
         case NUOSQL_TIME:
         case NUOSQL_TIMESTAMP:
         {
-            NuoDB::Timestamp * field = results->getTimestamp(column);
+            NuoDB::Timestamp* field = results->getTimestamp(column);
             if (!results->wasNull())
             {
-                double secs = ((double) field->getSeconds()) + (((double) field->getNanos()) / 1000000);
+                double secs = ((double) field->getSeconds()) + (((double) field->getNanos()) / NANOS_PER_SECOND);
                 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);
+            char const* field = results->getString(column);
             if (!results->wasNull())
             {
                 rb_require("bigdecimal");
@@ -812,13 +670,23 @@ nuodb_get_rb_value(int column, SqlType type, ResultSet * results)
         }
         default:
         {
-            rb_raise(rb_eTypeError, "not a supported ruby type: %d", type);
+            rb_raise(rb_eTypeError, "Not a supported ruby type: %d", type);
             break;
         }
     }
     return value;
 }
 
+static
+NuoDB::ResultSetMetaData* getResultMetadata(nuodb_result_handle* result_handle)
+{
+    if (!result_handle->resultMetaData && result_handle->pointer) {
+        result_handle->resultMetaData = result_handle->pointer->getMetaData();
+    }
+
+    return result_handle->resultMetaData;
+}
+
 /*
  * call-seq:
  *      result.columns -> ary
@@ -835,53 +703,26 @@ 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)
-    {
+    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();
+
+        if (NIL_P(columns)) {
+            try {
+                ResultSetMetaData* result_metadata = getResultMetadata(handle);
 
                 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]
+                for (int column_index = 1; column_index < column_count + 1; ++column_index) {
                     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();
+                    
+                    //Can't issue database metadata queries as that will close out the current transaction due to a bug
+                    args[1] = Qnil;
 
                     args[2] = nuodb_map_sql_type(result_metadata->getColumnType(column_index));
                     args[3] = result_metadata->isNullable(column_index) ? Qtrue : Qfalse;
@@ -893,24 +734,40 @@ nuodb_result_columns(VALUE self)
                 rb_iv_set(self, "@columns", array);
 
                 return array;
-            }
-            catch (SQLException & e)
-            {
+            } catch (SQLException & e) {
                 rb_raise_nuodb_error(e.getSqlcode(), "Failed to create column info: %s", e.getText());
             }
-        }
-        else
-        {
+        } else {
             return columns;
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: result handle nil");
     }
     return Qnil;
 }
 
+static
+void nuodb_populate_row_metadata(nuodb_result_handle* result_handle)
+{
+    if (!result_handle->pointer || result_handle->types != NULL) {
+        return;
+    }
+    trace("populating row metadata");
+
+    NuoDB::ResultSetMetaData* metadata = getResultMetadata(result_handle);
+    assert(metadata != NULL);
+
+    int32_t column_count = metadata->getColumnCount();
+    result_handle->columnCount = column_count;
+    result_handle->types = ALLOC_N(SqlType, column_count);
+
+    for (int32_t column = 1; column < column_count + 1; column++) {
+        SqlType type = (SqlType) metadata->getColumnType(column);
+        result_handle->types[column-1] = type;
+    }
+
+}
+
 /*
  * call-seq:
  *      result.rows -> ary
@@ -932,25 +789,24 @@ 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)
-    {
+    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
-            {
+
+        if (NIL_P(rows)) {
+            try {
+                nuodb_populate_row_metadata(handle);
                 rows = rb_ary_new();
 
-                while (handle->pointer->next())
-                {
+                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);
+                    //remember, SQL result set columns are 1-indexed
+                    for (int32_t column = 1; column < handle->columnCount + 1; column++) {
+                        SqlType type = handle->types[column - 1];
                         rb_ary_push(row, nuodb_get_rb_value(column, type, handle->pointer));
                     }
 
@@ -958,16 +814,12 @@ nuodb_result_rows(VALUE self)
                 }
 
                 rb_iv_set(self, "@rows", rows);
-            }
-            catch (SQLException & e)
-            {
+            } catch (SQLException & e) {
                 rb_raise_nuodb_error(e.getSqlcode(), "Failed to create a rows array: %s", e.getText());
             }
         }
         return rows;
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: result handle nil");
     }
     return Qnil;
@@ -992,7 +844,7 @@ static VALUE
 nuodb_result_each(VALUE self)
 {
     trace("nuodb_result_each");
-    nuodb_result_handle * handle = cast_handle<nuodb_result_handle>(self);
+    nuodb_result_handle* handle = cast_handle<nuodb_result_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         VALUE rows = rb_iv_get(self, "@rows");
@@ -1038,59 +890,43 @@ void nuodb_define_result_api()
 //------------------------------------------------------------------------------
 
 static
-VALUE nuodb_statement_free_protect(VALUE value)
+void nuodb_statement_mark(void* ptr)
 {
-    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;
+    trace("nuodb_statement_mark");
+
+    nuodb_statement_handle* handle = static_cast<nuodb_statement_handle *>(ptr);
+    rb_gc_mark(handle->connection);
 }
 
 static
-void nuodb_statement_free(void * ptr)
+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);
+    nuodb_statement_handle* handle = (nuodb_statement_handle*)ptr;
+
+    if (handle && handle->pointer) {
+        NuoDB::SQLException* err = handle_free(handle, handle->connection_handle);
+
+        if (err) {
+            //Not ok to raise an error during GC
+            //rb_raise_nuodb_error(err->getSqlcode(), "Failed to successfully close statement: %s", err->getText());
+            log(ERROR, "Failed to successfully close statement");
+            log(ERROR, err->getText());
         }
     }
+
 }
 
 static
-void nuodb_statement_mark(void * ptr)
+void nuodb_statement_cleanup(nuodb_handle* handle)
 {
-    trace("nuodb_statement_mark");
+    nuodb_statement_handle* statementHandle = (nuodb_statement_handle*)handle;
 
-    nuodb_statement_handle * handle = static_cast<nuodb_statement_handle *>(ptr);
-    rb_gc_mark(handle->parent);
+    if (statementHandle && statementHandle->pointer) {
+        statementHandle->pointer->close();
+    }
 }
 
-static
-void nuodb_statement_decr_reference_count(void * ptr)
-{
-    trace("nuodb_statement_decr_reference_count");
-    decr_reference_count(static_cast<nuodb_statement_handle *>(ptr));
-}
 
 /*
  * call-seq:
@@ -1102,39 +938,9 @@ 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_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;
 }
 
 static
@@ -1142,33 +948,28 @@ VALUE nuodb_statement_initialize(VALUE parent)
 {
     trace("nuodb_statement_initialize");
 
-    nuodb_connection_handle * parent_handle = cast_handle<nuodb_connection_handle>(parent);
-    if (parent_handle != NULL && parent_handle->pointer != NULL)
-    {
-        NuoDB::Statement * statement = NULL;
-        try
-        {
+    nuodb_connection_handle* parent_handle = cast_handle<nuodb_connection_handle>(parent);
+
+    if (parent_handle != NULL && parent_handle->pointer != NULL) {
+        NuoDB::Statement* statement = NULL;
+        try {
             statement = parent_handle->pointer->createStatement();
-        }
-        catch (SQLException & e)
-        {
+        } 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);
+        trace("alloc");
+        nuodb_statement_handle* handle = ALLOC(nuodb_statement_handle);
+        handle_init(handle, parent_handle, 1, nuodb_statement_cleanup);
+        add_child(parent_handle, handle);
 
-        handle->free_func = RUBY_DATA_FUNC(&nuodb_statement_free);
-        handle->atomic = 0;
-        handle->parent = parent;
-        handle->parent_handle = parent_handle;
+        handle->connection = parent;
+        handle->connection_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);
+        VALUE self = Data_Wrap_Struct(nuodb_statement_klass, nuodb_statement_mark, nuodb_statement_free, 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;
         }
 
@@ -1184,17 +985,13 @@ VALUE nuodb_statement_initialize(VALUE parent)
 
         trace("nuodb_statement_initialize: auto finish");
 
-        if (exception)
-        {
+        if (exception) {
+            //@TODO - don't we need to free memory here?
             rb_jump_tag(exception);
-        }
-        else
-        {
+        } else {
             return result;
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: statement handle nil");
     }
     return Qnil;
@@ -1218,7 +1015,7 @@ VALUE nuodb_statement_execute(VALUE self, VALUE sql)
         rb_raise(rb_eTypeError, "wrong sql argument type %s (String expected)", rb_class2name(CLASS_OF(sql)));
     }
 
-    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    nuodb_statement_handle* handle = cast_handle<nuodb_statement_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -1249,7 +1046,7 @@ VALUE nuodb_statement_update_count(VALUE self)
 {
     trace("nuodb_statement_update_count");
 
-    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    nuodb_statement_handle* handle = cast_handle<nuodb_statement_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -1278,12 +1075,20 @@ static VALUE nuodb_statement_results(VALUE self)
 {
     trace("nuodb_statement_results");
 
-    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
+    nuodb_statement_handle* handle = cast_handle<nuodb_statement_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
         {
-            return nuodb_result_alloc(self, handle->pointer->getResultSet(), handle->pointer->getConnection());
+            VALUE ruby_handle = nuodb_result_init(self, handle->pointer->getResultSet(), handle->pointer->getConnection());
+            nuodb_result_handle* our_result_handle = cast_handle<nuodb_result_handle>(ruby_handle);
+
+            assert(our_result_handle != NULL);
+            assert(our_result_handle->prepStmt == NULL);
+            assert(our_result_handle->stmt == NULL);
+
+            our_result_handle->stmt = handle;
+            return ruby_handle;
         }
         catch (SQLException & e)
         {
@@ -1308,26 +1113,27 @@ static VALUE nuodb_statement_generated_keys(VALUE self)
 {
     trace("nuodb_statement_generated_keys");
 
-    nuodb_statement_handle * handle = cast_handle<nuodb_statement_handle>(self);
-    if (handle != NULL && handle->pointer != NULL)
-    {
-        try
-        {
+    nuodb_statement_handle* handle = cast_handle<nuodb_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL) {
+        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());
+            ResultSet* results = handle->pointer->getGeneratedKeys();
+            if (results != NULL) {
+                VALUE ruby_handle = nuodb_result_init(self, results, handle->pointer->getConnection());
+                nuodb_result_handle* our_result_handle = cast_handle<nuodb_result_handle>(ruby_handle);
+
+                assert(our_result_handle != NULL);
+                assert(our_result_handle->prepStmt == NULL);
+                assert(our_result_handle->stmt == NULL);
+
+                our_result_handle->stmt = handle;
+                return ruby_handle;
             }
-        }
-        catch (SQLException & e)
-        {
+        } catch (SQLException & e) {
             rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the generated keys for the statement: %s", e.getText());
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: statement handle nil");
     }
     return Qnil;
@@ -1360,60 +1166,40 @@ void nuodb_define_statement_api()
 //------------------------------------------------------------------------------
 
 static
-VALUE nuodb_prepared_statement_free_protect(VALUE value)
+void nuodb_prepared_statement_free(void* ptr)
 {
-    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());
-            }
+    trace("nuodb_prepared_statement_free");
+
+    if (ptr != NULL) {
+        nuodb_prepared_statement_handle* handle = (nuodb_prepared_statement_handle*)ptr;
+        NuoDB::SQLException* err = handle_free(handle, handle->connection_handle);
+
+        if (err) {
+            //Not ok to raise a ruby error during GC
+            //rb_raise_nuodb_error(err->getSqlcode(), "Failed to successfully close prepared statement: %s", err->getText());
+            log(ERROR, "Failed to successfully close prepared statement");
+            log(ERROR, err->getText());
         }
     }
-    return Qnil;
 }
 
 static
-void nuodb_prepared_statement_free(void * ptr)
+void nuodb_prepared_statement_cleanup(nuodb_handle* handle)
 {
-    trace("nuodb_prepared_statement_free");
+    nuodb_prepared_statement_handle* prepHandle = (nuodb_prepared_statement_handle*)prepHandle;
 
-    if (ptr != NULL)
-    {
-        int exception = 0;
-        rb_protect(nuodb_prepared_statement_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
-        if (exception)
-        {
-            rb_jump_tag(exception);
-        }
+    if (prepHandle && prepHandle->pointer) {
+        prepHandle->pointer->close();
     }
 }
 
 static
-void nuodb_prepared_statement_mark(void * ptr)
+void nuodb_prepared_statement_mark(void* ptr)
 {
     trace("nuodb_prepared_statement_mark");
 
-    nuodb_prepared_statement_handle * handle = static_cast<nuodb_prepared_statement_handle *>(ptr);
-    rb_gc_mark(handle->parent);
-}
-
-static
-void nuodb_prepared_statement_decr_reference_count(nuodb_handle * handle)
-{
-    trace("nuodb_prepared_statement_decr_reference_count");
-    decr_reference_count(handle);
+    nuodb_prepared_statement_handle* handle = (nuodb_prepared_statement_handle *)ptr;
+    rb_gc_mark(handle->connection);
 }
 
 /*
@@ -1426,41 +1212,9 @@ 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_handle* handle = cast_handle<nuodb_prepared_statement_handle>(self);//reinterpret_cast<nuodb_prepared_statement_handle *>(value);
     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
@@ -1468,34 +1222,30 @@ VALUE nuodb_prepared_statement_initialize(VALUE parent, VALUE sql)
 {
     trace("nuodb_prepared_statement_initialize");
 
-    if (TYPE(sql) != T_STRING)
-    {
+    if (TYPE(sql) != T_STRING) {
         rb_raise(rb_eTypeError, "wrong sql argument type %s (String expected)", rb_class2name(CLASS_OF(sql)));
     }
 
-    nuodb_connection_handle * parent_handle = cast_handle<nuodb_connection_handle>(parent);
-    if (parent_handle != NULL && parent_handle->pointer != NULL)
-    {
-        NuoDB::PreparedStatement * statement = NULL;
-        try
-        {
+    nuodb_connection_handle* parent_handle = cast_handle<nuodb_connection_handle>(parent);
+
+    if (parent_handle != NULL && parent_handle->pointer != NULL) {
+        NuoDB::PreparedStatement* statement = NULL;
+        try {
             statement = parent_handle->pointer->prepareStatement(StringValueCStr(sql),
                     NuoDB::RETURN_GENERATED_KEYS);
-        }
-        catch (SQLException & e)
-        {
+        } 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;
+        trace("alloc");
+        nuodb_prepared_statement_handle* handle = ALLOC(struct nuodb_prepared_statement_handle);
+        handle_init(handle, parent_handle, 1, nuodb_prepared_statement_cleanup);
+        add_child(parent_handle, handle);
+
+        handle->connection = parent;
+        handle->connection_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);
+        VALUE self = Data_Wrap_Struct(nuodb_prepared_statement_klass, nuodb_prepared_statement_mark, nuodb_prepared_statement_free, handle);
 
         if (!rb_block_given_p()) {
             trace("nuodb_prepared_statement_initialize: no block");
@@ -1515,24 +1265,20 @@ VALUE nuodb_prepared_statement_initialize(VALUE parent, VALUE sql)
 
         trace("nuodb_prepared_statement_initialize: auto finish");
 
-        if (exception)
-        {
+        if (exception) {
+            //@TODO - don't we have to free memory?
             rb_jump_tag(exception);
-        }
-        else
-        {
+        } else {
             return result;
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
     return Qnil;
 }
 
 static
-void raise_unsupported_type_at_index(char const * type_name, int32_t index)
+void raise_unsupported_type_at_index(char const* type_name, int32_t index)
 {
     rb_raise(rb_eTypeError, "unsupported type %s at %d", type_name, index);
 }
@@ -1559,7 +1305,7 @@ VALUE nuodb_prepared_statement_bind_param(VALUE self, VALUE param, VALUE value)
     }
     int32_t index = NUM2UINT(param);
 
-    NuoDB::PreparedStatement * statement = cast_pointer_member<
+    NuoDB::PreparedStatement* statement = cast_pointer_member<
                                            nuodb_prepared_statement_handle, NuoDB::PreparedStatement>(self);
 
     try
@@ -1576,7 +1322,7 @@ VALUE nuodb_prepared_statement_bind_param(VALUE self, VALUE param, VALUE value)
         case T_STRING: // 0x05
             {
                 log(DEBUG, "supported: T_STRING");
-                char const * real_value = RSTRING_PTR(value);
+                char const* real_value = RSTRING_PTR(value);
                 statement->setString(index, real_value);
             }
             break;
@@ -1614,7 +1360,7 @@ VALUE nuodb_prepared_statement_bind_param(VALUE self, VALUE param, VALUE value)
                     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)
+                    SqlTimestamp sqlTimestamp(NUM2INT(sec), NUM2INT(usec) * NANOS_PER_MICRO); //  + NUM2INT(offset)
                     statement->setTimestamp(index, &sqlTimestamp);
                     break;
                 }
@@ -1626,7 +1372,7 @@ VALUE nuodb_prepared_statement_bind_param(VALUE self, VALUE param, VALUE value)
                     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)
+                    SqlTimestamp sqlTimestamp(NUM2LONG(sec), NUM2INT(usec) * NANOS_PER_MICRO);//  + NUM2INT(offset)
                     statement->setTimestamp(index, &sqlTimestamp);
                     break;
                 }
@@ -1711,7 +1457,7 @@ VALUE nuodb_prepared_statement_bind_params(VALUE self, VALUE array)
 {
     trace("nuodb_prepared_statement_bind_params");
 
-    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    nuodb_prepared_statement_handle* handle = cast_handle<nuodb_prepared_statement_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         for (int i = 0; i < RARRAY_LEN(array); ++i)
@@ -1741,7 +1487,7 @@ VALUE nuodb_prepared_statement_execute(VALUE self)
 {
     trace("nuodb_prepared_statement_execute");
 
-    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    nuodb_prepared_statement_handle* handle = cast_handle<nuodb_prepared_statement_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -1771,7 +1517,7 @@ VALUE nuodb_prepared_statement_update_count(VALUE self)
 {
     trace("nuodb_prepared_statement_update_count");
 
-    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    nuodb_prepared_statement_handle* handle = cast_handle<nuodb_prepared_statement_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -1800,20 +1546,22 @@ static VALUE nuodb_prepared_statement_results(VALUE self)
 {
     trace("nuodb_prepared_statement_results");
 
-    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
-    if (handle != NULL && handle->pointer != NULL)
-    {
-        try
-        {
-            return nuodb_result_alloc(self, handle->pointer->getResultSet(), handle->pointer->getConnection());
-        }
-        catch (SQLException & e)
-        {
+    nuodb_prepared_statement_handle* handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL) {
+        try {
+            VALUE ruby_handle = nuodb_result_init(self, handle->pointer->getResultSet(), handle->pointer->getConnection());
+            nuodb_result_handle* our_result_handle = cast_handle<nuodb_result_handle>(ruby_handle);
+
+            assert(our_result_handle != NULL);
+            assert(our_result_handle->prepStmt == NULL);
+            assert(our_result_handle->stmt == NULL);
+
+            our_result_handle->prepStmt = handle;
+            return ruby_handle;
+        } catch (SQLException & e) {
             rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the result set for the prepared statement: %s", e.getText());
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
     return Qnil;
@@ -1830,26 +1578,27 @@ static VALUE nuodb_prepared_statement_generated_keys(VALUE self)
 {
     trace("nuodb_prepared_statement_generated_keys");
 
-    nuodb_prepared_statement_handle * handle = cast_handle<nuodb_prepared_statement_handle>(self);
-    if (handle != NULL && handle->pointer != NULL)
-    {
-        try
-        {
+    nuodb_prepared_statement_handle* handle = cast_handle<nuodb_prepared_statement_handle>(self);
+    if (handle != NULL && handle->pointer != NULL) {
+        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());
+            ResultSet* results = handle->pointer->getGeneratedKeys();
+            if (results != NULL) {
+                VALUE ruby_handle = nuodb_result_init(self, results, handle->pointer->getConnection());
+                nuodb_result_handle* our_result_handle = cast_handle<nuodb_result_handle>(ruby_handle);
+
+                assert(our_result_handle != NULL);
+                assert(our_result_handle->prepStmt == NULL);
+                assert(our_result_handle->stmt == NULL);
+
+                our_result_handle->prepStmt = handle;
+                return ruby_handle;
             }
-        }
-        catch (SQLException & e)
-        {
+        } catch (SQLException & e) {
             rb_raise_nuodb_error(e.getSqlcode(), "Failed to get the generated keys for the prepared statement: %s", e.getText());
         }
-    }
-    else
-    {
+    } else {
         rb_raise(rb_eArgError, "invalid state: prepared statement handle nil");
     }
     return Qnil;
@@ -1888,56 +1637,38 @@ void nuodb_define_prepared_statement_api()
  */
 
 static
-VALUE nuodb_connection_free_protect(VALUE value)
+void nuodb_connection_free(void* ptr)
 {
-    trace("nuodb_connection_free_protect");
+    trace("nuodb_connection_free");
+    if (ptr != NULL) {
+	    nuodb_connection_handle* handle = (nuodb_connection_handle*)ptr;
+        NuoDB::SQLException* err = handle_free(handle, NULL);
 
-    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());
-            }
+        if (err) {
+            //Not ok to raise a ruby exception during GC
+            //rb_raise_nuodb_error(err->getSqlcode(), "Failed to successfully close connection: %s", err->getText());
+            log(ERROR, "Failed to successfully close connection");
+            log(ERROR, err->getText());
         }
     }
-    return Qnil;
 }
 
 static
-void nuodb_connection_free(void * ptr)
+void nuodb_connection_cleanup(nuodb_handle* handle)
 {
-    trace("nuodb_connection_free");
-    if (ptr != NULL)
-    {
-        int exception = 0;
-        rb_protect(nuodb_connection_free_protect, reinterpret_cast<VALUE>(ptr), &exception);
-        if (exception)
-        {
-            rb_jump_tag(exception);
-        }
+    nuodb_connection_handle* connectionHandle = (nuodb_connection_handle*)handle;
+
+    if (connectionHandle && connectionHandle->pointer) {
+        connectionHandle->pointer->close();
     }
 }
 
 static
-void nuodb_connection_mark(void * ptr)
+void nuodb_connection_mark(void* ptr)
 {
     trace("nuodb_connection_mark");
 
-    nuodb_connection_handle * handle = static_cast<nuodb_connection_handle *>(ptr);
-    track_ref_count("MARK CONN", handle);
+    nuodb_connection_handle* handle = (nuodb_connection_handle *)ptr;
 
     rb_gc_mark(handle->database);
     rb_gc_mark(handle->username);
@@ -1945,38 +1676,28 @@ void nuodb_connection_mark(void * ptr)
     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);
+    trace("alloc");
+    nuodb_connection_handle* handle = ALLOC(struct nuodb_connection_handle);
+    handle_init(handle, NULL, 4, nuodb_connection_cleanup);
     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);
+    return Data_Wrap_Struct(klass, nuodb_connection_mark, nuodb_connection_free, handle);
 }
 
-static void internal_connection_connect_or_raise(nuodb_connection_handle * handle)
+static void internal_connection_connect_or_raise(nuodb_connection_handle* handle)
 {
     trace("internal_connection_connect_or_raise");
 
@@ -1985,7 +1706,7 @@ static void internal_connection_connect_or_raise(nuodb_connection_handle * handl
         try
         {
             handle->pointer = Connection::create();
-            Properties * props = handle->pointer->allocProperties();
+            Properties* props = handle->pointer->allocProperties();
             props->putValue("user", StringValueCStr(handle->username));
             props->putValue("password", StringValueCStr(handle->password));
             props->putValue("schema", StringValueCStr(handle->schema));
@@ -2010,7 +1731,7 @@ static void internal_connection_connect_or_raise(nuodb_connection_handle * handl
         try
         {
             handle->pointer = Connection::create();
-            Properties * props = handle->pointer->allocProperties();
+            Properties* props = handle->pointer->allocProperties();
             props->putValue("user", StringValueCStr(handle->username));
             props->putValue("password", StringValueCStr(handle->password));
             if (!NIL_P(handle->timezone))
@@ -2045,7 +1766,7 @@ static VALUE nuodb_connection_commit(VALUE self)
 {
     trace("nuodb_connection_commit");
 
-    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    nuodb_connection_handle* handle = cast_handle<nuodb_connection_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -2073,44 +1794,9 @@ static VALUE nuodb_connection_commit(VALUE self)
 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_handle* handle = cast_handle<nuodb_connection_handle>(self);//;
     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;
 }
 
 /*
@@ -2126,7 +1812,7 @@ static VALUE nuodb_connection_ping(VALUE self)
 {
     trace("nuodb_connection_ping");
 
-    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    nuodb_connection_handle* handle = cast_handle<nuodb_connection_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -2197,7 +1883,7 @@ static VALUE nuodb_connection_rollback(VALUE self)
 {
     trace("nuodb_connection_rollback");
 
-    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    nuodb_connection_handle* handle = cast_handle<nuodb_connection_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -2234,7 +1920,7 @@ static VALUE nuodb_connection_autocommit_set(VALUE self, VALUE value)
 {
     trace("nuodb_connection_autocommit_set");
 
-    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    nuodb_connection_handle* handle = cast_handle<nuodb_connection_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         bool auto_commit = !(RB_TYPE_P(value, T_FALSE) || RB_TYPE_P(value, T_NIL));
@@ -2270,7 +1956,7 @@ static VALUE nuodb_connection_autocommit_get(VALUE self)
 {
     trace("nuodb_connection_autocommit_get");
 
-    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    nuodb_connection_handle* handle = cast_handle<nuodb_connection_handle>(self);
     if (handle != NULL && handle->pointer != NULL)
     {
         try
@@ -2322,7 +2008,7 @@ static VALUE nuodb_connection_initialize(VALUE self, VALUE hash)
         rb_raise(rb_eTypeError, "wrong argument type %s (Hash expected)", rb_class2name(CLASS_OF(hash)));
     }
 
-    nuodb_connection_handle * handle = cast_handle<nuodb_connection_handle>(self);
+    nuodb_connection_handle* handle = cast_handle<nuodb_connection_handle>(self);
     if (NIL_P(handle->database))
     {
         VALUE value = rb_hash_aref(hash, sym_database);
@@ -2417,42 +2103,6 @@ static VALUE nuodb_connection_initialize(VALUE self, VALUE hash)
     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()
 {
     /*