oinky 0.1.0

data/ext/nky_lib_index.cpp

@@ -0,0 +1,158 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+#include "nky_lib_core.hpp"
+
+
+//  Create a cursor at the beginning of the index.
+static oinky_error oinky_index_cursor_new_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t **crs)
+{
+    db_t::index_handle ih(make_handle(index));
+    db_t::index_cursor_handle cnew(ih.new_cursor(ih.begin()));
+    *crs = (oinky_index_row_cursor_t *) cnew.raw();
+    return nky_success;
+}
+oinky_error oinky_index_cursor_new(oinky_index_handle_t *index, oinky_index_row_cursor_t **crs)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_new_impl, index, crs));
+}
+
+static oinky_error oinky_index_cursor_clone_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t *src, oinky_index_row_cursor_t **newcrs)
+{
+    db_t::index_cursor_handle cs(make_handle(src));
+    db_t::index_cursor_handle cnew(cs.clone());
+    *newcrs = (oinky_index_row_cursor_t *) cnew.raw();
+    return nky_success;
+}
+oinky_error oinky_index_cursor_clone(oinky_index_handle_t *index, oinky_index_row_cursor_t *src, oinky_index_row_cursor_t **newcrs)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_clone_impl, index, src, newcrs));
+}
+
+void oinky_index_cursor_free(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    //  This deletes the internal cursor object.  
+    //  ***IMPORTANT***
+    //  1) It can only be called once.  
+    //  2) It must be called before the DB is destroyed or not at all.  Cursor
+    //      lifetimes are bounded by DB lifetimes by definition, so DB destroy
+    //      implicitly frees all cursors.
+    db_t::index_cursor_handle c(make_handle(crs));
+    make_handle(index).delete_cursor(c);
+}
+
+static oinky_error oinky_index_cursor_seek_last_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    db_t::index_handle ih(make_handle(index));
+    db_t::index_cursor_handle c(make_handle(crs));
+    ih.move_cursor(c, ih.end());
+    c.seek_prev();
+    if (c.before_begin()) {
+        c.seek_next();
+    }
+    return nky_success;
+}
+oinky_error oinky_index_cursor_seek_last(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_last_impl, index, crs));
+}
+
+static oinky_error oinky_index_cursor_seek_first_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    db_t::index_handle ih(make_handle(index));
+    db_t::index_cursor_handle c(make_handle(crs));
+    ih.move_cursor(c, ih.begin());
+    return nky_success;
+}
+oinky_error oinky_index_cursor_seek_first(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_first_impl, index, crs));
+}
+
+//  Moves the given cursor to a position in the index defined by the given set of values.
+//  lower_bound and upper_bound are equivalent to their STL meanings.
+typedef db_t::index_row_iterator (db_t::index_handle::*ix_search_method)(const variant_cv_t *, const variant_cv_t *) const;
+static oinky_error oinky_index_cursor_seek_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs, size_t seq_len, const oinky_db_variant *value_seq, ix_search_method m)
+{
+    db_t::index_handle ih(make_handle(index));
+    variant_cv_t *values = (variant_cv_t *) alloca(sizeof(variant_cv_t) * seq_len);
+    for (size_t i=0;i<seq_len;++i) {
+        values[i] = nky_variant_xform(value_seq[i]);
+    }
+    db_t::index_row_iterator itr = (ih.*m)(values, values + seq_len);
+    db_t::index_cursor_handle c(make_handle(crs));
+    ih.move_cursor(c, itr);
+    return nky_success;
+}
+
+oinky_error oinky_index_cursor_seek_lower_bound(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs, size_t seq_len, const oinky_db_variant *value_seq)
+{
+    ix_search_method m = &db_t::index_handle::lower_bound<const variant_cv_t *>;
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_impl, index, crs, seq_len, value_seq, m));
+}
+
+oinky_error oinky_index_cursor_seek_upper_bound(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs, size_t seq_len, const oinky_db_variant *value_seq)
+{
+    ix_search_method m = &db_t::index_handle::upper_bound<const variant_cv_t *>;
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_impl, index, crs, seq_len, value_seq, m));
+}
+//  If found, returns success and sets cursor to element.  If not found, 
+//  return ObjectNotFound and sets cursor to end (state == 1).  Analogous
+//  to STL find.
+oinky_error oinky_index_cursor_seek_exact(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs, size_t seq_len, const oinky_db_variant *value_seq)
+{
+    ix_search_method m = &db_t::index_handle::find<const variant_cv_t *>;
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_impl, index, crs, seq_len, value_seq, m));
+}
+//  increment/decrement
+oinky_error oinky_index_cursor_seek_next_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    make_handle(crs).seek_next();
+    return nky_success;
+}
+oinky_error oinky_index_cursor_seek_next(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_next_impl, index, crs));
+}
+oinky_error oinky_index_cursor_seek_prev_impl(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    make_handle(crs).seek_prev();
+    return nky_success;
+}
+oinky_error oinky_index_cursor_seek_prev(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_seek_prev_impl, index, crs));
+}
+
+//  Returns -1 if cursor is before beginning of sequence,
+//  0 if it is on a valid element,
+//  and 1 if it is beyond the end of the sequence.
+int8_t oinky_index_cursor_state(oinky_index_handle_t *index, oinky_index_row_cursor_t *crs)
+{
+    db_t::index_cursor_handle c(make_handle(crs));
+    if (c.valid_data()) return 0;
+    if (c.before_begin()) return -1;
+    return 1;
+}
+
+static oinky_error oinky_index_cursor_get_values_impl(oinky_index_row_cursor_t *crs, oinky_column_selector_t *selector, size_t vcount, oinky_db_variant *out_values, size_t *out_value_count)
+{
+    variant_cv_t *vals = (variant_cv_t *)alloca(sizeof(variant_cv_t) * selector->cs.column_count());
+    make_handle(crs).select(selector->cs).copy_to(vals, selector->cs.column_count());
+    if (selector->cs.column_count() < vcount) {
+        vcount = selector->cs.column_count();
+    }
+    for (size_t i=0;i<vcount;++i) {
+        out_values[i] = nky_variant_from_variant(vals[i]);
+    }
+    *out_value_count = vcount;
+    return nky_success;
+}
+
+oinky_error oinky_index_cursor_get_values(oinky_index_row_cursor_t *crs, oinky_column_selector_t *selector, size_t vcount, oinky_db_variant *out_values, size_t *out_value_count)
+{
+    return wrap_exception(boost::bind(oinky_index_cursor_get_values_impl, crs, selector, vcount, out_values, out_value_count));
+}
+

data/ext/nky_lib_table.cpp

