oinky 0.1.0

data/ext/include/oinky/nky_dialect.hpp

@@ -0,0 +1,107 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+//  Need this for stderr
+#include <stdio.h>
+
+namespace Oinky
+{
+
+typedef uint8_t uint8;
+typedef uint16_t uint16;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+typedef int8_t int8;
+typedef int16_t int16;
+typedef int32_t int32;
+typedef int64_t int64;
+
+typedef float float32;
+typedef double float64;
+
+BOOST_STATIC_ASSERT(sizeof(float32) == 4);
+BOOST_STATIC_ASSERT(sizeof(float64) == 8);
+
+template<typename DERIVED>
+struct with_compare_ops
+{
+    bool operator==(const DERIVED &other) const { return ((const DERIVED *)this)->compare_to(other) == 0; }
+    bool operator!=(const DERIVED &other) const { return ((const DERIVED *)this)->compare_to(other) != 0; }
+    bool operator<(const DERIVED &other) const { return ((const DERIVED *)this)->compare_to(other) < 0; }
+    bool operator>(const DERIVED &other) const { return ((const DERIVED *)this)->compare_to(other) > 0; }
+    bool operator<=(const DERIVED &other) const { return ((const DERIVED *)this)->compare_to(other) <= 0; }
+    bool operator>=(const DERIVED &other) const { return ((const DERIVED *)this)->compare_to(other) >= 0; }
+};
+
+//  This is used to verify that user-supplied callbacks satisfy the proper function concept.
+template<typename FN, typename F>
+static inline void check_function_concept(F f)
+{
+    //  template indirection than the next line.  This must be wrapped
+    //  in a dead if statement, because otherwise this might allocate 
+    //  a function object on the heap, depending on the compiler and type of FN.
+    if (false) {
+        boost::function<FN> x(f);
+    }
+}
+
+#ifndef MAX
+#define MAX(a,b) ((a) < (b) ? (b) : (a))
+#endif
+#ifndef MIN
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+
+
+#define __OINKY_TRACE_ASSERT_QUOTEME_(x) #x
+#define __OINKY_TRACE_ASSERT_QUOTEME(x) __OINKY_TRACE_ASSERT_QUOTEME_(x)
+
+#define OINKY_TRACE_ASSERT(VAL) {if (!(VAL)) assert_exit("[" __FILE__ ":" __OINKY_TRACE_ASSERT_QUOTEME(__LINE__) "] Assertion Failed: ", __OINKY_TRACE_ASSERT_QUOTEME_(VAL)); }
+#define OINKY_TRACE_ASSERT_MSG(VAL,MSG) {if (!(VAL)) assert_exit("[" __FILE__ ":" __OINKY_TRACE_ASSERT_QUOTEME(__LINE__) "] ", MSG); }
+
+#ifdef DEBUG
+#define OINKY_ASSERT OINKY_TRACE_ASSERT
+#define OINKY_ASSERT_MSG OINKY_TRACE_ASSERT_MSG
+#else
+#define OINKY_ASSERT(VAL) {}
+#define OINKY_ASSERT_MSG(VAL,MSG) {}
+#endif
+
+static void assert_exit(const char *message1, const char *message2)
+{
+    fprintf(stderr, "%s%s\n", message1, message2);
+    fflush(stderr);
+    
+	::abort();
+}
+
+//  This just forwards to the boost implementation for now, but
+//  it's nice that we can redirect it later easily, if everyone
+//  goes through this for now.
+static void throw_error(const boost::system::error_code& err) {
+	//  This derives from std::runtime_error which derives from std::exception.
+	boost::system::system_error e(err);
+	boost::throw_exception(e);
+}
+
+inline uint32 map_into_range(uint32 ref, uint32 min_inc, uint32 max_inc, uint32 default_v) {
+    //  Check that it's greater than or equal to min_inc, and less than or equal to N.
+    int32 fail = ref - min_inc;
+    fail |= max_inc - ref;
+    //  The high bit of fail now indicates that the ref is bad.
+    //  Right-shift with sign-extend means all bits are set if ref is bad,
+    //  all clear if ref is good.
+    fail >>= 31;
+    ref &= ~fail;
+    //  Ref is now the same as it was, or zero if it was out of range.
+    //  Set the low bit if it was bad.
+    ref |= fail & default_v;
+    return ref;
+}
+
+
+} //namespace Oinky
+

data/ext/include/oinky/nky_error.hpp

