oinky 0.1.0

data/ext/include/oinky/nky_public.hpp

@@ -0,0 +1,808 @@
+//  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
+{
+using namespace Oinky::Errors;
+
+//  Simulate an enum-class.
+namespace value_types
+{
+    //
+    //  Simplified set of SQL value types.  int/date/string
+    //
+    enum value_type_code_t
+    {
+        //  These are always sorted as integers.
+        Bit = 1,
+        Int8 = 2,
+        Int16 = 3,
+        Int32 = 4,
+        Int64 = 5,
+        Datetime = 6,
+        //  strings are always lexically sorted unsigned bytes.  They are stored
+        //  in the string table, not in the table itself.
+        String = 7,
+        //  more inline types
+        Uint8 = 8,
+        Uint16 = 9,
+        Uint32 = 10,
+        Uint64 = 11,
+        Float32 = 12,
+        Float64 = 13,
+    };
+} //namespace value_types
+
+#define OINKY_VALUE_TYPE_MAX    13
+
+namespace column_types
+{
+    //
+    //  This is a superset of the value_type.  It additionally defines the 
+    //  Variant type.
+    //
+    //  A value must specify a type, but a column (family of values) need not.
+    //  Variant column-type indicates that each row specifies its own type.
+    enum column_type_code_t
+    {
+        Variant = 0,
+        
+        //  The rest are identical to value_type_code
+        Bit = 1,
+        Int8 = 2,
+        Int16 = 3,
+        Int32 = 4,
+        Int64 = 5,
+        Datetime = 6,
+        String = 7,
+        //  more inline types
+        Uint8 = 8,
+        Uint16 = 9,
+        Uint32 = 10,
+        Uint64 = 11,
+        Float32 = 12,
+        Float64 = 13,
+    };
+} //namespace column_types
+
+typedef value_types::value_type_code_t value_type_code_t;
+typedef column_types::column_type_code_t column_type_code_t;
+
+struct datetime_t
+{
+    //  All times are stored in UTC format.
+    //
+    //  map of bits.  Y-(year-1900). M-(month-1). D-(day-1). h-hour, m-minute, s-second, u-microsecond
+    //  YYYY-YYYY-YYYY-YYYY-YYMM-MMDD-DDDh-hhhh-
+    //  mmmm-mmss-ssss-uuuu-uuuu-uuuu-uuuu-uuuu
+    //  
+    enum __constants {
+        yearshift = 46,
+        monthshift = 42,
+        dayshift = 37,
+        hourshift = 32,
+        minuteshift = 26,
+        secondshift = 20,
+        usecshift = 0
+    };
+    //  Each of the above fields stores more values than are required.  Thus, the
+    //  representation is sparse.  We can't really do equality 
+    //  testing without adding a lot of date logic and assumptions about
+    //  calendars.  Was there a year 0, etc?  Was the year a leap-year?
+    //  were there leap-seconds.
+    //
+    //  The above storage is absolute in nature as opposed to relative for that 
+    //  reason.  Errors (in computation of leap-years/seconds) do not accrue.
+    //  We do not store the number of days since january 1 1900.  We store the 
+    //  number of years, then months, then days, then hours, etc.
+    //
+    //  In general, getting consistent representations of all dates still 
+    //  requires consistent datetime implementations, but with this scheme, even 
+    //  different datetime packages will produce results that are close.
+    //
+    int64 _val;
+    
+    int32 years_since_1900() const { return _val >> yearshift; }
+    uint16 months_since_january() const { return (_val >> monthshift) & 0xf; }
+    uint8 days_since_first_of_month() const { return (_val >> dayshift) & 0x1f; }
+    uint8 hours_since_midnight() const { return (_val >> hourshift) & 0x1f; }
+    uint8 minutes_since_hour() const { return (_val >> minuteshift) & 0x3f; }
+    uint8 seconds_since_minute() const { return (_val >> secondshift) & 0x3f; }
+    uint32 microseconds_since_second() const { return (_val >> usecshift) & 0xfffff; }
+    
+    uint32 seconds_since_midnight() const { 
+        return (3600 * hours_since_midnight()) +
+            (60 * minutes_since_hour()) +
+            seconds_since_minute();
+    }
+    uint64 microseconds_since_midnight() const { 
+        return (1000000ull * seconds_since_midnight()) + 
+            microseconds_since_second();
+    }
+    
+    //  NOTE:  See above about sparseness of representation.  Thus, we are not 
+    //  comparing dates.  We are comparing representations of dates.  When these
+    //  representations are ordered, and then coverted into real dates, the
+    //  resulting dates may no longer be identically ordered.
+    bool operator<(const datetime_t &other) const { return _val < other._val; }
+    bool operator<=(const datetime_t &other) const { return _val <= other._val; }
+    bool operator==(const datetime_t &other) const { return _val == other._val; }
+    bool operator!=(const datetime_t &other) const { return _val != other._val; }
+    bool operator>(const datetime_t &other) const { return _val > other._val; }
+    bool operator>=(const datetime_t &other) const { return _val >= other._val; }
+    
+    datetime_t() : _val(0) {}
+    
+    static datetime_t compose(
+        int years_since_1900, 
+        uint8 months_since_january, 
+        uint8 days_since_first_of_month, 
+        uint8 hours_since_midnight = 0,
+        uint8 minutes_since_hour = 0,
+        uint8 seconds_since_minute = 0,
+        uint32 microseconds_since_second = 0)
+    {
+        //  This still permits some odd dates.  We can't be perfect without 
+        //  knowing everything about leap-years and even leap-seconds, and 
+        //  the leap-seconds throws some things in about is the max hours
+        //  23 or 24, seconds 59 or 60, etc.
+        //
+        //  So why do this test at all if we can't do it right?  Because we want
+        //  to ensure that we don't have bit overflows between fields.  That's
+        //  much worse than having a funky date that is still *valid*.
+        if ((months_since_january > 11) ||
+            (days_since_first_of_month > 31) ||
+            (hours_since_midnight > 24) ||
+            (minutes_since_hour > 63) ||
+            (seconds_since_minute > 63)) 
+        {
+            throw_error(invalid_argument());
+        }
+    
+        datetime_t dt;
+        dt._val = 
+            (((int64) years_since_1900) << yearshift) +
+            (((int64) months_since_january) << monthshift) +
+            (((int64) days_since_first_of_month) << dayshift) +
+            (((int64) hours_since_midnight) << hourshift) +
+            (((int64) minutes_since_hour) << minuteshift) +
+            (((int64) seconds_since_minute) << secondshift) +
+            (((int64) microseconds_since_second) << usecshift);
+        return dt;
+    }
+        
+    static datetime_t now() {
+        boost::posix_time::ptime dt = boost::posix_time::microsec_clock::universal_time();
+        return from_boost_ptime(dt);
+    }
+    
+    static datetime_t from_boost_ptime(boost::posix_time::ptime dt) {
+        struct tm tmval = boost::posix_time::to_tm(dt);
+        
+        //  This interface seems very silly to me.
+        boost::posix_time::time_duration duration( dt.time_of_day() );
+        uint64 usec = duration.total_microseconds();
+        
+        enum _const_vals {
+            seconds = 1000000,
+            minutes = 60 * seconds
+        };
+        return compose(
+            (int) tmval.tm_year, 
+            tmval.tm_mon, 
+            tmval.tm_mday - 1, 
+            usec / (60ull * minutes), 
+            (usec % (60ull * minutes)) / minutes, 
+            (usec % minutes) / seconds,
+            usec % seconds);
+    }
+
+    boost::posix_time::ptime to_boost_ptime() const {
+        boost::posix_time::ptime base(boost::gregorian::date(1900 * years_since_1900(), boost::date_time::Jan + months_since_january(), 1 + days_since_first_of_month()));
+        base += boost::posix_time::microseconds(microseconds_since_midnight());
+        return base;
+    }
+};
+
+BOOST_STATIC_ASSERT(sizeof(datetime_t) == 8);
+
+namespace Internal
+{
+
+//  Forward declare this for friendship.
+template<class REF_T> class stringtable_t;
+template<typename REF_T> class u_string_value_safe;
+class safe_cv_t;
+
+}
+
+//  This describes a string.  The lifetime of the string is equivalent to that
+//  of the database.  If the database is destroyed or remounted, the string
+//  becomes invalid.  The memory backing it may be deallocated or rewritten.
+//
+//  All string-sharing with the user is via this type, whether for column-values
+//  or metastrings.
+//
+//  When the used passes this object to a method, it is the caller's 
+//  responsibility to ensure the bytes remain valid until the method returns.
+class db_string
+{
+    const char *bytes;
+    uint32 _length;
+    //  Note this is agnostic to the table.  It could refer to the string
+    //  table or metatable.  We never trust it.
+    uint32 xref;
+    
+    template<typename REF_T> friend class ::Oinky::Internal::u_string_value_safe;
+    template<typename REF_T> friend class ::Oinky::Internal::stringtable_t;
+    friend class ::Oinky::Internal::safe_cv_t;
+    
+public:
+
+    uint32 length() const { return _length; }
+    const char *begin() const { return bytes; }
+    const char *end() const { return bytes + _length; }
+    
+    db_string() : bytes(NULL), _length(0), xref(0) {}
+    db_string(const char *str) : bytes(str), _length(strlen(str)), xref(0) {}
+    db_string(const char *str, uint32 __length) : bytes(str), _length(__length), xref(0) {}
+
+    //  Metastrings must not contain NULLs.  Other than that, all characters
+    //  are supported as table/column/index names in sqlite if they are 
+    //  properly bracketed, so we follow the same pattern.
+    //
+    //  The following is valid in sqlite:
+    //    "select * from [This should-be a_valid.table+name!?]" 
+    bool validate_metastring() const {
+        return strnlen(bytes, _length) == _length;
+    }
+
+    //  We can't safely use the xref value to compare strings, because we don't
+    //  know where it came from.  The two strings could be from distinct
+    //  database instances.
+    int compare_to(const db_string &other) const {
+        //  Must use memcmp not strncmp.  Remember these are arbitrary indirect 
+        //  byte strings, not null-terminated c-strings.
+        int k;
+        if (_length < other._length) {
+            k = memcmp(bytes, other.bytes, _length);
+            if (k == 0) return -1;
+        } else if (_length > other._length) {
+            k = memcmp(bytes, other.bytes, other._length);
+            if (k == 0) return 1;
+        } else {
+            k = memcmp(bytes, other.bytes, _length);
+        }
+        if (k < 0) return -1;
+        if (k > 0) return 1;
+        return 0;
+    }
+
+    template<typename T>
+    inline int compare_to(const T &other) const {
+        return -other.compare_to(*this);
+    }
+    
+    template<typename T>
+    bool operator==(const T &other) const { return compare_to(other) == 0; }
+    template<typename T>
+    bool operator!=(const T &other) const { return compare_to(other) != 0; }
+    template<typename T>
+    bool operator<(const T &other) const { return compare_to(other) < 0; }
+    template<typename T>
+    bool operator<=(const T &other) const { return compare_to(other) <= 0; }
+    template<typename T>
+    bool operator>(const T &other) const { return compare_to(other) > 0; }
+    template<typename T>
+    bool operator>=(const T &other) const { return compare_to(other) >= 0; }
+};
+
+namespace Internal
+{
+    //  This is the public variant column value type.  It represents the column
+    //  value according to its internal encoding.
+    class column_value_payload
+    {
+        enum value_payload_size_ec { 
+            value_payload_size = MAX(sizeof(db_string), MAX(sizeof(uint64),sizeof(datetime_t)))
+        };
+        char bytes[value_payload_size];
+        BOOST_STATIC_ASSERT(value_payload_size >= sizeof(db_string));
+        BOOST_STATIC_ASSERT(value_payload_size >= sizeof(uint64));
+        BOOST_STATIC_ASSERT(value_payload_size >= sizeof(datetime_t));
+
+    public:
+        column_value_payload() {}
+        
+        column_value_payload(bool x) {
+            bit_value() = x;
+        }
+        column_value_payload(int64 x) {
+            int_value() = x;
+        }
+        column_value_payload(uint64 x) {
+            uint_value() = x;
+        }
+        column_value_payload(float32 x) {
+            f32_value() = x;
+        }
+        column_value_payload(float64 x) {
+            f64_value() = x;
+        }
+        column_value_payload(const db_string &x) {
+            string_value() = x;
+        }
+        column_value_payload(const datetime_t &x) {
+            dt_value() = x;
+        }
+        
+        column_value_payload &operator=(const column_value_payload &x) {
+            if (this == &x) return *this;
+            memcpy(bytes, x.bytes, value_payload_size);
+            return *this;
+        }
+        
+        template<typename T> 
+        column_value_payload &operator=(const T &x) {
+            if (this == (const column_value_payload *) &x) return *this;
+            //  If there isn't a constructor for this, then it
+            //  can't be assigned.
+            *this = column_value_payload(x);
+            return *this;
+        }
+
+        bool &bit_value() { return *(bool *)bytes; }
+        bool bit_value() const { return *(const bool *)bytes; }
+
+        db_string &string_value() { return *(db_string *)bytes; }
+        const db_string &string_value() const { return *(const db_string *)bytes; }
+
+        int64 &int_value() { return *(int64 *)bytes; }
+        const int64 &int_value() const { return *(const int64 *)bytes; }
+
+        uint64 &uint_value() { return *(uint64 *)bytes; }
+        const uint64 &uint_value() const { return *(const uint64 *)bytes; }
+
+        float64 &f64_value() { return *(float64 *)bytes; }
+        const float64 &f64_value() const { return *(const float64 *)bytes; }
+
+        float32 &f32_value() { return *(float32 *)bytes; }
+        const float32 &f32_value() const { return *(const float32 *)bytes; }
+
+        datetime_t &dt_value() { return *(datetime_t *)bytes; }
+        const datetime_t &dt_value() const { return *(const datetime_t *)bytes; }
+
+        int compare_to(value_type_code_t type, const column_value_payload &right) const
+        {
+            switch (type) {
+                //  These are always sorted as integers.
+                case value_types::Bit :
+                    if (bit_value() && !right.bit_value()) return 1;
+                    if (!bit_value() && right.bit_value()) return -1;
+                    return 0;
+                case value_types::Int8 :
+                case value_types::Int16 :
+                case value_types::Int32 :
+                case value_types::Int64 :
+                    if (int_value() < right.int_value()) return -1;
+                    if (int_value() == right.int_value()) return 0;
+                    return 1;
+                case value_types::Uint8 :
+                case value_types::Uint16 :
+                case value_types::Uint32 :
+                case value_types::Uint64 :
+                    if (uint_value() < right.uint_value()) return -1;
+                    if (uint_value() == right.uint_value()) return 0;
+                    return 1;
+                case value_types::Float32 :
+                    if (f32_value() < right.f32_value()) return -1;
+                    if (f32_value() == right.f32_value()) return 0;
+                    return 1;
+                case value_types::Float64 :
+                    if (f64_value() < right.f64_value()) return -1;
+                    if (f64_value() == right.f64_value()) return 0;
+                    return 1;
+                case value_types::Datetime :
+                    if (dt_value() < right.dt_value()) return -1;
+                    if (dt_value() == right.dt_value()) return 0;
+                    return 1;
+                case value_types::String :
+                    return string_value().compare_to(right.string_value());
+            }
+            throw_error(bad_encoding());
+            //please the compiler.
+            return 0;
+        }
+    };
+}
+
+//  This is a user-visible column value type.  It's not quite what we store
+//  internally, since internally we know the value-type from the column
+//  definition.
+class variant_cv_t : public with_compare_ops<variant_cv_t>
+{
+    value_type_code_t _type;
+    Internal::column_value_payload _value;
+    
+public:
+    variant_cv_t() : _type(value_types::Int8), _value((int64)0) {}
+
+    variant_cv_t(int64 v) : _type(value_types::Int64), _value((int64)v) {}
+    variant_cv_t(int32 v) : _type(value_types::Int32), _value((int64)v) {}
+    variant_cv_t(int16 v) : _type(value_types::Int16), _value((int64)v) {}
+    variant_cv_t(int8 v) : _type(value_types::Int8), _value((int64)v) {}
+    variant_cv_t(uint64 v) : _type(value_types::Uint64), _value((uint64)v) {}
+    variant_cv_t(uint32 v) : _type(value_types::Uint32), _value((uint64)v) {}
+    variant_cv_t(uint16 v) : _type(value_types::Uint16), _value((uint64)v) {}
+    variant_cv_t(uint8 v) : _type(value_types::Uint8), _value((uint64)v) {}
+    variant_cv_t(float64 v) : _type(value_types::Float64), _value(v) {}
+    variant_cv_t(float32 v) : _type(value_types::Float32), _value(v) {}
+    variant_cv_t(bool v) : _type(value_types::Bit), _value(v) {}
+    variant_cv_t(const db_string &s) : _type(value_types::String), _value(s) {}
+    variant_cv_t(const char *s) : _type(value_types::String), _value(db_string(s)) {}
+    variant_cv_t(const datetime_t &dt) : _type(value_types::Datetime), _value(dt) {}
+
+    template<typename T>
+    variant_cv_t& operator=(const T &v) {
+        if (this != (const variant_cv_t *)&v) { 
+            *this = variant_cv_t(v);
+        }
+        return *this;
+    }
+
+    value_type_code_t type() const { return _type; }
+
+    bool is_bit() const { return _type == value_types::Bit; }
+    bool is_int() const { return _type >= value_types::Int8 && _type <= value_types::Int64; }
+    bool is_uint() const { return _type >= value_types::Uint8 && _type <= value_types::Uint64; }
+    bool is_date() const { return _type == value_types::Datetime; }
+    bool is_f32() const { return _type == value_types::Float32; }
+    bool is_f64() const { return _type == value_types::Float64; }
+    bool is_string() const { return _type == value_types::String; }
+    
+    bool &bit_value() { return _value.bit_value(); }
+    bool bit_value() const { return _value.bit_value(); }
+    
+    db_string &string_value() { return _value.string_value(); }
+    const db_string &string_value() const { return _value.string_value(); }
+    
+    datetime_t &dt_value() { return _value.dt_value(); }
+    const datetime_t &dt_value() const { return _value.dt_value(); }
+    
+    int64 &int_value() { return _value.int_value(); }
+    const int64 &int_value() const { return _value.int_value(); }
+
+    uint64 &uint_value() { return _value.uint_value(); }
+    const uint64 &uint_value() const { return _value.uint_value(); }
+
+    float64 &f64_value() { return _value.f64_value(); }
+    const float64 &f64_value() const { return _value.f64_value(); }
+
+    float32 &f32_value() { return _value.f32_value(); }
+    const float32 &f32_value() const { return _value.f32_value(); }
+
+    //  This is a safer way to dispatch.  It guarantees that no possibilities
+    //  are excluded...that the switch is complete.
+    template<template<typename T> class FN, typename CTX>
+    void dispatch(CTX ctx) const
+    {
+        switch (_type) {
+            case value_types::Bit :
+                FN<bool>::call(bit_value(), ctx);
+                return;
+            //  These are always sorted as integers.
+            case value_types::Int8 :
+                FN<int8>::call((int8) int_value(), ctx);
+                return;
+            case value_types::Int16 :
+                FN<int16>::call((int16) int_value(), ctx);
+                return;
+            case value_types::Int32 :
+                FN<int32>::call((int32) int_value(), ctx);
+                return;
+            case value_types::Int64 :
+                FN<int64>::call(int_value(), ctx);
+                return;
+            //  These are always sorted as unsigned integers.
+            case value_types::Uint8 :
+                FN<uint8>::call((uint8) uint_value(), ctx);
+                return;
+            case value_types::Uint16 :
+                FN<uint16>::call((uint16) uint_value(), ctx);
+                return;
+            case value_types::Uint32 :
+                FN<uint32>::call((uint32) uint_value(), ctx);
+                return;
+            case value_types::Uint64 :
+                FN<uint64>::call(uint_value(), ctx);
+                return;
+
+            //  floating point
+            case value_types::Float32 :
+                FN<float32>::call(f32_value(), ctx);
+                return;
+            case value_types::Float64 :
+                FN<float64>::call(f64_value(), ctx);
+                return;
+                
+            case value_types::Datetime :
+                FN<datetime_t>::call(dt_value(), ctx);
+                return;
+            case value_types::String :
+                FN<db_string>::call(string_value(), ctx);
+                return;
+        }
+        throw_error(bad_encoding());
+    }
+    
+    int compare_to(const variant_cv_t &other) const
+    {
+        //  most common
+        if (_type == other._type) {
+            return _value.compare_to(_type, other._value);
+        } else if (is_int()) {
+            //  They're all stored full-width 64-bit internally, and would 
+            //  have been truncated to size when they were stored, if smaller.
+            if (other.is_int()) {
+                return _value.compare_to(value_types::Int64, other._value);
+            }
+            if (other.is_uint()) {
+                if (int_value() < 0) return -1;
+                return _value.compare_to(value_types::Uint64, other._value);
+            }
+        } else if (is_uint()) {
+            if (other.is_uint()) {
+                return _value.compare_to(value_types::Uint64, other._value);
+            }
+            if (other.is_int()) {
+                if (other.int_value() < 0) return 1;
+                return _value.compare_to(value_types::Uint64, other._value);
+            }
+        } else if (is_f32()) {
+            if (other.is_f64()) {
+                float64 l = f32_value();
+                float64 r = other.f64_value();
+                if (l < r) {
+                    return -1;
+                }
+                if (l == r) {
+                    return 0;
+                }
+                return 1;
+            }
+        } else if (is_f64()) {
+            if (other.is_f32()) {
+                float64 l = f64_value();
+                float64 r = other.f32_value();
+                if (l < r) {
+                    return -1;
+                }
+                if (l == r) {
+                    return 0;
+                }
+                return 1;
+            }
+        }
+         
+        //  Types are not comparable.
+        throw_error(incomparable_value_types());
+        return 0;
+    }
+
+private:
+    template<typename INT, value_type_code_t vt>
+    inline void coerce_int()
+    {
+        if (!(is_int() || is_uint())) {
+            throw_error(column_type_mismatch());
+        }
+        _value.int_value() = (INT) _value.int_value();
+        _type = vt;
+    }
+    
+    inline void check_throw_type(value_type_code_t vt)
+    {
+        if (_type != vt) {
+            throw_error(column_type_mismatch());
+        }
+    }
+public:    
+    //  Alters internal value/type to comply with the specified column_type.
+    //  If this is an integer, it may truncate/cast.  If it's an incompatible
+    //  type, it may throw column_type_mismatch().  If the column_type is
+    //  variant, it will no-op.
+    void coerce(column_type_code_t ct) {
+        switch (ct) {
+            case column_types::Variant : return;
+
+            case column_types::Int8 : 
+                coerce_int<int8, value_types::Int8>(); return;
+            case column_types::Int16 : 
+                coerce_int<int16, value_types::Int16>(); return;
+            case column_types::Int32 : 
+                coerce_int<int32, value_types::Int32>(); return;
+            case column_types::Int64 : 
+                coerce_int<int64, value_types::Int64>(); return;
+
+            case column_types::Uint8 : 
+                coerce_int<uint8, value_types::Uint8>(); return;
+            case column_types::Uint16 : 
+                coerce_int<uint16, value_types::Uint16>(); return;
+            case column_types::Uint32 : 
+                coerce_int<uint32, value_types::Uint32>(); return;
+            case column_types::Uint64 : 
+                coerce_int<uint64, value_types::Uint64>(); return;
+
+            //
+            case column_types::Float32 : 
+                if (is_f32()) {
+                    return;
+                }
+                if (is_f64()) {
+                    f32_value() = (float32) _value.f64_value();
+                    _type = value_types::Float32;
+                    return;
+                }
+                throw_error(column_type_mismatch());
+            case column_types::Float64 : 
+                if (is_f64()) {
+                    return;
+                }
+                if (is_f32()) {
+                    f64_value() = (float64) _value.f32_value();
+                    _type = value_types::Float64;
+                    return;
+                }
+                throw_error(column_type_mismatch());
+
+            case column_types::Datetime : 
+                //  Just type-check.  No values to change.
+                check_throw_type(value_types::Datetime);
+                return;
+            case column_types::String : 
+                check_throw_type(value_types::String);
+                return;
+            case column_types::Bit : 
+                check_throw_type(value_types::Bit);
+                return;
+        }
+        throw_error(bad_encoding());
+    }
+    
+    template<typename VALUE>
+    struct formatter
+    {
+        template<typename OSTREAM>
+        static void call(const VALUE &v, OSTREAM *os) {
+            (*os) << v;
+        }
+    };
+};
+
+//  These are the user-visible definition structures.
+struct table_column_def
+{
+    db_string column_name;
+    //  This may exactly specify the value_type for each row (and default_value)
+    //  or it may make no restriction at all (ct == column_types::Variant).
+    column_type_code_t column_type;
+    //  Obviously the default value must conform to the column_type.
+    variant_cv_t default_value;
+    
+    table_column_def() {}
+    
+    table_column_def(
+        db_string _cn,
+        column_type_code_t _ct,
+        variant_cv_t _dv) :
+    column_name(_cn),
+        column_type(_ct),
+        default_value(_dv)
+    {
+        //  This will throw if the default_value and column_type are inconsistent.
+        default_value.coerce(column_type);
+    }
+};
+
+//  This specifier is used when defining an index.
+struct index_column_def
+{
+    db_string column_name;
+    bool sort_ascending;
+};
+
+//  The columns of an existing index can be enumerated to produce these.
+//  Unlike the above, these index columns are already bound to columns in
+//  the target table.
+/*
+struct index_column_handle
+{
+    index_column_spec spec;
+    table_column_handle column;
+    
+    index_column_def(
+        index_column_spec _spec,
+        const table_column_def &_column) :
+    spec(_spec),
+        column(_column)
+    {}
+};*/
+
+//
+//  This describes the lifespan of an object, relative to the savepoint history.
+//  When creating or deleting an object, we simply set the according insert/
+//  delete stamp to the latest savepoint marker.  When rolling back to a 
+//  savepoint, we scan all objects in the database and delete those which were
+//  created after the target value, and recreate those which were created
+//  before and deleted after.
+//
+//  Objects which pre-date the mounting of the DB have an insert_sp of 0, 
+//  meaning that no SP rollback will ever uncreate them.
+//
+//  Obviously, the savepoints are not persistent.  The SP marker resets to 
+//  zero each time the DB is deserialized.
+//
+//  FAQ: Aren't savepoints an esoteric feature?  Why implement them?
+//  The familiar mechanism of exception handling in DB systems is the 
+//  transaction. However, transactions can be expensive because they do too 
+//  much.  Transactions are also a synchronization mechanism, among other 
+//  things.  Our system is designed to be externally synchronized by the 
+//  user.  Possibly by a mutex, and possibly by nothing at all, depending
+//  on the application.  But, we still need a mechanism for compositional 
+//  exception handling.  Savepoints are like transactions without the 
+//  feature of synchronization.  They are composable and efficient.  Complex
+//  operations can be wrapped in a cascading sequence of savepoints.  
+//
+struct sp_marker_t
+{
+    uint32 val;
+    sp_marker_t() : val(0) {}
+    sp_marker_t(uint32 _val) : val(_val) {}
+    
+    void increment() { val++; }
+    
+    template<typename T> inline bool operator==(const T &other) const { return other == val; }
+    template<typename T> inline bool operator!=(const T &other) const { return other != val; }
+    template<typename T> inline bool operator<(const T &other) const { return other > val; }
+    template<typename T> inline bool operator<=(const T &other) const { return other >= val; }
+    template<typename T> inline bool operator>(const T &other) const { return other < val; }
+    template<typename T> inline bool operator>=(const T &other) const { return other <= val; }
+};
+
+enum index_uniqueness_spec_t
+{
+    Unique = 1,
+    NonUnique = 2
+};
+
+} //namespace Oinky
+
+
+namespace std
+{
+
+template<class _Traits> 
+inline std::basic_ostream<char, _Traits>& 
+operator<<(
+    std::basic_ostream<char, _Traits> &os, 
+    const Oinky::db_string &str
+    )
+{
+    return os.write(str.begin(), str.length());
+}
+
+template<class _Traits> 
+inline std::basic_ostream<char, _Traits>& 
+operator<<(
+    std::basic_ostream<char, _Traits> &os, 
+    const Oinky::variant_cv_t &cv
+    )
+{
+    cv.dispatch<Oinky::variant_cv_t::formatter>(&os);
+    return os;
+}
+
+}//namespace std
+