@@ -0,0 +1,224 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+#include "nky_lib_core.hpp"
+
+
+static oinky_error oinky_table_add_column_impl(oinky_table_handle_t *table, oinky_column_def defn)
+{
+    table_column_def tcd(
+        nky_string_xform(defn.column_name),
+        nky_column_type_xform(defn.column_type),
+        nky_variant_xform(defn.default_value));
+        
+    make_handle(table).columns().create(tcd);
+    return nky_success;
+}
+oinky_error oinky_table_add_column(oinky_table_handle_t *table, oinky_column_def defn)
+{
+    return wrap_exception(boost::bind(oinky_table_add_column_impl, table, defn));
+}
+
+static oinky_error oinky_table_drop_column_impl(oinky_table_handle_t *table, db_string colname)
+{
+    db_t::columns_accessor_t cols(make_handle(table).columns());
+    db_t::column_itr i = cols.find(colname);
+    if (i == cols.end()) {
+        throw_error(object_not_found());
+    }
+    cols.drop(i);
+    return nky_success;
+}
+oinky_error oinky_table_drop_column(oinky_table_handle_t *table, oinky_db_string colname)
+{
+    return wrap_exception(boost::bind(oinky_table_drop_column_impl, table, nky_string_xform(colname)));
+}
+
+static oinky_error oinky_table_drop_index_impl(oinky_table_handle_t *table, db_string idxname)
+{
+    db_t::indices_accessor_t ixs(make_handle(table).indices());
+    db_t::index_itr i = ixs.find(idxname);
+    if (i == ixs.end()) {
+        throw_error(object_not_found());
+    }
+    ixs.drop(i);
+    return nky_success;
+}
+oinky_error oinky_table_drop_index(oinky_table_handle_t *table, oinky_db_string idxname)
+{
+    return wrap_exception(boost::bind(oinky_table_drop_index_impl, table, nky_string_xform(idxname)));
+}
+
+
+//  Create a cursor at the beginning of the table.
+static oinky_error oinky_table_cursor_new_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t **crs)
+{
+    db_t::table_handle ih(make_handle(table));
+    db_t::table_cursor_handle cnew(ih.new_cursor(ih.rows_begin()));
+    *crs = (oinky_table_row_cursor_t *) cnew.raw();
+    return nky_success;
+}
+oinky_error oinky_table_cursor_new(oinky_table_handle_t *table, oinky_table_row_cursor_t **crs)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_new_impl, table, crs));
+}
+
+static oinky_error oinky_table_cursor_clone_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *src, oinky_table_row_cursor_t **newcrs)
+{
+    db_t::table_cursor_handle cs(make_handle(src));
+    db_t::table_cursor_handle cnew(cs.clone());
+    *newcrs = (oinky_table_row_cursor_t *) cnew.raw();
+    return nky_success;
+}
+oinky_error oinky_table_cursor_clone(oinky_table_handle_t *table, oinky_table_row_cursor_t *src, oinky_table_row_cursor_t **newcrs)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_clone_impl, table, src, newcrs));
+}
+
+void oinky_table_cursor_free(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    //  This deletes the internal cursor object.  
+    //  ***IMPORTANT***
+    //  1) It can only be called once.  
+    //  2) It must be called before the DB is destroyed or not at all.  Cursor
+    //      lifetimes are bounded by DB lifetimes by definition, so DB destroy
+    //      implicitly frees all cursors.
+    db_t::table_cursor_handle c(make_handle(crs));
+    make_handle(table).delete_cursor(c);
+}
+
+static oinky_error oinky_table_cursor_seek_last_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    db_t::table_handle ih(make_handle(table));
+    db_t::table_cursor_handle c(make_handle(crs));
+    ih.move_cursor(c, ih.rows_end());
+    c.seek_prev();
+    if (c.before_begin()) {
+        c.seek_next();
+    }
+    return nky_success;
+}
+oinky_error oinky_table_cursor_seek_last(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_seek_last_impl, table, crs));
+}
+
+static oinky_error oinky_table_cursor_seek_first_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    db_t::table_handle ih(make_handle(table));
+    db_t::table_cursor_handle c(make_handle(crs));
+    ih.move_cursor(c, ih.rows_begin());
+    return nky_success;
+}
+oinky_error oinky_table_cursor_seek_first(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_seek_first_impl, table, crs));
+}
+
+//  increment/decrement
+oinky_error oinky_table_cursor_seek_next_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    make_handle(crs).seek_next();
+    return nky_success;
+}
+oinky_error oinky_table_cursor_seek_next(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_seek_next_impl, table, crs));
+}
+oinky_error oinky_table_cursor_seek_prev_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    make_handle(crs).seek_prev();
+    return nky_success;
+}
+oinky_error oinky_table_cursor_seek_prev(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_seek_prev_impl, table, crs));
+}
+
+//  Returns -1 if cursor is before beginning of sequence,
+//  0 if it is on a valid element,
+//  and 1 if it is beyond the end of the sequence.
+int8_t oinky_table_cursor_state(oinky_table_handle_t *table, oinky_table_row_cursor_t *crs)
+{
+    db_t::table_cursor_handle c(make_handle(crs));
+    if (c.valid_data()) return 0;
+    if (c.before_begin()) return -1;
+    return 1;
+}
+
+static oinky_error oinky_table_cursor_get_values_impl(oinky_table_row_cursor_t *crs, oinky_column_selector_t *selector, size_t vcount, oinky_db_variant *out_values, size_t *out_value_count)
+{
+    db_t::table_cursor_handle c(make_handle(crs));
+    variant_cv_t *vals = (variant_cv_t *)alloca(sizeof(variant_cv_t) * selector->cs.column_count());
+    c.select(selector->cs).copy_to(vals, selector->cs.column_count());
+    if (selector->cs.column_count() < vcount) {
+        vcount = selector->cs.column_count();
+    }
+    for (size_t i=0;i<vcount;++i) {
+        out_values[i] = nky_variant_from_variant(vals[i]);
+    }
+    *out_value_count = vcount;
+    return nky_success;
+}
+
+oinky_error oinky_table_cursor_get_values(oinky_table_row_cursor_t *crs, oinky_column_selector_t *selector, size_t vcount, oinky_db_variant *out_values, size_t *out_value_count)
+{
+    return wrap_exception(boost::bind(oinky_table_cursor_get_values_impl, crs, selector, vcount, out_values, out_value_count));
+}
+
+//  Update the columns (identified by column_selector) at the row (identified by cursor) with the given values.
+static oinky_error oinky_table_update_row_at_index_cursor_impl(oinky_table_handle_t *table, oinky_index_row_cursor_t *cursor, oinky_column_selector_t *selector, size_t col_count, const variant_cv_t *values)
+{
+    make_handle(table).update_row(make_handle(cursor), selector->cs, values, values + col_count);
+    return nky_success;
+}
+
+oinky_error oinky_table_update_row_at_index_cursor(oinky_table_handle_t *table, oinky_index_row_cursor_t *cursor, oinky_column_selector_t *selector, size_t col_count, const oinky_db_variant *values)
+{
+    return wrap_unpack_variant_list(boost::bind(oinky_table_update_row_at_index_cursor_impl, table, cursor, selector, col_count, _1), col_count, values);
+}
+
+//  Update the columns (identified by column_selector) at the row (identified by cursor) with the given values.
+static oinky_error oinky_table_update_row_at_table_cursor_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *cursor, oinky_column_selector_t *selector, size_t col_count, const variant_cv_t *values)
+{
+    make_handle(table).update_row(make_handle(cursor), selector->cs, values, values + col_count);
+    return nky_success;
+}
+
+oinky_error oinky_table_update_row_at_table_cursor(oinky_table_handle_t *table, oinky_table_row_cursor_t *cursor, oinky_column_selector_t *selector, size_t col_count, const oinky_db_variant *values)
+{
+    return wrap_unpack_variant_list(boost::bind(oinky_table_update_row_at_table_cursor_impl, table, cursor, selector, col_count, _1), col_count, values);
+}
+
+static oinky_error oinky_table_delete_row_at_index_cursor_impl(oinky_table_handle_t *table, oinky_index_row_cursor_t *cursor)
+{
+    make_handle(table).erase(make_handle(cursor));
+    return nky_success;
+}
+oinky_error oinky_table_delete_row_at_index_cursor(oinky_table_handle_t *table, oinky_index_row_cursor_t *cursor)
+{
+    return wrap_exception(boost::bind(oinky_table_delete_row_at_index_cursor_impl, table, cursor));
+}
+static oinky_error oinky_table_delete_row_at_table_cursor_impl(oinky_table_handle_t *table, oinky_table_row_cursor_t *cursor)
+{
+    make_handle(table).erase(make_handle(cursor));
+    return nky_success;
+}
+oinky_error oinky_table_delete_row_at_table_cursor(oinky_table_handle_t *table, oinky_table_row_cursor_t *cursor)
+{
+    return wrap_exception(boost::bind(oinky_table_delete_row_at_table_cursor_impl, table, cursor));
+}
+
+static oinky_error oinky_table_insert_row_impl(oinky_table_handle_t *table, oinky_column_selector_t *selector, size_t col_count, const variant_cv_t *values)
+{
+    make_handle(table).insert_row(selector->cs, values, values + col_count);
+    return nky_success;
+}
+
+oinky_error oinky_table_insert_row(oinky_table_handle_t *table, oinky_column_selector_t *selector, size_t col_count, const oinky_db_variant *values)
+{
+    return wrap_unpack_variant_list(boost::bind(oinky_table_insert_row_impl, table, selector, col_count, _1), col_count, values);
+}
+