@@ -0,0 +1,164 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+namespace Oinky
+{
+namespace Errors
+{
+	using namespace boost::system;
+
+    //  Simulate enum class.
+	namespace oinky_code
+	{
+		enum oinky_code
+		{
+			success = 0,
+
+			implementation_bug = 1,
+			no_resources = 2,
+			invalid_argument = 5,
+			unknown_exception = 6,
+            row_format_mismatch = 8,
+            column_type_mismatch = 9,
+            object_deleted = 10,
+            object_exists = 11,
+            index_entry_not_unique = 12,
+            version_mismatch = 13,
+            unsupported_operation = 14,
+            object_still_referenced = 15,
+            incomparable_value_types = 16,
+            column_not_indexable = 17,
+            object_not_found = 18,
+            buffer_overflow = 19,
+            buffer_underflow = 20,
+            bad_encoding = 21,
+            cursor_out_of_range = 22,
+            limit_exceeded = 23
+		};
+	}
+
+	class oinky_category_impl : public error_category
+	{
+	public:
+		virtual const char* name() const { return "Oinky"; }
+		virtual std::string message(int ev) const {
+            return messagebytes(ev);
+        }
+		static const char *messagebytes(int ev) {
+			switch (ev) {
+				case oinky_code::success : return "Oinky success??";
+                
+				case oinky_code::implementation_bug : return "Oh NO! Implementation bug.";
+				case oinky_code::no_resources : return "Out of system resources (probably memory).";
+				case oinky_code::invalid_argument : return "Invalid Argument.";
+				case oinky_code::unknown_exception : return "An unrecognized exception was generated.  It does not derive from boost::system::runtime_error.";
+                case oinky_code::row_format_mismatch : return "Bad row format.  Number of column values does not match selector.";
+                case oinky_code::column_type_mismatch : return "The given value does not conform to column type.";
+                case oinky_code::object_deleted : return "The object has been deleted.";
+                case oinky_code::object_exists : return "The object already exists.";
+                case oinky_code::index_entry_not_unique : return "A uniqueness constraint has been violated.";
+                case oinky_code::version_mismatch : return "This version of the library cannot handle the target datum.";
+                case oinky_code::unsupported_operation : return "The operation is not supported.";
+                case oinky_code::object_still_referenced : return "The object cannot be deleted because it is still referenced.";
+                case oinky_code::incomparable_value_types : return "The two values can't be compared, because they are of incompatible type.";
+                case oinky_code::column_not_indexable : return "The column can't be indexed, because its cell types are incomparable.";
+				case oinky_code::object_not_found : return "The object was not found.";
+				case oinky_code::buffer_overflow : return "Serialization: buffer overflow";
+				case oinky_code::buffer_underflow : return "Serialization: buffer underflow.";
+				case oinky_code::bad_encoding : return "Serialization: bad encoding.";
+				case oinky_code::cursor_out_of_range : return "The cursor is beyond its valid range.";
+				case oinky_code::limit_exceeded : return "One or more of the semantic limits has been reached (eg: #columns/rows/etc.)";
+			}
+            return "Unknown Oinky failure (invalid code).";
+		}
+
+        //  TBD:
+        //  Few of these error conditions map very well.  Sort it out later with
+        //  more context.
+		virtual error_condition default_error_condition(int ev) const {
+			switch (ev) {
+				case oinky_code::success : return boost::system::errc::success;
+				case oinky_code::implementation_bug : return boost::system::errc::argument_out_of_domain;
+				case oinky_code::no_resources : return boost::system::errc::not_enough_memory;
+				case oinky_code::invalid_argument : return boost::system::errc::invalid_argument;
+				case oinky_code::unknown_exception : return boost::system::errc::argument_out_of_domain;
+                case oinky_code::row_format_mismatch : return boost::system::errc::argument_out_of_domain;
+                case oinky_code::column_type_mismatch : return boost::system::errc::argument_out_of_domain;
+                case oinky_code::object_deleted : return boost::system::errc::no_such_file_or_directory;
+                case oinky_code::object_exists : return boost::system::errc::address_in_use;
+                case oinky_code::index_entry_not_unique : return boost::system::errc::address_in_use;
+                case oinky_code::version_mismatch : return boost::system::errc::invalid_argument;
+                case oinky_code::unsupported_operation : return boost::system::errc::invalid_argument;
+                case oinky_code::object_still_referenced : return boost::system::errc::invalid_argument;
+                case oinky_code::incomparable_value_types : return boost::system::errc::invalid_argument;
+                case oinky_code::column_not_indexable : return boost::system::errc::invalid_argument;
+				case oinky_code::object_not_found : return boost::system::errc::no_such_file_or_directory;
+				case oinky_code::buffer_overflow : return boost::system::errc::no_buffer_space;
+				case oinky_code::buffer_underflow : return boost::system::errc::message_size;
+				case oinky_code::bad_encoding : return boost::system::errc::bad_message;
+				case oinky_code::cursor_out_of_range : return boost::system::errc::argument_out_of_domain;
+				case oinky_code::limit_exceeded : return boost::system::errc::argument_out_of_domain;
+
+				default: return boost::system::error_condition(ev, *this);
+			}
+		}
+	};
+
+	namespace ErrDetail
+	{
+		//  Templating avoids duplicate implementations when linking. =)
+		template<typename CAT>
+		const error_category& __unique_category()
+		{
+			static CAT instance;
+			return instance;
+		}
+    }   
+    
+    inline const error_category& oinky_category()
+    {
+        return ErrDetail::__unique_category<oinky_category_impl>();
+    }
+
+    template<int intcode>
+    class oinky_error_class : public error_code 
+    { 
+    public: 
+        oinky_error_class() : error_code(intcode,oinky_category()) {} 
+    };
+
+	class implementation_bug : public oinky_error_class<oinky_code::implementation_bug> {};
+	class no_resources : public oinky_error_class<oinky_code::no_resources> {};
+	class invalid_argument : public oinky_error_class<oinky_code::invalid_argument> {};
+	class unknown_exception : public oinky_error_class<oinky_code::unknown_exception> {};
+    class row_format_mismatch : public oinky_error_class<oinky_code::row_format_mismatch> {};    
+    class column_type_mismatch : public oinky_error_class<oinky_code::column_type_mismatch> {};        
+    class object_deleted : public oinky_error_class<oinky_code::object_deleted> {};        
+    class object_exists : public oinky_error_class<oinky_code::object_exists> {};        
+    class index_entry_not_unique : public oinky_error_class<oinky_code::index_entry_not_unique> {};        
+    class version_mismatch : public oinky_error_class<oinky_code::version_mismatch> {};        
+    class unsupported_operation : public oinky_error_class<oinky_code::unsupported_operation> {};        
+    class object_still_referenced : public oinky_error_class<oinky_code::object_still_referenced> {};        
+    class incomparable_value_types : public oinky_error_class<oinky_code::incomparable_value_types> {};        
+    class column_not_indexable : public oinky_error_class<oinky_code::column_not_indexable> {};        
+	class object_not_found : public oinky_error_class<oinky_code::object_not_found> {};
+	class buffer_overflow : public oinky_error_class<oinky_code::buffer_overflow> {};
+	class buffer_underflow : public oinky_error_class<oinky_code::buffer_underflow> {};
+	class bad_encoding : public oinky_error_class<oinky_code::bad_encoding> {};
+	class cursor_out_of_range : public oinky_error_class<oinky_code::cursor_out_of_range> {};
+	class limit_exceeded : public oinky_error_class<oinky_code::limit_exceeded> {};
+
+} //namespace Errors
+} //namespace Oinky
+
+namespace boost
+{
+namespace system
+{
+	template <>
+	struct is_error_code_enum<Oinky::Errors::oinky_category_impl> : public true_type {};
+};
+};
+