data/lib/oinky.rb

@@ -0,0 +1,1284 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+require 'date'
+require 'ffi'
+
+require 'oinky/error'
+require 'oinky/query'
+require 'oinky/nbuffer'
+require 'oinky/version'
+require 'oinky/modelbase'
+require 'oinky/compiler'
+
+module Oinky
+
+  class ExHash < Hash
+    def [](x)
+      # This allows access by string or symbol
+      return super(x.to_s)
+    end
+  end
+
+  # All of the C library interface is hidden within this internal module.
+  # The clean object-oriented lifetime-managed interface is built above this.
+  module Internal  
+    extend FFI::Library
+
+    libdir = File.expand_path(__FILE__).sub(/\/[^\/]+$/,'')
+    # No way of knowing the extension reliably.  (I've tried all the suggested
+    # methods and not one seems to actually work.)
+    fn = Dir.glob(File.join(libdir, 'liboinky_c*'))[0]
+    ffi_lib fn
+
+    typedef :int, :oinky_error
+
+    attach_function :convert_oinky_error, [:int], :string
+    attach_function :oinky_db_new, [], :pointer
+    attach_function :oinky_db_mount, [:pointer, :size_t, :pointer], :oinky_error
+    attach_function :oinky_db_free, [:pointer], :void
+
+    attach_function :oinky_db_is_modified_since, [:pointer, :uint64], :int
+    attach_function :oinky_db_create_savepoint, [:pointer, :pointer], :oinky_error
+    attach_function :oinky_db_savepoint_rollback, [:pointer, :uint64], :oinky_error
+
+    attach_function :oinky_db_prepare_pack, [:pointer, :pointer], :oinky_error
+    attach_function :oinky_db_complete_pack, [:pointer, :size_t, :pointer], :oinky_error
+
+    attach_function :oinky_debug_break, [], :void
+
+    def self.prepare_pack(db)
+      res = FFI::MemoryPointer.new :size_t
+      wrap_oinky(oinky_db_prepare_pack(db, res))
+      res.read_int
+    end
+    
+    def self.wrap_oinky(err)
+      if err < 0
+        raise OinkyException.new(err, convert_oinky_error(err))
+      end
+      nil
+    end
+
+    class DB_string < FFI::Struct
+      include NativeBuffer
+
+      layout(:length, :size_t,
+             :bytes, :pointer) 
+
+      attr_accessor :refs
+
+      def self.make(val)
+        nv = DB_string.new
+        nv.refs = make_in_place(nv, val)
+        nv
+      end
+
+      # Have to separate like this because FFI Doesn't allow
+      # assigning to structs by value.
+      def self.make_in_place(nv, val)
+        if val.is_a? String
+          val = NativeMallocBuffer.new(val)
+          nv[:bytes] = val.ptr
+          nv[:length] = val.length
+        elsif val.is_a? NativeBuffer
+          nv[:bytes] = val.ptr
+          nv[:length] = val.length
+        else
+          raise OinkyException.new("Argument is not a recognized string")
+        end
+
+        # Caller keeps the source object in memory as long as the variant.
+        # This is important whatever the source, ruby strings and 
+        # NativeBuffers equally.
+        return val
+      end
+
+      # These are required by NativeBuffer
+      def ptr
+        self[:bytes]
+      end
+      def length
+        self[:length]
+      end
+    end
+    attach_function :oinky_table_name, [:pointer], DB_string.by_value
+    attach_function :oinky_index_name, [:pointer], DB_string.by_value
+
+    attach_function :oinky_table_count, [:pointer], :size_t
+    attach_function :oinky_tbl_column_count, [:pointer], :size_t
+    attach_function :oinky_idx_column_count, [:pointer], :size_t
+    attach_function :oinky_tbl_index_count, [:pointer], :size_t
+    attach_function :oinky_tbl_row_count, [:pointer], :size_t
+    attach_function :oinky_idx_row_count, [:pointer], :size_t
+
+    attach_function :oinky_db_get_table_handles, [:pointer, :pointer, :size_t], :oinky_error
+    attach_function :oinky_table_get_index_handles, [:pointer, :pointer, :size_t], :oinky_error
+
+    NkyTypeCodes = FFI::Enum.new([
+                                :variant, 0,
+                                :bit, 1,
+                                :int8, 2,
+                                :int16, 3,
+                                :int32, 4,
+                                :int64, 5,
+                                :datetime, 6,
+                                :string, 7,
+                                :uint8, 8,
+                                :uint16, 9,
+                                :uint32, 10,
+                                :uint64, 11,
+                                :float32, 12,
+                                :float64, 13
+                               ])
+
+    class OinkyUnpackedDateTime < FFI::Struct    
+      layout(:years_since_1900, :int32, 
+             :months_since_january, :uint8,
+             :days_since_first_of_month, :uint8,
+             :hours_since_midnight, :uint8,
+             :minutes_since_hour, :uint8,
+             :seconds_since_minute, :uint8,
+             :microseconds_since_second, :uint32)
+    end
+
+    class OinkyDateTime < FFI::Struct
+      layout( :ptime, :int64 )
+
+      def self.parse(str)
+        # This can be a ruby string or a native string.  This method
+        # doesn't take a reference.
+        #puts "parsing: " + str
+        dt = DateTime.parse(str.to_s)
+        return from_dt(dt)
+      end
+      def self.from_intval(intval)
+        v = OinkyDateTime.new
+        v[:ptime] = intval
+        v
+      end
+      def intval
+        self[:ptime]
+      end
+      def self.from_dt(dt)
+        dt = dt.new_offset(0)
+
+        unpacked = OinkyUnpackedDateTime.new
+        unpacked[:years_since_1900] = dt.year - 1900
+        unpacked[:months_since_january] = dt.month - 1
+        unpacked[:days_since_first_of_month] = dt.day - 1
+        unpacked[:hours_since_midnight] = dt.hour
+        unpacked[:minutes_since_hour] = dt.minute
+        unpacked[:seconds_since_minute] = dt.second
+        unpacked[:microseconds_since_second] = (dt.second_fraction * 1000000).to_i
+
+        v = OinkyDateTime.new
+        Internal.wrap_oinky(Internal.nky_pack_datetime(v, unpacked))
+        v
+      end
+      def rb_val
+        unpacked = OinkyUnpackedDateTime.new
+        Internal.wrap_oinky(Internal.nky_unpack_datetime(self, unpacked))
+        # Make a datetime, accounting for sloppy encoding with overlapping 
+        # months and days
+        dt = DateTime.
+          new(1900 + unpacked[:years_since_1900]).
+          next_month(unpacked[:months_since_january]).
+          next_day(unpacked[:days_since_first_of_month])
+
+        daypart = 
+          ((((((unpacked[:hours_since_midnight] * 60) + 
+               unpacked[:minutes_since_hour]) * 60) +
+             unpacked[:seconds_since_minute]) * 1000000) +
+           unpacked[:microseconds_since_second]).quo(3600000000 * 24)
+
+        return dt + daypart
+      end
+      def to_datetime
+        rb_val
+      end
+    end
+
+    attach_function(:nky_unpack_datetime,
+                    [OinkyDateTime.by_value, OinkyUnpackedDateTime], :oinky_error)
+    attach_function(:nky_pack_datetime,
+                    [OinkyDateTime, OinkyUnpackedDateTime.by_value], :oinky_error)
+
+    class Variant < FFI::Struct
+    end
+
+    class VariantSet < FFI::MemoryPointer
+      attr_accessor :refs
+      
+      def count
+        @refs.count
+      end
+      
+      def initialize(count)
+        super(Variant, count)
+      end
+      
+      def [](x)
+        Variant.new(super(x))
+      end
+    end
+
+    class Variant
+      class ValueT < FFI::Union
+        layout(:string_value, DB_string,
+               :int_value, :int64,
+               :uint_value, :uint64,
+               :f32_value, FFI::TYPE_FLOAT32,
+               :f64_value, FFI::TYPE_FLOAT64,
+               :dt_value, :int64)
+      end
+
+      layout(:value, ValueT,
+             :type, NkyTypeCodes)
+
+      # We must do this again.  We can't rely on the one in the DB_string
+      # we create because that can get discarded as soon as we are finished
+      # using it to initialize.
+      attr_accessor :refs
+
+      def self.make(val)
+        nv = Variant.new
+        nv.refs = make_in_place(nv, val)
+        nv
+      end
+      def self.make_in_place(nv, val)
+        if val.is_a?(String) or val.is_a?(NativeBuffer)
+          nv[:type] = NkyTypeCodes[:string]
+          return DB_string.make_in_place(nv[:value][:string_value], val)
+        elsif val.is_a?(DateTime) or val.is_a?(Time) or val.is_a?(Date) or val.is_a?(OinkyDateTime)
+          dt = val.to_datetime
+          nv[:value][:dt_value] = OinkyDateTime.from_dt(dt).intval
+          nv[:type] = NkyTypeCodes[:datetime]
+          return nil
+        elsif val.is_a?(Fixnum) or val.is_a?(Bignum)
+          if val < 0
+            nv[:value][:int_value] = val
+            nv[:type] = NkyTypeCodes[:int64]
+          else
+            nv[:value][:uint_value] = val
+            nv[:type] = NkyTypeCodes[:uint64]
+          end
+          return nil
+        elsif val.is_a?(Float)
+          nv[:value][:f64_value] = val
+          nv[:type] = NkyTypeCodes[:float64]
+          return nil
+        elsif val.is_a?(TrueClass)
+          nv[:value][:int_value] = 1
+          nv[:type] = NkyTypeCodes[:bit]
+          return nil
+        elsif val.is_a?(FalseClass)
+          nv[:value][:int_value] = 0
+          nv[:type] = NkyTypeCodes[:bit]
+          return nil
+        else
+          raise OinkyException.new("Don't know how to make variant from given value of type: #{val.class}")
+        end
+        return nil
+      end
+
+      def self.make_from_set(set)
+        ptr = VariantSet.new(set.size)
+        ptr.refs = []
+        set.each_with_index{|v, i|
+          ptr.refs << make_in_place(ptr[i], v)
+        }
+        ptr
+      end
+
+      # Convert to a ruby value
+      def rb_val
+        v = self[:value]
+        case self[:type]
+        when :string
+          return v[:string_value].rb_str
+        when :datetime
+          return OinkyDateTime.from_intval(v[:dt_value]).to_datetime
+        when :bit
+          return v[:int_value] == 1
+
+        when :int8
+          return v[:int_value]
+        when :int16
+          return v[:int_value]
+        when :int32
+          return v[:int_value]
+        when :int64
+          return v[:int_value]
+
+        when :uint8
+          return v[:uint_value]
+        when :uint16
+          return v[:uint_value]
+        when :uint32
+          return v[:uint_value]
+        when :uint64
+          return v[:uint_value]
+
+        when :float32
+          return v[:f32_value]
+        when :float64
+          return v[:f64_value]
+        end
+        raise OinkyException.new("Invalid type code in Variant.")
+      end
+    end
+
+    class ColumnDefn < FFI::Struct
+      layout( :column_name, DB_string,
+              :column_type, NkyTypeCodes,
+              :default_value, Variant )
+
+      attr_accessor :refs
+
+      def self.make(name, type, value)        
+        v = ColumnDefn.new
+        cn = DB_string.make_in_place(v[:column_name], name)
+        dv = Variant.make_in_place(v[:default_value], value)
+        v[:column_type] = NkyTypeCodes[type]
+
+        # Keep these objects in memory
+        v.refs = [cn, dv]
+        v
+      end
+
+      class ColumnSet < FFI::MemoryPointer
+        attr_accessor :refs
+
+        def count
+          @refs.count
+        end
+
+        def initialize(count)
+          super(ColumnDefn, count)
+        end
+
+        def [](x)
+          ColumnDefn.new(super(x))
+        end
+      end
+    end
+
+    def self.make_hash(src, keys)
+      h = ExHash.new
+      keys.each {|k| h[k] = src[k] }
+      h
+    end
+
+    class IndexColumnDefn < FFI::Struct
+      layout( :column_name, DB_string,
+              :sort_ascending, :int8 )
+
+      attr_accessor :refs
+
+      def to_h
+        { :column_name=>self[:column_name].to_s,
+          :sort_ascending=>(self[:sort_ascending] != 0) }
+      end
+
+      def self.make(name, ascending = true)
+        v = IndexColumnDefn.new
+        v.refs = make_in_place(v, name, ascending)
+        v
+      end
+      def self.make_in_place(nv, name, ascending = true)
+        cn = DB_string.make_in_place(nv[:column_name], name)
+        nv[:sort_ascending] = ascending ? 1 : 0
+        cn
+      end
+
+      class IxColumnSet < FFI::MemoryPointer
+        attr_accessor :refs
+
+        def count
+          @refs.count
+        end
+
+        def initialize(count)
+          super(IndexColumnDefn, count)
+        end
+
+        def [](x)
+          IndexColumnDefn.new(super(x))
+        end
+      end
+
+      def self.make_from_set(set)
+        values = []
+        set.each {|col|
+          if col.is_a?(Symbol) or col.is_a?(String)
+            values << {:column_name=>col.to_s, :sort_ascending=>true}
+          elsif col.is_a? Hash
+            name = (col[:column_name] || col[:name] || col[:column]).to_s
+            ascending = true
+            [:ascending, :sort_ascending].each {|k|
+              ascending = false if (col.has_key?(k) and not col[k])
+            }
+            [:descending, :sort_descending].each {|k|
+              ascending = false if col[k]
+            }
+            values << {:column_name=>name, :sort_ascending=>ascending}
+          else
+            raise OinkyException.new("Unrecognized index columnset entry: #{col.class}")
+          end
+        }
+        ptr = IxColumnSet.new(values.size)
+        ptr.refs = []
+        values.each_with_index{|v, i|
+          ptr.refs << make_in_place(ptr[i], v[:column_name], v[:sort_ascending])
+        }
+        ptr
+      end
+    end
+
+    #oinky_error oinky_db_create_table(oinky_db_handle_t *db, const char *name, oinky_table_handle_t **handle);
+    attach_function(:oinky_db_create_table, 
+                    [:pointer, :string, :pointer], :oinky_error)
+    attach_function(:oinky_db_drop_table, 
+                    [:pointer, DB_string.by_value], :oinky_error)
+    attach_function(:oinky_table_add_column, 
+                    [:pointer, ColumnDefn.by_value], :oinky_error)
+    attach_function(:oinky_table_get_column_defs,
+                    [:pointer, :pointer, :size_t], :size_t)
+    attach_function(:oinky_index_get_definition,
+                    [:pointer, :pointer, :pointer, :pointer, :size_t], :oinky_error)
+    attach_function(:oinky_table_drop_column,
+                    [:pointer, DB_string.by_value], :oinky_error)
+
+    attach_function(:oinky_table_add_index, 
+                    [:pointer, :string, :int8, :size_t, :pointer, :pointer], 
+                    :oinky_error)
+    attach_function(:oinky_table_drop_index,
+                    [:pointer, DB_string.by_value], :oinky_error)
+
+    attach_function(:oinky_table_make_column_selector,
+                    [:pointer, :size_t, :pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_delete_column_selector,
+                    [:pointer, :pointer], :oinky_error)
+
+    # Index cursors
+    attach_function(:oinky_index_cursor_new, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_free,
+                    [:pointer, :pointer], :void)
+    attach_function(:oinky_index_cursor_clone,
+                    [:pointer, :pointer, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_seek_first, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_seek_lower_bound,
+                    [:pointer, :pointer, :size_t, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_seek_last, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_seek_prev, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_seek_next, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_index_cursor_state,
+                    [:pointer, :pointer], :int8)
+    attach_function(:oinky_index_cursor_get_values,
+                    [:pointer, :pointer, :size_t, :pointer, :pointer], :oinky_error)
+
+    # Table cursors
+    attach_function(:oinky_table_cursor_new, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_cursor_free,
+                    [:pointer, :pointer], :void)
+    attach_function(:oinky_table_cursor_clone,
+                    [:pointer, :pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_cursor_seek_first, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_cursor_seek_last, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_cursor_seek_prev, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_cursor_seek_next, 
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_cursor_state,
+                    [:pointer, :pointer], :int8)
+    attach_function(:oinky_table_cursor_get_values,
+                    [:pointer, :pointer, :size_t, :pointer, :pointer], :oinky_error)
+
+    # Data insertion
+    attach_function(:oinky_table_update_row_at_table_cursor,
+                    [:pointer, :pointer, :pointer, :size_t, :pointer], :oinky_error)
+    attach_function(:oinky_table_update_row_at_index_cursor,
+                    [:pointer, :pointer, :pointer, :size_t, :pointer], :oinky_error)
+    attach_function(:oinky_table_delete_row_at_table_cursor,
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_delete_row_at_index_cursor,
+                    [:pointer, :pointer], :oinky_error)
+    attach_function(:oinky_table_insert_row,
+                    [:pointer, :pointer, :size_t, :pointer], :oinky_error)
+
+    # The cursor types and implementation methods are different for index cursors
+    # and table cursors.  However, they operate almost identically.  This is the
+    # common implementation.  Index and Table specialize only slightly.
+    class CursorBase
+      def initialize(host)
+        if host.is_a? host_class
+          @host = host
+          @hosthandle = @host.send(:eval, "@handle")
+          c = FFI::MemoryPointer.new(:pointer)
+          Internal.wrap_oinky(impl(:cursor_new).call(@hosthandle, c))
+          @handle = c.read_pointer
+          seek_first
+        elsif host.is_a? self.class
+          c = FFI::MemoryPointer.new(:pointer)
+          h, @hosthandle, @host = host.send(:eval, "[@handle, @hosthandle, @host]")
+          Internal.wrap_oinky(impl(:cursor_clone).call(@hosthandle, h, c))
+          @handle = c.read_pointer
+        else
+          raise OinkyException.new("Unknown argument type to #{self.class}.new")
+        end
+
+        # Cursors are automatically destroyed when the DB is destroyed.
+        # If we call cursor deletion after DB deletion, that is equivalent to
+        # freeing twice.  It's bad.  But we have no way of controlling the
+        # order of finalizer invocation (between cursor and DB) short of
+        # referencing the DB in the cursor finalizer.  But that causes the DB
+        # to stick around for a whole extra GC cycle.  Generally, that overhead
+        # is much worse than leaking the cursor objects for the lifetime of 
+        # the DB.  So, we have two options:
+        # 1) Keep a reference on the DB object in the cursor finalizer, causing
+        #    a full GC-cycle delay in freeing DB resources.
+        # 2) Leak cursor objects always, letting them be cleaned up implicitly
+        #    when the DB is destroyed.
+        # This is a configuration property called Oinky.implicit_cursor_cleanup
+        # which defaults to 'true', indicating that we pursue strategy 2.  It
+        # is a property of the database object instance which applies to all
+        # cursors derived from that instance (table or index).
+        # cursors 
+        # applies to all cursors created after the property is set.  
+        # Changing the global or db-local value dynamically at any time is 
+        # safe.  It should generally only be set to 'false' for instances that 
+        # will be long-lived, where the aggregate overhead of cursors created 
+        # (tens of bytes) might compare to the overhead of the database itself.
+        
+        unless @host.db.implicit_cursor_cleanup
+          ObjectSpace.define_finalizer( self, self.class.finalize(impl(:cursor_free), @handle, {:db=>@host.db}) )
+        end
+      end
+      
+      def self.finalize(m, ptr, refs)
+        proc { m.call(ptr); refs[:db] = nil }
+      end
+
+      def seek_first
+        Internal.wrap_oinky(impl(:cursor_seek_first).call(@hosthandle, @handle))
+        self
+      end
+      def seek_last
+        Internal.wrap_oinky(impl(:cursor_seek_last).call(@hosthandle, @handle))
+        self
+      end
+      def seek_next
+        Internal.wrap_oinky(impl(:cursor_seek_next).call(@hosthandle, @handle))
+        self
+      end
+      def seek_prev
+        Internal.wrap_oinky(impl(:cursor_seek_prev).call(@hosthandle, @handle))
+        self
+      end
+      def state_val
+        impl(:cursor_state).call(@hosthandle, @handle)
+      end
+      def is_valid?
+        state_val == 0
+      end
+      def at_end?
+        state_val == 1
+      end
+      def before_begin?
+        state_val == -1
+      end
+      def clone
+        self.class.new(self)
+      end
+      def column_selector_default(cs = nil)
+        cs = self.table.select_all_columns unless cs
+        cs = self.table.select_columns(cs) unless cs.is_a? ColumnSelector
+        cs
+      end
+      def select(cs = nil)
+        cs = self.column_selector_default(cs)
+        vals = self.select_values(cs)
+        r = ExHash.new
+        cns = cs.cols
+        vals.each_with_index{|v,i|
+          r[cns[i]] = v
+        }
+        return r
+      end
+      def select_all
+        self.select(nil)
+      end
+      # Like <select>, but just returns values as an array, rather
+      # than as a hash
+      def select_values(cs = nil)
+        cs = column_selector_default(cs)
+        vs = Internal::VariantSet.new(cs.size)
+        out_count = FFI::MemoryPointer.new :size_t
+        Internal.wrap_oinky(impl(:cursor_get_values).call(@handle, cs.handle, cs.size, vs, out_count))
+        (0..out_count.read_int-1).map{|i| vs[i].rb_val }
+      end
+      def select_all_values
+        self.select_values(nil)
+      end
+      # Move this cursor forward until the end (or until enumeration is stopped)
+      def each_forward(cs = nil)
+        e = ValuesEnumerator.new {|blk|
+          # The cursor may not begin in a valid position
+          self.seek_next unless self.is_valid?
+          while self.is_valid?
+            blk.yield self.select(cs)
+            self.seek_next
+          end
+        }
+        if block_given?
+          e.each{|k| yield k}
+        else
+          return e
+        end
+        self
+      end
+      def each_backward(cs = nil)
+        e = ValuesEnumerator.new {|blk|
+          # The cursor may not begin in a valid position
+          self.seek_prev unless self.is_valid?
+          while self.is_valid?
+            blk.yield self.select(cs)
+            self.seek_prev
+          end
+        }
+        if block_given?
+          e.each{|k| yield k}
+        else
+          return e
+        end
+        self
+      end
+    end # class CursorBase
+  end # Internal
+
+  # These should be exposed for defining column values, even though we do not
+  # expose the Variant concept itself.
+  column_types = Internal::NkyTypeCodes.to_h.keys.sort
+  ValueTypes = column_types.select{|x| x != :variant}
+  ColumnTypes ||= column_types
+
+  # ColumnTypes may have been previously defined (by the compiler)
+  # but if so, the definition should have been identical.
+  unless ColumnTypes == column_types 
+    raise OinkyException.new("Mismatched column types definition: " +
+                         "#{ColumnTypes.inspect} != #{column_types.inspect}")
+  end
+
+  class ColumnSelector
+    def initialize(table, colnames)
+      th = table.send(:eval, "@handle")
+
+      # Make an array of strings.
+      colnames = [colnames] unless colnames.is_a? Enumerable
+      colnames = colnames.to_a
+      colnames = colnames.map {|v| v.to_s}
+
+      # Make an array of c-strings
+      cols = FFI::MemoryPointer.new(:string, colnames.size)
+      native = NativeMallocBuffer.new((colnames * "\x00") + "\x00")
+      ptr = native.ptr
+      colnames.each_with_index{|s,i|
+        # The routine expects null-terminated strings.
+        cols[i].write_pointer(ptr)
+        ptr = ptr + s.length + 1
+      }
+
+      cs = FFI::MemoryPointer.new :pointer
+      Internal.wrap_oinky(Internal.oinky_table_make_column_selector(th, colnames.size, cols, cs))
+      @handle, @cols = [cs.read_pointer, colnames]
+
+      ObjectSpace.define_finalizer( self, self.class.finalize(table, @handle) )
+    end
+    
+    def self.finalize(tptr, hptr)
+      proc { Internal.oinky_table_delete_column_selector(tptr, hptr) }
+    end
+
+    # column selectors are immutable.  cloning would cause us to free twice
+    # anyway.
+    def clone
+      self
+    end
+
+    attr_reader :handle, :cols
+
+    def size
+      cols.size
+    end
+  end
+
+  # This is a column selector that's not bound to a particular table
+  class OpenSelector
+    attr_accessor :cols
+    def initialize(cols)
+      @cols = cols
+    end
+    def from(target)
+      target.each(@cols)
+    end
+  end
+  def self.select(cols)
+    OpenSelector.new(cols)
+  end
+  def self.select_all
+    select(nil)
+  end
+
+  module RowSet
+    def cursor_each
+      e = Enumerator.new {|blk|
+        c = self.new_cursor
+        while c.is_valid?
+          blk.yield c
+          c.seek_next
+        end
+      }
+      if block_given?
+        e.each{|k| yield k}
+      else
+        return e
+      end
+    end
+
+    def each(cs = nil)
+      # Making the selector first will be most efficient
+      cs = @table.select_columns(cs)
+
+      e = ValuesEnumerator.new {|blk|
+        self.cursor_each { |c| blk.yield c.select(cs) }
+      }
+      if block_given?
+        e.each{|k| yield k}
+      else
+        return e
+      end
+    end
+
+    def new_cursor(*a)
+      self.class::Cursor.new(self, *a)
+    end
+  end # module RowSet
+
+  class Table
+    include RowSet
+
+    def initialize(db, handle)
+      @db, @handle = db, handle
+      @table = self
+    end
+
+    attr_reader :db
+
+    def column_count
+      Internal.oinky_tbl_column_count(@handle)
+    end
+    def index_count
+      Internal.oinky_tbl_index_count(@handle)
+    end
+    def row_count
+      Internal.oinky_tbl_row_count(@handle)
+    end
+
+    def add_column(*a)
+      add_columns([a])
+    end
+    def add_columns(cset)
+      @db.atomic {
+        if cset.is_a? Hash
+          cset.each {|name,v|
+            add_column_internal(v.merge(:name=>name))
+          }
+        else
+          cset.each {|a|
+            add_column_internal(a)
+          }
+        end
+        # Refresh the default column selector
+        reselect_all_columns
+      }
+      self
+    end
+
+    private
+    def add_column_internal(a)
+      a = a[0] if (a.size == 1)
+      name, type, default_v = a
+      if a.is_a? Hash
+        h = a
+        name = (h[:column_name] || h[:name])
+        type = (h[:column_type] || h[:type])
+        default_v = (h[:default_value] || h[:default])
+      end
+      name = name.to_s if name.is_a? Symbol
+      # This will raise if the parameters are wrong.
+      defn = Internal::ColumnDefn.make(name, type, default_v)
+      # All parameters are good at this point
+      Internal.wrap_oinky(Internal.oinky_table_add_column(@handle, defn))
+    end
+
+    public
+    def add_index(opts)
+      name = opts[:name]
+      raise OinkyException.new("Invalid index name") unless name.length
+      colset = (opts[:columns] or opts[:columnset])
+      raise OinkyException.new("Oinky::Table::add_index: ':columns' not specified") unless colset
+      raise OinkyException.new("Oinky::Table::add_index: ':unique' not specified") unless opts.has_key?(:unique)
+      unique = opts[:unique]
+      
+      iptr = FFI::MemoryPointer.new :pointer
+      colset = Internal::IndexColumnDefn.make_from_set(colset)
+      Internal.wrap_oinky(Internal.oinky_table_add_index(
+                                                         @handle, 
+                                                         name, 
+                                                         unique ? 1 : 0,
+                                                         colset.count,
+                                                         colset,
+                                                         iptr))
+      #return Index.new(iptr.read_pointer)
+      #
+      # It makes more sense that this should be like column than like
+      # create_table
+      self
+    end
+
+    def name
+      return @tblname if @tblname
+      dbs = Internal.oinky_table_name(@handle)
+      @tblname = dbs.to_s
+    end
+
+    def columns
+      sz = self.column_count()
+      defs = Internal::ColumnDefn::ColumnSet.new(sz)
+      rsz = Internal.oinky_table_get_column_defs(@handle, defs, sz)
+      unless rsz == sz
+        raise OinkyException.new("Oinky: Unknown interface error - columncount [#{rsz}, #{sz}]") 
+      end
+      cols = ExHash.new
+      (0..sz-1).each{|i|
+        cd = defs[i]
+        cols[cd[:column_name].to_s] = {:type=>cd[:column_type], :default =>cd[:default_value].rb_val}
+      }
+      cols
+    end
+
+    def drop_column(colname)
+      dbs = Internal::DB_string.make(colname.to_s)
+      Internal.wrap_oinky(Internal.oinky_table_drop_column(@handle, dbs))
+      # Refresh the colset cache
+      reselect_all_columns
+      self
+    end
+
+    def select_columns(colnames)
+      return self.select_all_columns unless colnames
+      return colnames if colnames.is_a? ColumnSelector
+      ColumnSelector.new(self, colnames)
+    end
+
+    # Caches the selector
+    def select_all_columns
+      @selectall ||= self.reselect_all_columns
+    end
+    # Refreshes the selector cache
+    def reselect_all_columns
+      @selectall = self.select_columns(self.columns.keys)
+    end
+
+    def select(cs)
+      cs = self.select_columns(cs)
+      e = self.each(cs)
+      if block_given?
+        e.each {|k| yield k}
+      else
+        return e
+      end
+    end
+
+    def select_all
+      e = self.select(self.select_all_columns)
+      if block_given?
+        e.each {|k| yield k}
+      else
+        return e
+      end
+    end
+
+    def indices
+      sz = self.index_count()
+      handles = FFI::MemoryPointer.new(:pointer, sz)
+      rsz = Internal.oinky_table_get_index_handles(@handle, handles, sz)
+      unless rsz == sz
+        raise OinkyException.new("Oinky: Unknown interface error - indexcount") 
+      end
+      r = ExHash.new
+      (0..sz-1).each{|i| 
+        ix = Index.new(self, handles[i].read_pointer)
+        r[ix.name] = ix
+      }
+      return r
+    end
+
+    def drop_index(ixname)
+      dbs = Internal::DB_string.make(ixname.to_s)
+      Internal.wrap_oinky(Internal.oinky_table_drop_index(@handle, dbs))
+      self
+    end
+
+    class Cursor < Internal::CursorBase
+      private
+      def impl(name)
+        Internal.method("oinky_table_#{name}".to_sym)
+      end
+      def host_class
+        Table
+      end
+      public
+      def table
+        @host
+      end
+      # Cannot seek by value in a table
+      if method_defined? :seek
+        undef :seek
+      end
+    end # class Cursor
+
+    def update_row(where, cs, values = nil)
+      unless where.is_a? Internal::CursorBase
+        raise OinkyException.new("Invalid row specifier.  Use a Cursor object.") 
+      end
+      cs, count, vals = make_selector_and_values(:update_row, cs, values)
+      p = nil
+      if (where.is_a? Table::Cursor)
+        p = Internal.method :oinky_table_update_row_at_table_cursor
+      else
+        p = Internal.method :oinky_table_update_row_at_index_cursor
+      end
+      Internal.wrap_oinky(
+          p.call(
+            @handle, 
+            where.send(:eval,"@handle"), 
+            cs.handle, 
+            count,
+            vals))
+      self
+    end #def update_row
+
+    def delete_row(where)
+      unless where.is_a? Internal::CursorBase
+        raise OinkyException.new("Invalid row specifier.  Use a Cursor object.") 
+      end
+      p = nil
+      if (where.is_a? Table::Cursor)
+        p = Internal.method :oinky_table_delete_row_at_table_cursor
+      else
+        p = Internal.method :oinky_table_delete_row_at_index_cursor
+      end
+      Internal.wrap_oinky(
+          p.call(
+            @handle, 
+            where.send(:eval,"@handle")))
+      self
+    end #def delete_row
+
+    def insert_row(cs, values = nil)
+      cs, count, vals = make_selector_and_values(:insert_row, cs, values)
+      Internal.wrap_oinky(
+          Internal.oinky_table_insert_row(
+            @handle, 
+            cs.handle, 
+            count,
+            vals))
+      self
+    end #def insert_row
+
+    private
+    def make_selector_and_values(mname, cs, values)
+      if cs.is_a? Hash
+        kg = []
+        vg = []
+        cs.each {|k,v|
+          kg << k
+          vg << v
+        }
+        cs = select_columns(kg)
+        return make_selector_and_values(mname, cs, vg)
+      else
+        unless cs.is_a? ColumnSelector
+          raise OinkyException.new("#{mname} requires a ColumnSelector and Value-array or a column-value Hash.")
+        end
+        unless cs.size == values.size
+          raise OinkyException.new("Size of values array must match selector width.")
+        end
+        return [cs, cs.size, Internal::Variant.make_from_set(values)]
+      end
+    end # make_selector_and_values
+  end # class Table
+
+  class Index
+    include RowSet
+
+    def initialize(table, handle)
+      @table, @handle = table, handle
+    end
+
+    attr_reader :table
+    def db ; @table.db ; end
+
+    def column_count
+      Internal.oinky_idx_column_count(@handle)
+    end
+    def row_count
+      Internal.oinky_idx_row_count(@handle)
+    end
+
+    def definition
+      return @definition if @definition
+
+      sz = self.column_count()
+      nm = FFI::MemoryPointer.new(Internal::DB_string)
+      uniq = FFI::MemoryPointer.new(:char)
+      defs = Internal::IndexColumnDefn::IxColumnSet.new(sz)
+      Internal.wrap_oinky(Internal.oinky_index_get_definition(@handle, nm, uniq, defs, sz))
+
+      # Unlike the table, ordering of the index column definitions is 
+      # semantically important.
+      @definition = { 
+        :name=>Internal::DB_string.new(nm).to_s,
+        :unique=>uniq.read_char != 0 ? true : false,
+        :columns=> (0..sz-1).map{|i|
+          defs[i].to_h
+        }
+      }
+      @colnames = @definition[:columns].map{|c| c[:column_name] }
+      return @definition
+    end
+
+    def columns
+      definition
+      @colnames
+    end
+
+    def selector
+      table.select_columns(self.columns)
+    end
+
+    def name
+      return @idxname if @idxname
+      dbs = Internal.oinky_index_name(@handle)
+      @idxname = dbs.to_s
+    end
+
+    class Cursor < Internal::CursorBase
+      private
+      def impl(name)
+        Internal.method("oinky_index_#{name}".to_sym)
+      end
+      def host_class
+        Index
+      end
+      public
+      def table
+        @host.table
+      end
+
+      def initialize(host, where = nil)
+        super(host)
+        if where
+          seek(where)
+        end
+      end
+
+      def seek(where)
+        vars = Internal::Variant.make_from_set(where)
+        Internal.wrap_oinky(Internal.oinky_index_cursor_seek_lower_bound(@hosthandle, @handle, vars.count, vars))
+        self
+      end
+    end
+  end #class Index
+
+  # By default, we never free cursors explicitly, which allows the GC to
+  # free database instances more aggressively.  These accessors allow the 
+  # bahavior to be changed.  See the comment in the CursorBase initializer.
+  @@implicit_cursor_cleanup = true
+  def self.implicit_cursor_cleanup
+    @@implicit_cursor_cleanup
+  end
+  def self.implicit_cursor_cleanup=(x)
+    @@implicit_cursor_cleanup = x
+  end
+
+  class DB
+    attr_accessor :implicit_cursor_cleanup
+    attr_reader :source_buffer
+
+    def initialize(ptr = nil, s = nil)
+      if ptr
+        unless ptr.is_a? FFI::Pointer
+          raise OinkyException.new("Can't initialize oinky DB with given value of type: #{ptr.class}")
+        end
+        @db_ptr = ptr
+      else
+        # Create an empty DB
+        @db_ptr = Internal.oinky_db_new
+      end
+      # We must preserve a reference to the heap-string object, at least until
+      # we destroy the DB instance.
+      @source_buffer = s
+
+      # Make an instance-local copy of the global default.  Changing the global
+      # after this point will not alter the behavior of cursors on this instance.
+      @implicit_cursor_cleanup = Oinky.implicit_cursor_cleanup
+
+      ObjectSpace.define_finalizer( self, self.class.finalize(@db_ptr) )
+    end
+    
+    def self.finalize(ptr)
+      proc { Internal.oinky_db_free(ptr) }
+    end
+
+    # Deep copy is this simple
+    def clone
+      str = self.serialize
+      self.class.mount(str)
+    end
+
+    def self.mount(s)
+      if s.is_a? String
+        s = NativeMallocBuffer.new(s)
+      end
+      unless s.is_a? NativeBuffer
+        raise OinkyException.new("Oinky can only mount a String or a NativeBuffer") 
+      end
+      ptr = FFI::MemoryPointer.new :pointer
+      Internal.wrap_oinky(Internal.oinky_db_mount(ptr, s.length, s.ptr))
+      return DB.new(ptr.read_pointer, s)
+    end
+
+    class Savepoint
+      attr_reader :db, :value
+      def initialize(db, value)
+        @db, @value = db, value
+      end
+    end
+
+    def create_savepoint
+      sp = FFI::MemoryPointer.new(:uint64)
+      Internal.wrap_oinky(Internal.oinky_db_create_savepoint(@db_ptr, sp))
+      return Savepoint.new(self, sp.read_uint64)
+    end
+
+    def savepoint_rollback(sp)
+      unless sp.is_a?(Savepoint) and (sp.db == self)
+        raise OinkyException.new("ArgumentError.  SP does not match this DB instance")
+      end
+      Internal.wrap_oinky(Internal.oinky_db_savepoint_rollback(@db_ptr, sp.value))
+      self
+    end
+
+    # This is intended to support a write cache.
+    #
+    # Determines whether the database has been modified since the given 
+    # savepoint.  This can generate some false positives in the case where 
+    # the only relevant changes were rolled back to a former state, but 
+    # this transient ambiguity can be eliminated by creating a new savepoint
+    # to test against, after each writeback.
+    def modified_since?(sp)
+      Internal.oinky_db_is_modified_since(@db_ptr, sp.value) != 0
+    end
+
+    # Usage:
+    #
+    # db.atomic {
+    #   db.create_table 'foo'
+    #   db.create_table 'bar'
+    #   ...
+    # }
+    def atomic
+      sp = self.create_savepoint
+      begin
+        yield
+        sp = nil
+      ensure
+        self.savepoint_rollback(sp) if sp
+      end
+      self
+    end
+
+    def table_count
+      Internal.oinky_table_count(@db_ptr)
+    end
+
+    def serialize
+      size = Internal.prepare_pack(@db_ptr)
+      str = NativeMallocBuffer.new(size)
+      Internal.wrap_oinky(Internal.oinky_db_complete_pack(@db_ptr, str.length, str.ptr))
+      str
+    end
+
+    def create_table(name)
+      handle = FFI::MemoryPointer.new :pointer
+      Internal.wrap_oinky(Internal.oinky_db_create_table(@db_ptr, name.to_s, handle))
+      tbl = Table.new(self, handle.read_pointer)
+      if block_given? 
+        yield tbl
+      end
+      self
+    end
+
+    def drop_table(name)
+      name = name.name if name.is_a? Table
+      dbs = Internal::DB_string.make(name.to_s)
+      Internal.wrap_oinky(Internal.oinky_db_drop_table(@db_ptr, dbs))
+      self
+    end
+
+    def tables
+      sz = self.table_count()
+      handles = FFI::MemoryPointer.new(:pointer, sz)
+      rsz = Internal.oinky_db_get_table_handles(@db_ptr, handles, sz)
+      unless rsz == sz
+        raise OinkyException.new("Oinky: Unknown interface error - tablecount") 
+      end
+      
+      map = ExHash.new
+      (0..sz-1).each{|i| 
+        th = Table.new(self, handles[i].read_pointer)
+        map[th.name] = th
+      }
+      map.freeze
+    end
+
+    def [](tblname)
+      return tables[tblname]
+    end
+
+    def with_table(tblname)
+      yield self[tblname]
+      return self
+    end
+
+    def alter_table(tblname)
+      self.atomic {
+        yield self[tblname]
+      }
+    end
+  end
+end
+