data/ext/include/oinky/nky_fixed_table.hpp

@@ -0,0 +1,710 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+namespace Oinky
+{
+namespace Internal
+{
+using namespace Oinky::Errors;
+using Oinky::Serialization::v1_sformat_tag;
+
+//
+//  This is used to deserialize row values, but also by the
+//  serialization component to (de)serialize default values for columns.
+//
+struct i_stored_value
+{
+    template<typename STRTABLE>
+    static void pack_string(const safe_cv_t &val, char *cursor, const STRTABLE &strtable)
+    {
+        OINKY_ASSERT(val.is_string());
+        Oinky::Serialization::pack_nbc<v1_sformat_tag, u_strtable_ref>(strtable.xform_ref(val), cursor);
+    }
+    
+    template<typename STRTABLE>
+    static void pack_variant(const safe_cv_t &val, char *cursor, const STRTABLE &strtable)
+    {
+        //  Not all of the values below fill the whole cell.
+        *(int64 *)cursor = 0;
+        switch (val.type()) {
+            case value_types::String :
+                pack_string(val, cursor, strtable);
+                return;
+            case value_types::Datetime:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, datetime_t>(val.dt_value(), cursor);
+                return;
+            //int
+            case value_types::Int8:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, int8>(val.int_value(), cursor);
+                return;
+            case value_types::Int16:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, int16>(val.int_value(), cursor);
+                return;
+            case value_types::Int32:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, int32>(val.int_value(), cursor);
+                return;
+            case value_types::Int64:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, int64>(val.int_value(), cursor);
+                return;
+            //uint
+            case value_types::Uint8:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, uint8>(val.uint_value(), cursor);
+                return;
+            case value_types::Uint16:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, uint16>(val.uint_value(), cursor);
+                return;
+            case value_types::Uint32:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, uint32>(val.uint_value(), cursor);
+                return;
+            case value_types::Uint64:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, uint64>(val.uint_value(), cursor);
+                return;
+            //float
+            case value_types::Float32:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, float32>(val.f32_value(), cursor);
+                return;
+            case value_types::Float64:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, float64>(val.f64_value(), cursor);
+                return;
+                
+            case value_types::Bit:
+                Oinky::Serialization::pack_nbc<v1_sformat_tag, bool>(val.bit_value(), cursor);
+                return;
+        }
+        //  Somewhere there is corruption.
+        throw_error(implementation_bug());
+    }
+
+    template<typename T>
+    static inline T unpack_raw(const char *bytes)
+    {
+        T value;
+        Oinky::Serialization::unpack_nbc<v1_sformat_tag,T>(
+            &value,
+            bytes);
+        return value;
+    };
+    template<typename T>
+    static inline void unpack_variant(variant_cv_t *val, const char *bytes)
+    {
+        T value = unpack_raw<T>(bytes);
+        *val = value;
+    };
+
+    //  Can be meta or user strtable.
+    template<typename STRTABLE>
+    static void unpack(safe_cv_t *target, value_type_code_t vt, const char *bytes, const STRTABLE *strtable) 
+    {
+        variant_cv_t val;
+        //  This should throw if this is a string and the ref is invalid.
+        unpack(&val, vt, bytes, strtable);
+        *target = safe_cv_t::from_fixed(val, strtable);
+    }
+    
+    template<typename STRTABLE>
+    static void unpack(variant_cv_t *target, value_type_code_t vt, const char *bytes, const STRTABLE *strtable) 
+    {
+        switch (vt) {
+            case value_types::Bit : {
+                int8 v = unpack_raw<int8>(bytes);
+                *target = (v != 0);
+                break;
+            }
+            //int
+            case value_types::Int8 : unpack_variant<int8>(target, bytes); break;
+            case value_types::Int16 : unpack_variant<int16>(target, bytes); break;
+            case value_types::Int32 : unpack_variant<int32>(target, bytes); break;
+            case value_types::Int64 : unpack_variant<int64>(target, bytes); break;
+            //uint
+            case value_types::Uint8 : unpack_variant<uint8>(target, bytes); break;
+            case value_types::Uint16 : unpack_variant<uint16>(target, bytes); break;
+            case value_types::Uint32 : unpack_variant<uint32>(target, bytes); break;
+            case value_types::Uint64 : unpack_variant<uint64>(target, bytes); break;
+            //float
+            case value_types::Float32 : unpack_variant<float32>(target, bytes); break;
+            case value_types::Float64 : unpack_variant<float64>(target, bytes); break;
+            
+            case value_types::Datetime : unpack_variant<datetime_t>(target, bytes); break;
+            case value_types::String : {
+                u_strtable_ref value;
+                Oinky::Serialization::unpack_nbc<v1_sformat_tag>(
+                    &value,
+                    bytes);
+                //  This will throw if the ref is invalid.
+                *target = strtable->from_untrusted_ref(value);
+                break;
+            }
+            default :
+                OINKY_ASSERT(false);
+                //  Not really an exception.  The column is invalid 
+                //  internally.  We should have detected this earlier.
+                throw_error(unknown_exception());
+        }
+    }
+};
+    
+namespace FixedDetail 
+{
+    //  The internal representation for a row is just the seriaized bytes.
+    class i_row_value_t
+    {
+    public:
+        const stringtable_t<u_strtable_ref> *strtable;
+        const char *row_base;
+        row_idx_t row_byte_count;
+        
+        template<typename TABULAR_T>
+        i_row_value_t(
+            const stringtable_t<u_strtable_ref> *_strtable,
+            const TABULAR_T &_tabular,
+            row_idx_t _offset) :
+        strtable(_strtable),
+            row_base(_tabular.rowdata_base + (_offset * _tabular.row_width_bytes)),
+            row_byte_count(_tabular.row_width_bytes)
+        {
+            OINKY_ASSERT(_offset < _tabular.row_count);
+        }
+
+    public:
+        //  Parameters are a column definition and a value
+        template<typename FN>
+        void each_column_value(const column_ctx *const* cols, uint32 count, FN fn) const
+        {
+            each_column_value_t<variant_cv_t>(cols, count, fn);
+        }
+
+        //  Parameters are a column definition and a value
+        template<typename FN>
+        void each_safe_value(const column_ctx *const* cols, uint32 count, FN fn) const
+        {
+            //  TBD
+            //  We always enumerate the complete set of column values.
+            //  This is because if we ever add a column, the table gets
+            //  exploded, and this code ceases to run.
+            each_column_value_t<safe_cv_t>(cols, count, fn);
+        }
+        
+        template<typename TARGET>
+        TARGET get_value(const column_ctx &cc) const 
+        {
+            TARGET val;
+            uint32 offset = cc.frow_byte_offset;
+            value_type_code_t vt;
+
+            //  If the column type code is variant, we need to unpack the value
+            //  type code first.
+            if (cc.type() == column_types::Variant) 
+            {
+                uint8 vt_byte;
+                Oinky::Serialization::unpack_nbc<v1_sformat_tag>(
+                    &vt_byte,
+                    row_base + offset);
+                    
+                if (!vt_byte || (vt_byte > OINKY_VALUE_TYPE_MAX)) {
+                    //  The fixed encoding is bad.
+                    //  TBD: unfortunately raising now might be confusing.
+                    throw_error(bad_encoding());
+                }
+                vt = (value_type_code_t) vt_byte;
+                offset += 1;
+            } else if (cc.type() == column_types::Bit) {
+                uint8 mask = 1 << cc.frow_bit_offset;
+                bool val = (row_base[offset] & mask) != 0;
+                return TARGET(val);
+            } else {
+                vt = (value_type_code_t) cc.type();
+            }
+                
+            //  This is an unsafe unpack (we do not bounds check the source buffer.
+            //  It's safe because we bounds-checked when we unpacked the table
+            //  itself, and computed/checked the column offsets.
+            i_stored_value::unpack(&val, vt, row_base + offset, strtable);
+            return val;
+        }
+
+
+        template<template<typename T> class CB, typename CTX>
+        bool dispatch_raw_value(const column_ctx &cc, CTX *ctx) const
+        {
+            const char *data = row_base + cc.frow_byte_offset;
+
+            switch (cc.ctype) {
+                case column_types::Bit : {
+                    uint8 mask = 1 << cc.frow_bit_offset;
+                    bool v = (*data & mask) != 0;
+                    return CB<bool>::call(cc, v,ctx);
+                }
+                //int
+                case column_types::Int8 :
+                    return CB<int8>::call(cc, i_stored_value::unpack_raw<int8>(data), ctx);
+                case column_types::Int16 :
+                    return CB<int16>::call(cc, i_stored_value::unpack_raw<int16>(data), ctx);
+                case column_types::Int32 :
+                    return CB<int32>::call(cc, i_stored_value::unpack_raw<int32>(data), ctx);
+                case column_types::Int64 :
+                    return CB<int64>::call(cc, i_stored_value::unpack_raw<int64>(data), ctx);
+                //uint
+                case column_types::Uint8 :
+                    return CB<uint8>::call(cc, i_stored_value::unpack_raw<uint8>(data), ctx);
+                case column_types::Uint16 :
+                    return CB<uint16>::call(cc, i_stored_value::unpack_raw<uint16>(data), ctx);
+                case column_types::Uint32 :
+                    return CB<uint32>::call(cc, i_stored_value::unpack_raw<uint32>(data), ctx);
+                case column_types::Uint64 :
+                    return CB<uint64>::call(cc, i_stored_value::unpack_raw<uint64>(data), ctx);
+                //float
+                case column_types::Float32 :
+                    return CB<float32>::call(cc, i_stored_value::unpack_raw<float32>(data), ctx);
+                case column_types::Float64 :
+                    return CB<float64>::call(cc, i_stored_value::unpack_raw<float64>(data), ctx);
+                    
+                case column_types::Datetime :
+                    return CB<datetime_t>::call(cc, i_stored_value::unpack_raw<datetime_t>(data), ctx);
+                case column_types::String : {
+                    safe_cv_t str(strtable->from_untrusted_ref(i_stored_value::unpack_raw<u_strtable_ref>(data)));
+                    return CB<safe_cv_t>::call(cc, str, ctx);
+                }
+                case column_types::Variant : {
+                    int8 vt_byte = i_stored_value::unpack_raw<int8>(data);
+                    value_type_code_t vt = (value_type_code_t) vt_byte;
+                    data += 1;
+                    switch (vt) {
+                        case column_types::Bit : {
+                            uint8 mask = 1 << cc.frow_bit_offset;
+                            bool v = (*data & mask) != 0;
+                            return CB<bool>::call(cc, v,ctx);
+                        }
+                        //int
+                        case column_types::Int8 :
+                            return CB<int8>::call(cc, i_stored_value::unpack_raw<int8>(data), ctx);
+                        case column_types::Int16 :
+                            return CB<int16>::call(cc, i_stored_value::unpack_raw<int16>(data), ctx);
+                        case column_types::Int32 :
+                            return CB<int32>::call(cc, i_stored_value::unpack_raw<int32>(data), ctx);
+                        case column_types::Int64 :
+                            return CB<int64>::call(cc, i_stored_value::unpack_raw<int64>(data), ctx);
+                        //uint
+                        case column_types::Uint8 :
+                            return CB<uint8>::call(cc, i_stored_value::unpack_raw<uint8>(data), ctx);
+                        case column_types::Uint16 :
+                            return CB<uint16>::call(cc, i_stored_value::unpack_raw<uint16>(data), ctx);
+                        case column_types::Uint32 :
+                            return CB<uint32>::call(cc, i_stored_value::unpack_raw<uint32>(data), ctx);
+                        case column_types::Uint64 :
+                            return CB<uint64>::call(cc, i_stored_value::unpack_raw<uint64>(data), ctx);
+                        //float
+                        case column_types::Float32 :
+                            return CB<float32>::call(cc, i_stored_value::unpack_raw<float32>(data), ctx);
+                        case column_types::Float64 :
+                            return CB<float64>::call(cc, i_stored_value::unpack_raw<float64>(data), ctx);
+
+                        case column_types::Datetime :
+                            return CB<datetime_t>::call(cc, i_stored_value::unpack_raw<datetime_t>(data), ctx);
+                        case column_types::String : {
+                            safe_cv_t str(strtable->from_untrusted_ref(i_stored_value::unpack_raw<u_strtable_ref>(data)));
+                            return CB<safe_cv_t>::call(cc, str, ctx);
+                        }
+                    }
+                    //  The fixed encoding is bad.
+                    //  TBD: unfortunately raising now might be confusing.
+                    throw_error(bad_encoding());
+                }
+            }
+            throw_error(implementation_bug());
+            return false;
+        }
+        
+    private:
+        template<typename TARGET, typename FN>
+        bool dispatch_column_value_t(const column_ctx &cc, FN fn) const
+        {
+            return fn(cc, get_value<TARGET>(cc));
+        }
+
+        //  Parameters are a column definition and a value
+        template<typename TARGET, typename FN>
+        void each_column_value_t(const column_ctx *const* cols, uint32 limit, FN fn) const
+        {
+            for (uint32 i = 0;i != limit;++i) {
+                const column_ctx &cc(*cols[i]);
+                if (!dispatch_column_value_t<TARGET>(cc, fn)) {
+                    return;
+                }
+            }
+        }
+    };
+}
+
+using namespace FixedDetail;
+
+//  Specialized row value extractor for index comparer
+template<>
+struct row_value_extractor<FixedDetail::i_row_value_t>
+{
+    typedef variant_cv_t ex_value_t;
+    
+    template<typename TBL>
+    static inline ex_value_t get_column_value(const i_row_value_t &row, const column_ctx &col, const TBL *tbl) {
+        OINKY_ASSERT(row.strtable == &tbl->db->userstrings);
+        return row.get_value<ex_value_t>(col);
+    }
+};
+
+struct tabular_t
+{
+    row_idx_t row_count;
+    uint32 row_width_bytes;
+    const char *rowdata_base;
+
+    tabular_t() :
+    row_count(0),
+        row_width_bytes(0),
+        rowdata_base(NULL)
+    {}
+
+    tabular_t(
+        row_idx_t _row_count,
+        uint32 _row_width_bytes,
+        const char *_rowdata_base) :
+    row_count(_row_count),
+        row_width_bytes(_row_width_bytes),
+        rowdata_base(_rowdata_base)
+    {}
+};
+
+template<typename TABLE_CTX>
+struct tabledata_fixed
+{
+    typedef TABLE_CTX table_ctx;
+    typedef tabledata_fixed<table_ctx> host_t;
+
+    tabular_t tabular;
+    const table_ctx *table;
+    
+    tabledata_fixed(const table_ctx *_table) : table(_table) {}
+    
+    tabledata_fixed(
+        const tabular_t &_tabular,
+        const table_ctx *_table
+        ) :
+    tabular(_tabular),
+        table(_table)
+    {}
+
+    class iterator : public boost::iterator_facade<
+        iterator,
+        row_idx_t,
+        boost::random_access_traversal_tag,
+        row_idx_t>
+    {
+        const table_ctx *table;
+        row_idx_t _position;
+        
+        row_idx_t dereference() const { 
+            return _position;
+        }
+        bool equal(const iterator &other) const { 
+            return _position == other._position; 
+        }
+        void increment() { ++_position; }
+        void decrement() { --_position; }
+        void advance(int x) { _position += x; }
+        int distance_to(const iterator &other) const { 
+            return (int) _position - (int) other._position; 
+        }
+
+        friend class boost::iterator_core_access;
+        
+    public:
+        iterator() : table(NULL), _position((row_idx_t) -1) {}
+        iterator(const table_ctx *_table, row_idx_t __position) : table(_table), _position(__position) {}
+        
+        bool is_deleted() const { 
+            return !table->fixed.rowkey_is_present(_position); 
+        }
+    };
+
+    bool rowkey_is_present(row_idx_t rowkey) const {
+        //  The key can be out of range even if the iterator is not.  The 
+        //  indexes (arrays of rowkeys) were serialized by an untrusted 
+        //  party, after all.
+        return (rowkey < tabular.row_count) && !table->is_deleted(rowkey);
+    }
+
+    inline iterator iterator_at(row_idx_t where) const { 
+        if (where > tabular.row_count) {
+            where = tabular.row_count;
+        }
+        return iterator(table,where);
+    }
+    
+    typedef column_selector_template<table_ctx> column_selector_t;
+    
+    struct accessor_base
+    {
+        column_selector_t cs;
+        row_idx_t rowkey;
+        const table_ctx *table;
+        
+        accessor_base(
+            const column_selector_t &_cs,
+            row_idx_t _rowkey,
+            const table_ctx *_table) :
+        cs(_cs),
+            rowkey(_rowkey),
+            table(_table)
+        {}
+        
+        uint32 column_count() const { return cs.column_count(); }
+
+        //  Parameters are a column definition and a value
+        template<typename FN>
+        void each_column_value(FN fn) const {
+            table->fixed.each_column_value(cs, rowkey, fn);
+        }
+    };
+    
+    iterator begin() const { return iterator_at((row_idx_t) 0); }
+    iterator end() const { return iterator_at(tabular.row_count); }
+    
+    iterator itr_at(uint64 where) const { 
+        if (where > (uint64) tabular.row_count) {
+            where = (uint64) tabular.row_count;
+        }
+        return iterator_at((row_idx_t) where); 
+    }
+    
+    typedef multicolumn_value_accessor<accessor_base> select_accessor;
+    
+    void check_key(row_idx_t rowkey) const {
+        //  They keys come from the serialized table.
+        if (rowkey >= tabular.row_count) {
+            //  It's not completely obvious at this level that it's a bad 
+            //  encoding.  The other option is an internal bug.
+            throw_error(bad_encoding());
+        }
+    }
+    
+    select_accessor select(const column_selector_t &_selector, row_idx_t rowkey) const {
+        check_key(rowkey);
+        return select_accessor(accessor_base(_selector, rowkey, table));
+    }
+
+    template<typename FN>
+    void each_safe_value(row_idx_t rowkey, FN fn) const {
+        check_key(rowkey);
+        i_row_value_t irv(
+            &table->db->userstrings,
+            table->fixed.tabular, 
+            rowkey);
+        irv.each_safe_value(table->cols_by_position.begin(), table->cols_by_position.size(), fn);
+    }
+    
+    //  Parameters are a column definition and a value
+    template<typename SELECTOR, typename FN>
+    void each_column_value(const SELECTOR &_selector, row_idx_t rowkey, FN fn) const {
+        check_key(rowkey);
+        
+        i_row_value_t irv(
+            &table->db->userstrings,
+            table->fixed.tabular, 
+            rowkey);
+
+        column_selector_accessor<SELECTOR> selector(_selector);
+        selector.check_valid(table);
+        
+        irv.each_column_value(selector.colrefs(), selector.colcount(), fn);
+    }
+
+    //  Parameters are a column definition and a value
+    template<template<typename T> class CB, typename CTX>
+    void each_raw_value(const column_ctx *const* cols_begin, const column_ctx *const* cols_end, row_idx_t rowkey, CTX *ctx) const {
+        check_key(rowkey);
+        i_row_value_t irv(
+            &table->db->userstrings,
+            table->fixed.tabular, 
+            rowkey);
+            
+        for (const column_ctx *const* i = cols_begin; i != cols_end; ++i) {
+            const column_ctx &col(**i);
+            if (!irv.dispatch_raw_value<CB>(col, ctx)) {
+                return;
+            }
+        }
+    }
+};
+
+template<typename TABLE_CTX> class index_ctx_t;
+
+template<typename TABLE_CTX>
+class indexdata_fixed
+{
+public:
+    typedef TABLE_CTX table_ctx;
+    typedef index_ctx_t<table_ctx> index_ctx;
+    typedef indexdata_fixed<table_ctx> host_t;
+    
+    tabular_t tabular;
+    
+    //  These are computed values which help us unpack row indices efficiently,
+    //  regardless of width and platform.
+    index_rowkey_xform keyxform;
+    
+    const table_ctx *table;
+    index_ctx *index;
+
+    typedef column_selector_template<table_ctx> column_selector_t;
+    
+public:
+    class iterator : public boost::iterator_facade<
+        iterator,
+        row_idx_t,
+        boost::random_access_traversal_tag,
+        row_idx_t>
+    {
+        index_ctx *idx;
+        column_selector_t cs;
+        const table_ctx *table;
+        host_t fixed;
+        row_idx_t _position;
+        
+        row_idx_t dereference() const { 
+            return fixed.keyxform.template unpack<v1_sformat_tag>(_position, fixed.tabular.rowdata_base);
+        }
+        bool equal(const iterator &other) const { 
+            return _position == other._position; 
+        }
+        void increment() { ++_position; }
+        void decrement() { --_position; }
+        void advance(int x) { _position += x; }
+        int distance_to(const iterator &other) const { 
+            return (int) _position - (int) other._position; 
+        }
+
+        friend class boost::iterator_core_access;
+        
+    public:
+        iterator() : idx(NULL), table(NULL), _position((row_idx_t) -1) {}
+        
+        iterator(index_ctx *_index, row_idx_t __position) : 
+        idx(_index), 
+            cs(_index->index_columns()), 
+            table(_index->table), 
+            fixed(_index->fixed),
+            _position(__position) 
+        {}
+
+        typedef typename tabledata_fixed<table_ctx>::select_accessor select_accessor;
+        
+        select_accessor indexed_values() const {
+            return table->fixed.select(cs, dereference());
+        }
+
+        const index_ctx *index() const { return idx; }
+
+        bool is_deleted() const { 
+            row_idx_t rowkey = dereference();
+            return !table->fixed.rowkey_is_present(rowkey);
+        }
+    };
+
+private:
+    inline iterator iterator_at(row_idx_t where) const { 
+        OINKY_ASSERT(where <= tabular.row_count);
+        return iterator(index, where);
+    }
+
+public:
+    iterator begin() const { return iterator_at((row_idx_t) 0); }
+    iterator end() const { return iterator_at(tabular.row_count); }
+
+    indexdata_fixed() : table(NULL) {}
+
+    indexdata_fixed(
+        const tabular_t &_tabular,
+        const table_ctx *_table,
+        index_ctx *_index
+        ) :
+    tabular(_tabular),
+        keyxform(_tabular.row_count),
+        table(_table),
+        index(_index)
+    {
+        OINKY_ASSERT((tabular.row_count == 0) || (tabular.row_width_bytes == keyxform.dr_width));
+        OINKY_ASSERT(!tabular.row_count || (tabular.row_count == table->fixed.tabular.row_count));
+    }
+    
+private:
+    typedef index_row_compare_t<index_ctx, i_row_value_t> index_row_compare;
+    
+    struct key_compare
+    {
+        const table_ctx *table;
+        const host_t *indextab;
+        column_selector_t cs;
+        
+        key_compare(
+            const table_ctx *_table,
+            const host_t *_indextab, 
+            const column_selector_t &_cs) : 
+        table(_table),
+            indextab(_indextab),
+            cs(_cs)
+        {}
+
+        template<typename ITR_T>
+        int compare(row_idx_t lkey, const simple_sequence<ITR_T> &right) const {
+            i_row_value_t irv(
+                &table->db->userstrings,
+                table->fixed.tabular, 
+                lkey);
+            return index_row_compare(indextab->index).compare(irv, right);
+        }
+    
+        template<typename ITR_T>
+        bool operator()(row_idx_t lkey, const simple_sequence<ITR_T> &right) const {
+            return compare(lkey, right) < 0;
+        }
+        template<typename ITR_T>
+        bool operator()(const simple_sequence<ITR_T> &left, row_idx_t rkey) const {
+            return compare(rkey, left) > 0;
+        }
+    };
+
+public:    
+    //  These iterators are over the column values of the row we are searching for.
+    template<typename ROW_T>
+    iterator lower_bound(const ROW_T &row) const
+    {
+        key_compare compare(table, this, index->index_columns());
+        return std::lower_bound(begin(), end(), row, compare);
+    }
+    template<typename ROW_T>
+    iterator upper_bound(const ROW_T &row) const
+    {
+        //  See lower_bound for comments
+        key_compare compare(table, this, index->index_columns());
+        return std::upper_bound(begin(), end(), row, compare);
+    }
+    template<typename ROW_T>
+    iterator find(const ROW_T &row) const
+    {
+        //  Find lower bound.
+        iterator i(lower_bound(row));
+        if (i == end()) {
+            return i;
+        }
+        //  If the row spec is below itr, then we've found upper_bound == lower_bound.
+        key_compare compare(table, this, index->index_columns());
+        if (compare(row, *i)) {
+            return end();
+        }
+        return i;
+    }
+};
+
+} //namespace Internal
+} //namespace Oinky
+