oinky 0.1.0

data/ext/include/oinky/nky_serializer.hpp

@@ -0,0 +1,1625 @@
+//  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;
+using namespace Oinky::Internal;
+
+namespace Serialization
+{
+
+//  NOTE:  THIS IS OUT OF DATE, but it gives you the gist of it.
+//
+//  <DB encoding string - 12 bytes> "\x0coinky-0.1.0"
+//  <DB length>
+//  <m_stringtable>
+//      uint32 byte_count; (including the byte_count itself)
+//      uint32 item_count;
+//      uint32 offsets[item_count];
+//      <bytes> strings </>
+//  /m_stringtable>
+//  <u_stringtable>
+//      uint32 byte_count;
+//      uint32 item_count;
+//      uint32 offsets[item_count];
+//      <bytes> strings </>
+//  /u_stringtable>
+//  <tableset
+//      <uint32 - total byte length of tableset>
+//      <uint32 - table count>
+//      <vector of m_strtable_references -- length==table_count>
+//      <vector of uint32 offsets (of beginning of each table.  Offsets are from beginning
+//          of tableset) -- length==table_count>
+//      <table0  (name inherited from set header vector)
+//          <row_idx_t - row_count == the table and all indexes have the same number of rows
+//          <uint32 - row0_offset (offset of serialized rowdata, from beginningof <table
+//          <colset
+//              uint8 - column_count
+//              vector of column_def structures, which are fixed-length:
+//                  [m_strtable_ref columnname,
+//                   uint8 coltype,
+//                   default_value (this is padded up to 8 bytes(maximum value size))]
+//          /colset>
+//          <indexset
+//              <uint32 - total byte length of indexset>
+//              <uint8 index_count
+//              <indexdef
+//                  m_strtable_ref indexname
+//                  uint32 - offset of tabledata, from beginning of <indexset>
+//                  uint8 col_count
+//                  bool unique
+//                  vector of struct {
+//                      uint8 col_ref (reference into table's colset)
+//                      bool ascending
+//                  }
+//              <index0 data
+//                  array of row_idx_t references into table. length=table.row_count
+//              /data>
+//              <index1 data>
+//          /indexset>
+//          <table data>
+//      /table>
+//      <table1>
+//      ...
+//  /tableset>
+
+namespace V1Defs
+{
+#pragma pack(push,1)
+//  We use machine-native serialization for these structures.
+class s_table_hdr
+{
+    struct layout_t {
+        m_strtable_ref tblname; 
+        uint32 offset;
+    } s_value;
+    
+public:    
+    typedef layout_t unpacked_t;
+
+    unpacked_t unpack() const 
+    {
+        unpacked_t u;
+        unpack_nbc<v1_sformat_tag, m_strtable_ref>(&u.tblname, (const char *)&s_value.tblname);
+        unpack_nbc<v1_sformat_tag, uint32>(&u.offset, (const char *)&s_value.offset);
+        return u;
+    }
+
+    static void pack(m_strtable_ref tblname, uint32 offset, char *&write_cursor, const char *end_buf)
+    {
+        //  Check length.
+        if (write_cursor + sizeof(layout_t) > end_buf) {
+            throw_error(buffer_overflow());
+        }
+        pack_nbc<v1_sformat_tag, m_strtable_ref>(tblname, write_cursor);
+        write_cursor += sizeof(m_strtable_ref);
+        pack_nbc<v1_sformat_tag, uint32>(offset, write_cursor);
+        write_cursor += 4;
+    }
+};
+BOOST_STATIC_ASSERT(sizeof(s_table_hdr) == 8);
+
+class s_column_def
+{
+    struct layout_t {
+        m_strtable_ref colname;
+        uint8 ctype;
+        uint8 vtype;
+        char default_value_bytes[8];
+    } s_value;
+    
+public:
+    typedef layout_t unpacked_t;
+
+    unpacked_t unpack() const 
+    {
+        unpacked_t u = s_value;
+        //  Only this requires further processing.
+        unpack_nbc<v1_sformat_tag, m_strtable_ref>(&u.colname, (const char *)&s_value.colname);
+        return u;
+    }
+
+    template<typename DB>
+    static void pack(const column_ctx &col, const DB *db, char *&write_cursor, const char *end_buf)
+    {
+        //  Check length.
+        if (write_cursor + sizeof(layout_t) > end_buf) {
+            throw_error(buffer_overflow());
+        }
+        pack_nbc<v1_sformat_tag, m_strtable_ref>(db->metastrings.xform_ref(col.colname), write_cursor);
+        write_cursor += sizeof(m_strtable_ref);
+        pack_nbc<v1_sformat_tag, uint8>((uint8) col.ctype, write_cursor);
+        write_cursor += 1;
+        pack_nbc<v1_sformat_tag, uint8>((uint8) col.default_value.type(), write_cursor);
+        write_cursor += 1;
+        i_stored_value::pack_variant(col.default_value, write_cursor, db->userstrings);
+        write_cursor += 8;
+    }
+};
+BOOST_STATIC_ASSERT(sizeof(char) == 1);
+BOOST_STATIC_ASSERT(sizeof(uint8) == 1);
+BOOST_STATIC_ASSERT(sizeof(m_strtable_ref)==4);
+BOOST_STATIC_ASSERT(sizeof(s_column_def) == sizeof(m_strtable_ref) + 10);
+
+#pragma pack(pop)
+} //namespace V1Defs
+using namespace Oinky::Serialization::V1Defs;
+
+//  The scheme identifies itself.
+template<> 
+class Serializer<v1_sformat_tag, v1_sformat_tag>
+{
+    static const char *string() {
+        return "\x0coinky-0.1.1";
+    }
+public:
+    static uint32 virtual_pack()
+    {   
+        return strlen(string());
+    }
+    
+    static void pack(char *&buffer_start, const char *buffer_end)
+    {
+        uint32 l = virtual_pack();
+        if (buffer_end - buffer_start < l) {
+            throw_error(buffer_overflow());
+        }
+        memcpy(buffer_start, string(), l);
+        buffer_start += l;
+    }
+    
+    static void unpack(const char *buffer, uint32 buflen, uint32 last_end, uint32 &this_end)
+    {
+        if (!Serialization::check_bytes(string(), virtual_pack(), buffer, buflen, last_end, this_end)) {
+            throw_error(version_mismatch());
+        }
+    }
+};
+//  The scheme identifies itself.
+struct v1_trailer {};
+template<> 
+class Serializer<v1_trailer, v1_sformat_tag>
+{
+    static const char *string() {
+        return "oink";
+    }
+public:
+    static uint32 virtual_pack() {   
+        return strlen(string());
+    }
+    
+    static void pack(char *&buffer_start, const char *buffer_end)
+    {
+        uint32 l = virtual_pack();
+        if (buffer_end - buffer_start < l) {
+            throw_error(buffer_overflow());
+        }
+        memcpy(buffer_start, string(), l);
+        buffer_start += l;
+    }
+    
+    static void unpack(const char *buffer, uint32 buflen, uint32 last_end, uint32 &this_end)
+    {
+        if (!Serialization::check_bytes(string(), virtual_pack(), buffer, buflen, last_end, this_end)) {
+            throw_error(version_mismatch());
+        }
+    }
+};
+
+template<typename ALLOCATOR>
+class Serializer<db_handle_internal_t<ALLOCATOR>, v1_sformat_tag>
+{
+    typedef v1_sformat_tag scheme;
+    typedef db_handle_internal_t<ALLOCATOR> db_handle_internal;
+    typedef typename db_handle_internal::table_ctx table_ctx;
+    typedef typename table_ctx::index_ctx index_ctx;
+    typedef typename index_ctx::idx_column_iterator idx_column_iterator;
+
+//#############################################################################
+//##
+//##    DESERIALIZE
+//##
+//#############################################################################
+
+    template<typename s_value, typename CTX_TRAITS, typename MAP_FN>
+    static void unpack_set(context_map_t<CTX_TRAITS> *map, const MAP_FN &mapfn, const char *buffer, uint32 buflen, uint32 last_end, uint32 &this_end)
+    {
+        typedef typename CTX_TRAITS::index_t index_t;
+        typedef typename CTX_TRAITS::context_t context_t;
+        index_t count;
+        Serialization::unpack<scheme>(&count, buffer, buflen, this_end, this_end);
+        
+        if (((uint32) count > buflen - this_end) ||
+            (((uint32) count) * sizeof(s_value) > buflen - this_end)) 
+        {
+            //  This is not a buffer underflow.  That can happen only at the
+            //  top-level.  The size of this table was itself encoded, so if
+            //  it's wrong, that counts as a bad encoding.
+            throw_error(bad_encoding());
+        }
+        const s_value *s_cols = (const s_value *)(buffer + this_end);
+        this_end += count * sizeof(s_value);
+        //  TBD: Something like the column contexts could just be used in their
+        //  serialized form.  There's no need to allocate new contexts and
+        //  extract them, but this is a bit simpler (static and dynamic
+        //  contexts can be treated the same.)  This is slightly less efficient
+        //  (since we have another allocation for every table.  Also, the 
+        //  table structures will rarely be modified relative to the number of
+        //  times the DB is mounted in its lifetime, so it's the last thing that
+        //  should be optimized for speed.  For now, this is optimized for simplicity.
+        
+        map->f_contexts.resize(count);
+        map->_live_count = count;
+
+        const s_value *sc = s_cols;
+        context_t *ctx = map->f_contexts.begin();
+        for (index_t i=(index_t)0;i<count;++i, ++ctx, ++sc) {
+            mapfn(i, ctx, sc);
+        };
+    }
+
+    static void unpack_col_ctx(row_offset_accumulator_t *row_width, column_idx_t i, column_ctx *colctx, const s_column_def *s_coldef, table_ctx *table)
+    {
+        const s_column_def::unpacked_t sc(s_coldef->unpack());
+        
+        colctx->colname = table->db->metastrings.from_untrusted_ref(sc.colname);
+        colctx->ctype = (column_type_code_t) sc.ctype;
+        //colctx->position = i;
+        
+        //  Check the column type.
+        if (sc.ctype > OINKY_VALUE_TYPE_MAX) {
+            throw_error(bad_encoding());
+        }
+        
+        //  Determine where these column values are stored in the fixed row.
+        if (colctx->ctype == column_types::Bit) {
+            //  we use new_bit_offset as the temporary because it can hold the 
+            //  larger value that frow_bit_offset.
+            colctx->new_bit_offset = row_width->bit_count;
+            row_width->bit_count += 1;
+        } else {
+            colctx->frow_byte_offset = row_width->byte_offset;
+            //  This will throw if the column_type is invalid
+            row_width->byte_offset += compute_serialized_width(colctx->ctype);
+        }
+        
+        //  Now determine where to store the column values in any pending
+        //  rows we may create.
+        table->allocate_pending_column_data(colctx);
+        
+        //  Check the value type.  A value cannot be variant.
+        if ((sc.vtype < (uint8) value_types::Bit) || (sc.vtype > OINKY_VALUE_TYPE_MAX)) {
+            throw_error(bad_encoding());
+        }
+        //  Unpack the default value.
+        i_stored_value::unpack(&colctx->default_value, (value_type_code_t) sc.vtype, sc.default_value_bytes, &table->db->userstrings);
+    }
+
+    static void unpack_index_ctx(table_ctx *table, index_ctx *idx, index_idx_t _index_idx, const char *buffer, uint32 buflen, uint32 last_end, uint32 &this_end)
+    {
+        idx->reinit_serial(table, _index_idx);
+        
+        //  How many columns in this index.
+        m_strtable_ref idxnameref;
+        uint32 rowdata_offset;
+        column_idx_t col_count;
+        bool require_unique;
+        
+        this_end = last_end;
+        
+        Serialization::unpack<scheme>(&idxnameref, buffer, buflen, this_end, this_end);
+        Serialization::unpack<scheme>(&rowdata_offset, buffer, buflen, this_end, this_end);
+        Serialization::unpack<scheme>(&col_count, buffer, buflen, this_end, this_end);
+        Serialization::unpack<scheme>(&require_unique, buffer, buflen, this_end, this_end);
+        
+        idx->indexname = table->db->metastrings.from_untrusted_ref(idxnameref);
+        
+        //  Extract the index column definition data.
+        uint32 remainder = buflen - this_end;
+        uint32 ascending_bytes = (col_count + 7) >> 3;
+        if ((col_count * sizeof(column_idx_t)) + ascending_bytes > remainder) {
+            throw_error(bad_encoding());
+        }
+
+        idx->defn.col_count = col_count;
+        const column_idx_t *column_idx_refs = (const column_idx_t *) (buffer + this_end);
+        this_end += col_count * sizeof(column_idx_t);
+        idx->defn.cols_ascending = (const uint8 *) (buffer + this_end);
+        this_end += ascending_bytes;
+        idx->defn.require_unique = require_unique;
+
+        //  Convert the index refs into column_ctx * refs.
+        {
+            idx->__definition_data.resize(sizeof(column_ctx *) * idx->defn.col_count);
+            const column_ctx **cols = (const column_ctx **) idx->__definition_data.begin();
+            idx->column_refs = cols;
+            for (uint32 i=0;i<(uint32) idx->defn.col_count;++i) {
+                column_idx_t val;
+                unpack_nbc<scheme,column_idx_t>(&val, (const char *)(column_idx_refs + i));
+                //  Bounds check the column reference.
+                if ((uint32) val >= table->cols_by_position.size()) {
+                    throw_error(bad_encoding());
+                }
+                cols[i] = table->cols_by_position[val];
+            }
+        }
+        
+        //  An index does not shadow the data itself.  It merely provides an 
+        //  alternate ordering.  Each row of an index is simply the row-id.
+        uint32 row_count = table->fixed.tabular.row_count;
+        index_rowkey_xform keyxform((row_idx_t) table->fixed.tabular.row_count);
+        uint32 row_width = keyxform.dr_width;
+
+        //  Check that we have space for the offset list.
+        if ((rowdata_offset < this_end) || 
+            (rowdata_offset > buflen) ||
+            (row_count > buflen) ||
+            ((uint64) row_count * row_width > buflen - rowdata_offset)) 
+        {
+            throw_error(bad_encoding());
+        }
+        
+#if 0 
+//We do this in the fixed-index iterator itself.  We don't need to do it here too.
+        //  Check that none of the offsets exceeds the table size.
+        const row_idx_t *indexlist = (const row_idx_t *) (buffer + rowdata_offset);
+        if (array_exceeds_max_31(indexlist, row_count, (row_idx_t) (row_count - 1))) {
+            throw_error(bad_encoding());
+        }
+#endif
+        
+        //  Extract the column value data.
+        typedef typename index_ctx::fixed_t tf_t;
+        idx->fixed = tf_t(
+            tabular_t( 
+                (row_idx_t) row_count,
+                row_width,
+                buffer + rowdata_offset), 
+            table,
+            idx);
+
+        //  Check that all referenced columns are of indexable type.  If they
+        //  are not (are of variant type) then this is a bad encoding.
+        idx_column_iterator i = idx->coldefs_begin();
+        idx_column_iterator end = idx->coldefs_end();
+        for (;i != end; ++i) {
+            if (i->column->ctype == column_types::Variant) {
+                throw_error(bad_encoding());
+            }
+        }
+
+        //  We do not advance this_end past the index data.  We were only asked
+        //  to unpack the context.  The contexts are packed together.
+    }
+    
+    //  This uses int32s to test, meaning it can only test an upper limit up
+    //  to 2^31-1.
+    template<typename INT_TYPE>
+    static bool array_exceeds_max_31(const INT_TYPE *array, uint32 count, INT_TYPE max) {
+        BOOST_STATIC_ASSERT(sizeof(INT_TYPE) <= sizeof(uint32));
+        if ((uint32) max >= (uint32) (1 << 31)) {
+            throw_error(invalid_argument());
+        }
+        const INT_TYPE *i = array;
+        const INT_TYPE *end = i + count;
+        int32 a = 0;
+        int32 maxrow = (int32) max;
+        for (;i != end; ++i) {
+            //  This should be a free conversion.  Casting to familiar integer
+            //  types makes this clearer.
+            uint32 off = (uint32) *i;
+            //  We only care if the high bit ever gets set.
+            a |= maxrow - off;
+        }
+        //  If the high bit is set, then at least one element exceeded max.
+        return a < 0;
+    }
+    
+    static void unpack_index_set(table_ctx *table, const char *buffer, uint32 buflen, uint32 last_end, uint32 &this_end)
+    {
+        this_end = last_end;
+        index_idx_t count;
+        Serialization::unpack<scheme>(&count, buffer, buflen, this_end, this_end);
+        
+        //  Unpack each index context.
+        table->indexes.f_contexts.resize(count);
+        table->indexes._live_count = count;
+
+        index_ctx *ic = table->indexes.f_contexts.begin();
+        for (index_idx_t i = (index_idx_t)0;i<count;++i, ++ic) {
+            unpack_index_ctx(table, ic, i, buffer, buflen, this_end, this_end);
+        }
+        
+        table->indexes_by_position.assign_sequential(
+            table->indexes.f_contexts.begin(),
+            table->indexes.f_contexts.end());
+    }
+        
+    static void unpack_table(
+        uint32 __tbl_idx,       //ignored.  tables never referenced by position.
+        table_ctx *table, 
+        const s_table_hdr *s_hdr_data,
+        db_handle_internal *db, 
+        const char *buffer,     // Points to the beginning of the tableset.
+        uint32 buflen           //  Size of the tableset
+        )
+    {
+        const s_table_hdr::unpacked_t hdr_data(s_hdr_data->unpack());
+        
+        //  Clean slate.
+        table->reinit(db);
+        //  Get the table name
+        table->tablename = db->metastrings.from_untrusted_ref(hdr_data.tblname);
+
+        //  Move the beginning of this table spec.
+        if (hdr_data.offset >= buflen) {
+            throw_error(bad_encoding());
+        }
+        uint32 this_end = hdr_data.offset;
+        
+        row_idx_t row_count;
+        uint32 rowdata_offset;
+        Serialization::unpack<scheme>(&row_count, buffer, buflen, this_end, this_end);
+        Serialization::unpack<scheme>(&rowdata_offset, buffer, buflen, this_end, this_end);
+
+        //  Get the column data
+        row_offset_accumulator_t row_width;
+        unpack_set<s_column_def>(
+            &table->columns, 
+            boost::bind(&unpack_col_ctx, &row_width, _1, _2, _3, table), 
+            buffer, 
+            buflen,
+            this_end,
+            this_end);
+
+        //  Initialize the positional map.
+        uint32 column_count = table->columns.f_contexts.size();
+        table->cols_by_position.resize(column_count);
+        column_ctx **target_col_ptr = table->cols_by_position.begin();
+        column_ctx **end_col_ptr = table->cols_by_position.end();
+        
+        for(column_ctx *col = table->columns.f_contexts.begin();
+            target_col_ptr != end_col_ptr;
+            ++col, ++target_col_ptr) 
+        {
+            *target_col_ptr = col;
+            
+            //  Also update the bit/offset information if this is a bit column,
+            //  now that we know the row length.
+            if (col->ctype == column_types::Bit) {
+                col->frow_byte_offset = row_width.byte_offset + (col->new_bit_offset >> 3);
+                col->frow_bit_offset = col->new_bit_offset & 7;
+            }
+        }
+
+        //  Compute the actual row width, including bit columns.
+        uint32 serialized_row_width = row_width.full_width();
+            
+        //  Now the indexes.  Unlike the column set, the index set is framed.
+        //  Unpack the index set framing info first.
+        uint32 index_set_bytes;
+        Serialization::unpack<scheme>(&index_set_bytes, buffer, buflen, this_end, this_end);
+        uint32 ixsetbase = this_end - 4;
+        if (ixsetbase + index_set_bytes > buflen) {
+            throw_error(bad_encoding());
+        }
+        
+        //  Now unpack the row data (since we need to initialize the table's
+        //  fixed object prior to unpacking the indexes.
+        //
+        //  The serialized row width has been computed above.
+        
+        //  Extract the column value data.
+        if ((rowdata_offset < this_end) || 
+            (rowdata_offset > buflen) ||
+            ((uint64) row_count * serialized_row_width > buflen - rowdata_offset)) 
+        {
+            throw_error(bad_encoding());
+        }
+        
+        //  The rows get deserialized lazily.  We just save a pointer to them.
+        typedef typename table_ctx::fixed_t tf_t;
+        table->fixed = tf_t(
+            tabular_t( 
+                (row_idx_t) row_count,
+                serialized_row_width,
+                buffer + rowdata_offset), 
+            table);
+
+        //  Any new rows should have sequence numbers beginning beyond those
+        //  reserved for the fixed rows.
+        table->insert_sequence_limit = (uint64) row_count;
+
+        //  Now we can unpack the index set.
+        //  Start at 4 bytes, since we already read the byte_count value.
+        uint32 ixtmp = 4;
+        unpack_index_set(
+            table,
+            buffer + ixsetbase,
+            index_set_bytes,
+            ixtmp,
+            ixtmp);
+
+        //  Now advance the pointer beyond the frame, regardless of how much the
+        //  ixtmp reports consuming.  Note this is an assert not an exception.
+        //  Even malicious encoding should not be able to provoke this.
+        OINKY_ASSERT(ixtmp <= index_set_bytes);
+    }
+    
+    template<typename REF_T>
+    static void unpack_stringtable(
+        ALLOCATOR *allocator,
+        stringtable_t<REF_T> *target, 
+        const char *buffer, 
+        uint32 buflen, 
+        uint32 last_end,
+        uint32 &this_end) 
+    {
+        uint32 byte_count, string_count;
+        //
+        this_end = last_end;
+        Serialization::unpack<scheme>(&byte_count, buffer, buflen, this_end, this_end);
+        Serialization::unpack<scheme>(&string_count, buffer, buflen, this_end, this_end);
+        //
+        if (byte_count > buflen - last_end) {
+            throw_error(buffer_underflow());
+        }
+        //  Test that we have space for the arrays.
+        if ((string_count > buflen) ||
+            (string_count * 4 > buflen - this_end)) {
+            throw_error(bad_encoding());
+        }
+        //  These are not necessarily yet valid uint32s.  We haven't byte
+        //  reversed them yet (if necessary).  That happens lazily in 
+        //  stringtable_t::from_trusted_ref.
+        const uint32 *offsets = (const uint32 *)(buffer + this_end);
+        this_end += string_count * 4;
+#if 0        
+        //  TBD:  The following is a very fast validation.  It takes a few 
+        //  microseconds even for thousands of strings.  However, if we need
+        //  to byte-swap, it's worse.  So we just do it lazily in 
+        //  stringtable_t::from_trusted_ref
+        const uint32 *i = offsets;
+        const uint32 *end = offsets + string_count;
+        uint32 max = byte_count;
+        uint32 min = this_end - last_end;
+        uint32 a = 0;
+        for (;i != end;++i) {
+            uint32 off = *i;
+            a |= off - min;
+            min = off;
+        }
+        //  If any offset is greater than its subsequent offset.
+        if (a & (1<<31)) {
+            throw_error(bad_encoding());
+        }
+        //  If the final is greater than the size of the table.
+        if (min > byte_count) {
+            throw_error(bad_encoding());
+        }
+#endif        
+        //  Assign.
+        target->reinit(allocator, string_count, offsets, byte_count, buffer + last_end);
+        //  Complete
+        this_end = last_end + byte_count;
+    }
+
+    static void unpack_tableset(
+        typename db_handle_internal::tables_t *target, 
+        db_handle_internal *db, 
+        const char *buffer, 
+        uint32 buflen, 
+        uint32 last_end,
+        uint32 &this_end) 
+    {
+        uint32 byte_count;
+        //
+        Serialization::unpack<scheme>(&byte_count, buffer, buflen, last_end, this_end);
+        //
+        if (byte_count > buflen - last_end) {
+            throw_error(buffer_underflow());
+        }
+        //  For frame size.
+        uint32 tbstmp = 4;
+        unpack_set<s_table_hdr>(
+            &db->tables, 
+            boost::bind(&unpack_table, _1, _2, _3, db, buffer + last_end, byte_count), 
+            buffer + last_end, 
+            byte_count,
+            tbstmp,
+            tbstmp);
+
+        //  Complete
+        this_end = last_end + byte_count;
+    }
+public:
+    
+    static void mount(db_handle_internal *target, const char *buffer, uint32 buflen) {
+        //  Clean start.
+        target->reset();
+        
+        try {
+            uint32 this_end = 0;
+            
+            //  Check the encoding.
+            //  This will throw if the scheme is wrong.
+            Serializer<scheme,scheme>::unpack(buffer, buflen, this_end, this_end);
+
+            //  Get the length (including the encoding string).
+            uint32 total_length;
+            Serialization::unpack<scheme>(&total_length, buffer, buflen, this_end, this_end);
+            if (total_length > buflen) {
+                throw_error(buffer_underflow());
+            }
+            //  Unpack the meta-string table.
+            //
+            //  The relational tables depend on the metastring table for their
+            //  table/column/index names, and on the userstring table for the 
+            //  default-column-value definitions.
+            unpack_stringtable(&target->allocator, &target->metastrings, buffer, buflen, this_end, this_end);
+            //  Unpack the user-string table.
+            unpack_stringtable(&target->allocator, &target->userstrings, buffer, buflen, this_end, this_end);
+            //  Unpack the relational tables.
+            unpack_tableset(&target->tables, target, buffer, buflen, this_end, this_end);
+        } catch (...) {
+            //  Clean exit.
+            target->reset();
+            throw;
+        }
+    }
+
+//#############################################################################
+//##
+//##    SERIALIZE
+//##
+//#############################################################################
+    typedef typename table_ctx::cols_positional_itr_t cols_itr_t;
+
+    static uint32 prepare_pack_index_hdr(index_ctx *index)
+    {
+        //  Mark the index name.
+        index->table->db->metastrings.mark(index->indexname);
+        //  The size of the index definition.
+        uint32 bytes = 0;
+        bytes += Serializer<m_strtable_ref,scheme>::virtual_pack();//index->idxname
+        bytes += Serializer<uint32,scheme>::virtual_pack();//rowdata_offset
+        bytes += Serializer<column_idx_t,scheme>::virtual_pack(index->defn.col_count);
+        bytes += Serializer<bool,scheme>::virtual_pack(index->defn.require_unique);
+        bytes += sizeof(column_idx_t) * index->defn.col_count;
+        //  A bit per column to record sort-order.
+        uint32 ascending_bytes = (index->defn.col_count + 7) >> 3;
+        bytes += ascending_bytes;
+        return bytes;
+    }
+    static uint32 prepare_pack_index_data(index_ctx *index)
+    {
+        //  The size of the index definition.  The index name has already
+        //  been accounted for by the context_t serializer.
+        index_rowkey_xform keyxform((row_idx_t) index->table->row_count());
+        return index->table->row_count() * keyxform.dr_width;
+    }
+    static void complete_pack_index(
+        index_ctx *index, 
+        char *&hcursor,
+        char *idxset_base, 
+        const char *end_buf,
+        uint32 *last_data_offset,
+        const row_idx_t *remap_vector)
+    {
+        //###############
+        //  Write the index definition.
+        Serializer<m_strtable_ref,scheme>::pack(index->table->db->metastrings.xform_ref(index->indexname), hcursor, end_buf);
+        Serializer<uint32,scheme>::pack(*last_data_offset, hcursor, end_buf);
+        Serializer<column_idx_t,scheme>::pack(index->defn.col_count, hcursor, end_buf);
+        Serializer<bool,scheme>::pack(index->defn.require_unique, hcursor, end_buf);
+        idx_column_iterator coldefs_end = index->coldefs_end();
+        for (idx_column_iterator i = index->coldefs_begin(); i != coldefs_end; ++i) {
+            //  The new position may be different from the temporary position
+            //  we've been using internally.
+            Serializer<column_idx_t,scheme>::pack(
+                i->column->new_position, 
+                hcursor, 
+                end_buf);
+        }
+        
+        //  Pack the directional bits
+        uint32 ascending_bytes = (index->defn.col_count + 7) >> 3;
+        char *ascending_bytes_target = hcursor;
+        memset(ascending_bytes_target, 0, ascending_bytes);
+        uint32 pos = 0;
+        for (idx_column_iterator i = index->coldefs_begin(); i != coldefs_end; ++i, ++pos) {
+            //  The new position may be different from the temporary position
+            //  we've been using internally.
+            if (i->ascending) {
+                ascending_bytes_target[pos >> 3] |= 1 << (pos & 7);
+            }
+        }
+        hcursor += ascending_bytes;
+        
+        //###############
+        //  Rowdata.
+        char *rowrefcursor = idxset_base + *last_data_offset;
+        uint32 rowcount = index->table->row_count();
+        index_rowkey_xform keyxform((row_idx_t) rowcount);
+        uint32 index_data_bytes = rowcount * keyxform.dr_width;
+        if (rowrefcursor + index_data_bytes > end_buf) {
+            throw_error(buffer_overflow());
+        }
+
+        struct keyfn {
+            static inline row_idx_t newkey(typename index_ctx::iterator ri, const row_idx_t *remap_vector) {
+                if (ri.fixed_active()) {
+                    OINKY_ASSERT(!ri.pending_active());
+                    row_idx_t oldkey = *ri.fixed();
+                    return remap_vector ? remap_vector[oldkey] : oldkey;
+                } else {
+                    OINKY_ASSERT(ri.pending_active());
+                    return ri.pending().to_row()->new_rowkey;
+                }
+            }
+        };
+
+        typename index_ctx::iterator ri = index->begin();
+        typename index_ctx::iterator re = index->end();
+        
+        //  We will do this in two passes.  The first will be destructive to 
+        //  bits beyond those written by the cursor.  At the end of the array,
+        //  of course, we need to be careful not to overwrite anything, so
+        //  we'll zero the bits we care about and or-in the last few values.
+        uint32 i = 4;
+        for (;i < rowcount; ++ri, ++i) {
+            row_idx_t newkey = keyfn::newkey(ri, remap_vector);
+            keyxform.pack_nbc_destructive<scheme>(rowrefcursor, newkey);
+            rowrefcursor += keyxform.dr_width;
+        }
+        i -= 4;
+        //  Now zero the remainder of the target bytes.
+        if (i < rowcount) {
+            memset(rowrefcursor, 0, (rowcount - i) * keyxform.dr_width);
+            for (;ri != re; ++ri) {
+                row_idx_t newkey = keyfn::newkey(ri, remap_vector);
+                keyxform.pack_nbc_orbits<scheme>(rowrefcursor, newkey);
+                rowrefcursor += keyxform.dr_width;
+            }
+        }
+        OINKY_ASSERT(rowrefcursor == 
+            idxset_base + *last_data_offset + index_data_bytes);
+
+        //  Remember the data cursor position.
+        *last_data_offset = rowrefcursor - idxset_base;
+    }
+    
+    static uint32 prepare_pack_column(column_ctx *col, column_idx_t *new_column_idx, row_offset_accumulator_t *row_width, db_handle_internal *db)
+    {
+        //  If the default value is a string, then mark it.
+        if (col->default_value.is_string()) {
+            db->userstrings.mark(col->default_value);
+        }
+        
+        //  Assign new column position.
+        col->new_position = *new_column_idx;
+        *new_column_idx += 1;
+        //  Compute data-width.
+        if (col->ctype == column_types::Bit) {
+            col->new_bit_offset = row_width->bit_count;
+            row_width->bit_count += 1;
+        } else {
+            col->new_row_offset_bytes = row_width->byte_offset;
+            row_width->byte_offset += compute_serialized_width(col->ctype);
+        }
+        //  The column object contains no payload.  The header is the definition.
+        //  The definition is already accounted for.  0 bytes for payload.
+        return 0;
+    }
+    
+    static void complete_pack_column(
+        const column_ctx *col, 
+        char *&write_cursor, 
+        db_handle_internal *db,
+        const char *end_buf)
+    {
+        s_column_def::pack(*col, db, write_cursor, end_buf);
+    }
+    
+    static uint32 prepare_pack_table(table_ctx *table, db_handle_internal *db)
+    {
+        uint32 bytes = 0;
+        
+        if (must_remap_fixedkeys(table) && 
+            (db->packing.max_fixed_table_remap_size < (uint32) table->fixed.tabular.row_count)) 
+        {
+            db->packing.max_fixed_table_remap_size = (uint32) table->fixed.tabular.row_count;
+        }
+        
+        bytes += Serializer<row_idx_t, scheme>::virtual_pack();   //row_count
+        bytes += Serializer<uint32, scheme>::virtual_pack();   //rowdata_offset
+
+        //  Get the column data
+        column_idx_t new_column_position = (column_idx_t) 0;
+        table->packing.row_width = row_offset_accumulator_t();
+        
+        bytes += prepare_pack_set<s_column_def>(
+            table->columns, 
+            boost::bind(&prepare_pack_column, _1, &new_column_position, &table->packing.row_width, db));
+
+        //  Compute the actual row width, including bit columns.
+        uint32 serialized_row_width = table->packing.row_width.full_width();
+        
+        //  Now iterate all the bit columns and reset their location.
+        cols_itr_t ci = table->cols_by_position.begin();
+        cols_itr_t endcols = table->cols_by_position.end();
+        for (;ci != endcols;++ci) {
+            column_ctx *col(*ci);
+            if (col->ctype == column_types::Bit) {
+                col->new_row_offset_bytes = table->packing.row_width.byte_offset + (col->new_bit_offset >> 3);
+                col->new_bit_offset &= 7;
+            }
+        }
+                    
+        //#########
+        //  Index set header.
+        uint32 ixsetbytes = 0;
+        ixsetbytes += Serializer<uint32, scheme>::virtual_pack();     //index_set_bytes
+        uint32 ixhdrbytes = sizeof(index_idx_t); //index count
+        
+        //  Each index
+        typedef typename table_ctx::indexes_t::by_name_iterator ibni;
+        ibni ic = table->indexes.by_name().begin();
+        ibni iend = table->indexes.by_name().end();
+        for (;ic != iend; ++ic) {
+            ixhdrbytes += prepare_pack_index_hdr(*ic);
+            ixsetbytes += prepare_pack_index_data(*ic);
+        }
+        table->indexes.computed_packed_header_bytes = ixhdrbytes;
+        ixsetbytes += ixhdrbytes;
+        
+        table->packing.indexset_size = ixsetbytes;
+        bytes += ixsetbytes;
+
+        //#########
+        //  Row Data
+        
+        //  Call pack with PREPARE=true to compute byte count and mark
+        //  all strings prior to packing.
+        table->packing.rowdata_bytes = pack_row_data<true>(table, NULL, NULL);
+        bytes += table->packing.rowdata_bytes;
+        
+        table->packing.total_size = bytes;
+        return bytes;
+    }
+    
+    static bool must_remap_fixedkeys(const table_ctx *table) {
+        return table->pending_deletes.size() && 
+            (table->fixed_dropped_sp == 0) && 
+            (table->pending_deletes.size() != (uint32) table->fixed.tabular.row_count);
+    }
+    
+    //
+    //  There are basically two types of columns.  Direct and indirect values.
+    //  For each row, we process the one type then the other.
+    //
+    struct consolidated_frow_strings
+    {
+        uint32 src_offset;
+        uint32 target_offset;
+    };
+    struct consolidated_frow_bytes : consolidated_frow_strings
+    {
+        uint32 width;
+    };
+    struct consolidated_frow_bits : consolidated_frow_strings
+    {
+        uint8 src_mask;
+        int8 rshift;
+    };
+
+    template<typename T>
+    struct prepare_pack_cb {
+        inline static bool call(const column_ctx &ctx, bool value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, datetime_t value, user_stringtable_t *strtable) { return true; }
+
+        inline static bool call(const column_ctx &ctx, int8 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, int16 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, int32 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, int64 value, user_stringtable_t *strtable) { return true; }
+
+        inline static bool call(const column_ctx &ctx, uint8 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, uint16 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, uint32 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, uint64 value, user_stringtable_t *strtable) { return true; }
+
+        inline static bool call(const column_ctx &ctx, float32 value, user_stringtable_t *strtable) { return true; }
+        inline static bool call(const column_ctx &ctx, float64 value, user_stringtable_t *strtable) { return true; }
+
+        //  Only the variants and strings get called with safe_cv_t values.
+        inline static bool call(const column_ctx &ctx, const safe_cv_t &value, user_stringtable_t *strtable) {
+            OINKY_ASSERT((ctx.ctype == column_types::Variant) || (ctx.ctype == column_types::String));
+            if (value.is_string()) {
+                strtable->mark(value);
+            }
+            return true;
+        }
+    };
+    
+    struct complete_pack_cb_ctx
+    {
+        char *rowbase;
+        user_stringtable_t *strtable;
+        
+        complete_pack_cb_ctx(
+            char *_rowbase,
+            user_stringtable_t *_strtable) :
+        rowbase(_rowbase),
+            strtable(_strtable)
+        {}
+    };
+    
+    template<typename T>
+    struct complete_pack_cb {
+#define OINKY_DEFINE_COMPLETE_PACK_CB(TYPE)     \
+        inline static bool call(const column_ctx &cc, TYPE value, const complete_pack_cb_ctx *ctx) {    \
+            BOOST_STATIC_ASSERT((boost::is_same<TYPE, T>::value));                                      \
+            Serializer<TYPE, scheme>::pack_nbc(value, ctx->rowbase + cc.new_row_offset_bytes);          \
+            return true;                                                                                \
+        }
+        OINKY_DEFINE_COMPLETE_PACK_CB(int8)
+        OINKY_DEFINE_COMPLETE_PACK_CB(int16)
+        OINKY_DEFINE_COMPLETE_PACK_CB(int32)
+        OINKY_DEFINE_COMPLETE_PACK_CB(int64)
+
+        OINKY_DEFINE_COMPLETE_PACK_CB(uint8)
+        OINKY_DEFINE_COMPLETE_PACK_CB(uint16)
+        OINKY_DEFINE_COMPLETE_PACK_CB(uint32)
+        OINKY_DEFINE_COMPLETE_PACK_CB(uint64)
+
+        OINKY_DEFINE_COMPLETE_PACK_CB(float32)
+        OINKY_DEFINE_COMPLETE_PACK_CB(float64)
+
+        OINKY_DEFINE_COMPLETE_PACK_CB(datetime_t)
+#undef OINKY_DEFINE_COMPLETE_PACK_CB
+        
+        //  Only the variants and strings get called with safe_cv_t values.
+        inline static bool call(const column_ctx &cc, bool value, const complete_pack_cb_ctx *ctx) {
+            OINKY_ASSERT(cc.ctype == column_types::Bit);
+            if (value) {
+                uint8 mask = 1 << cc.new_bit_offset;
+                ctx->rowbase[cc.new_row_offset_bytes] |= mask;
+            }
+            return true;
+        }
+        //  Only the variants and strings get called with safe_cv_t values.
+        inline static bool call(const column_ctx &cc, const safe_cv_t &cv, const complete_pack_cb_ctx *ctx) {
+            OINKY_ASSERT((cc.ctype == column_types::Variant) || (cc.ctype == column_types::String));
+            char *cursor = ctx->rowbase + cc.new_row_offset_bytes;
+            if (cc.ctype == column_types::Variant) {
+                //  First write the typecode.
+                *(value_type_code_t *)cursor = cv.type();
+                cursor += 1;
+                //  Write the value.
+                i_stored_value::pack_variant(cv, cursor, *ctx->strtable);
+            } else {
+                //  Now pack the value...string or otherwise.
+                i_stored_value::pack_string(cv, cursor, *ctx->strtable);
+            }
+            return true;
+        }
+    };
+    
+    inline static void prepare_pack_prow(
+        const column_ctx *const* cols_begin,
+        const column_ctx *const* cols_end,
+        user_stringtable_t *strtable,
+        typename table_ctx::pitr_t &itr)
+    {
+        itr->template each_raw_value<prepare_pack_cb>(cols_begin, cols_end, strtable);
+    }
+    
+    inline static void complete_pack_prow(
+        const table_ctx *table,
+        typename table_ctx::pitr_t &itr, 
+        char *cursor)
+    {
+        //  If we are storing any single-bit columns...
+        if (table->packing.row_width.bit_count) {
+            //  Zero the bitfield, since we may not set them all.
+            memset(cursor + table->packing.row_width.byte_offset, 0, (table->packing.row_width.bit_count + 7) >> 3);
+        }
+        complete_pack_cb_ctx ctx(cursor, &table->db->userstrings);
+        itr->template each_raw_value<complete_pack_cb>(table->cols_by_position.begin(), table->cols_by_position.end(), &ctx);
+    }
+
+    //  This just marks the strings.
+    inline static void prepare_pack_row_strings(
+        table_ctx *table,
+        user_stringtable_t &strtable,
+        const consolidated_frow_strings *ci, 
+        const consolidated_frow_strings *coldefs_end, 
+        typename table_ctx::fixed_itr_t &itr)
+    {
+        row_idx_t rowkey = *itr;
+        const char *src_base = table->fixed.tabular.rowdata_base + 
+            (table->fixed.tabular.row_width_bytes * rowkey);
+            
+        for (;ci != coldefs_end; ++ci) {
+            const char *svalue = src_base + ci->src_offset;
+            u_strtable_ref sr;
+            unpack_nbc<scheme>(&sr, svalue);
+            strtable.mark_ref(sr);
+        }
+    }
+    inline static void complete_pack_frow_strings(
+        table_ctx *table,
+        const user_stringtable_t &strtable,
+        const consolidated_frow_strings *ci, 
+        const consolidated_frow_strings *coldefs_end, 
+        typename table_ctx::fixed_itr_t &itr,
+        char *trowbase)
+    {
+        row_idx_t rowkey = *itr;
+        const char *src_base = table->fixed.tabular.rowdata_base + 
+            (table->fixed.tabular.row_width_bytes * rowkey);
+            
+        for (;ci != coldefs_end; ++ci) {
+            const char *svalue = src_base + ci->src_offset;
+            char *tvalue = trowbase + ci->target_offset;
+            u_strtable_ref sr;
+            unpack_nbc<scheme>(&sr, svalue);
+            u_strtable_ref r = strtable.xform_ref(sr);
+            OINKY_ASSERT(r);
+            pack_nbc<scheme>(r, tvalue);
+        }
+    }
+    inline static void prepare_pack_row_variants(
+        table_ctx *table,
+        user_stringtable_t &strtable,
+        const consolidated_frow_strings *ci, 
+        const consolidated_frow_strings *coldefs_end, 
+        typename table_ctx::fixed_itr_t &itr)
+    {
+        row_idx_t rowkey = *itr;
+        const char *src_base = table->fixed.tabular.rowdata_base + 
+            (table->fixed.tabular.row_width_bytes * rowkey);
+            
+        for (;ci != coldefs_end; ++ci) {
+            const char *svalue = src_base + ci->src_offset;
+            if (*svalue == (char) value_types::String) {
+                ++svalue;
+                u_strtable_ref sr;
+                unpack_nbc<scheme>(&sr, svalue);
+                strtable.mark_ref(sr);
+            }
+        }
+    }
+    inline static void complete_pack_frow_variants(
+        table_ctx *table,
+        const user_stringtable_t &strtable,
+        const consolidated_frow_strings *ci, 
+        const consolidated_frow_strings *coldefs_end, 
+        typename table_ctx::fixed_itr_t &itr,
+        char *trowbase)
+    {
+        row_idx_t rowkey = *itr;
+        const char *src_base = table->fixed.tabular.rowdata_base + 
+            (table->fixed.tabular.row_width_bytes * rowkey);
+            
+        for (;ci != coldefs_end; ++ci) {
+            const char *svalue = src_base + ci->src_offset;
+            char *tvalue = trowbase + ci->target_offset;
+            value_type_code_t vt = (value_type_code_t) *svalue;
+            *tvalue = *svalue;
+            ++svalue;
+            ++tvalue;
+            if (vt == value_types::String) {
+                u_strtable_ref sr;
+                unpack_nbc<scheme>(&sr, svalue);
+                u_strtable_ref r = strtable.xform_ref(sr);
+                OINKY_ASSERT(r);
+                pack_nbc<scheme>(r, tvalue);
+                //  Two should fit in the 8 byte value cell.
+                BOOST_STATIC_ASSERT(sizeof(u_strtable_ref) == 4);
+                //  Zero the remainder.
+                tvalue += 4;
+                *(uint32 *)tvalue = 0;
+            } else {
+                //  Just copy the 8 bytes verbatim.
+                *(uint64*)tvalue = *(const uint64*)svalue;
+            }
+        }
+    }
+    inline static void complete_pack_frow_bytes(
+        table_ctx *table,
+        const consolidated_frow_bytes *ci, 
+        const consolidated_frow_bytes *coldefs_end, 
+        typename table_ctx::fixed_itr_t &itr,
+        char *trowbase)
+    {
+        row_idx_t rowkey = *itr;
+        const char *src_base = table->fixed.tabular.rowdata_base + 
+            (table->fixed.tabular.row_width_bytes * rowkey);
+            
+        for (;ci != coldefs_end; ++ci) {
+            const char *svalue = src_base + ci->src_offset;
+            char *tvalue = trowbase + ci->target_offset;
+            memcpy(tvalue, svalue, ci->width);
+        }
+    }
+
+    inline static void complete_pack_frow_bits(
+        table_ctx *table,
+        const consolidated_frow_bits *ci, 
+        const consolidated_frow_bits *coldefs_end, 
+        typename table_ctx::fixed_itr_t &itr,
+        char *trowbase)
+    {
+        row_idx_t rowkey = *itr;
+        const char *src_base = table->fixed.tabular.rowdata_base + 
+            (table->fixed.tabular.row_width_bytes * rowkey);
+
+        for (;ci != coldefs_end; ++ci) {
+            uint8 src = src_base[ci->src_offset] & ci->src_mask;
+            //  Not all architectures support negative shift, and it's undefined
+            //  in the language what it does, so I'm trusting the compiler to
+            //  optimize this if it can, but do the right thing generally.
+            if (ci->rshift < 0) {
+                int8 lshift = -ci->rshift;
+                OINKY_ASSERT((src & ~((256>>lshift) - 1)) == 0);
+                src <<= lshift;
+            } else {
+                //  We should have already masked out everything we don't need.
+                //  We should not be losing any bits.
+                OINKY_ASSERT((src & ((1<<ci->rshift) - 1)) == 0);
+                src >>= ci->rshift;
+            }
+            uint8 *t = (uint8 *) trowbase + ci->target_offset;
+            //  The target row buffer was zeroed, so we don't have ot worry about
+            //  clearing aanything.
+            *t |= src;
+        }
+    }
+            
+    //  This has two modes, one for each pass, PREPARE and FINAL.
+    template<bool PREPARE>
+    static uint32 pack_row_data(table_ctx *table, row_idx_t *remap_v, char *rowdatabegin)
+    {
+        char *rowcursor = rowdatabegin;
+        
+        //  Iterate through fixed entries.
+        typename table_ctx::fixed_itr_t fi = table->fixed.begin();
+        typename table_ctx::fixed_itr_t fe = table->fixed.end();
+        uint32 new_rowkey = 0;
+        
+        //  How many fixed rows do we expect to write?
+        uint32 fixed_rowcount = 
+            (table->fixed_dropped()) ?
+                0 :
+                (table->fixed.tabular.row_count - table->pending_deletes.size());
+
+        //  Only bother with this if we're going to write anything.
+        if (fixed_rowcount) {
+            OINKY_ASSERT(fi != fe);
+            //  Compute the column set summary (smaller and more local than
+            //  the full set of column contexts, plus with a simpler iterator).
+            //  In the fixed case we can eliminate branching on column type
+            //  in the inner loop.
+            consolidated_frow_bytes *bdefs = (consolidated_frow_bytes *) 
+                alloca(sizeof(consolidated_frow_bytes) * table->cols_by_position.size());
+            consolidated_frow_strings *sdefs = (consolidated_frow_strings *) 
+                alloca(sizeof(consolidated_frow_strings) * table->cols_by_position.size());
+            consolidated_frow_strings *vdefs = (consolidated_frow_strings *) 
+                alloca(sizeof(consolidated_frow_strings) * table->cols_by_position.size());
+            consolidated_frow_bits *btdefs = (consolidated_frow_bits *) 
+                alloca(sizeof(consolidated_frow_bits) * table->cols_by_position.size());
+            consolidated_frow_bytes *bt = bdefs;
+            consolidated_frow_bits *bitst = btdefs;
+            consolidated_frow_strings *st = sdefs;
+            consolidated_frow_strings *vt = vdefs;
+            uint32 this_bit = 0;
+            cols_itr_t ci = table->cols_by_position.begin();
+            cols_itr_t cend = table->cols_by_position.end();
+            for (; ci != cend; ++ci) 
+            {
+                const column_ctx &cc(**ci);
+                //  Fixed rows imply no schema change.
+                OINKY_ASSERT((cc.ls.insert_sp.val | cc.ls.delete_sp.val) == 0);
+                
+                if (cc.ctype == column_types::Variant) {
+                    vt->src_offset = cc.frow_byte_offset;
+                    vt->target_offset = cc.new_row_offset_bytes;
+                    ++vt;
+                } else if (cc.ctype == column_types::String) {
+                    st->src_offset = cc.frow_byte_offset;
+                    st->target_offset = cc.new_row_offset_bytes;
+                    ++st;
+                } else if (!PREPARE) {
+                    //
+                    //  These only need be computed for complete_pack
+                    //
+                    if (cc.ctype == column_types::Bit) {
+                        bitst->src_offset = cc.frow_byte_offset;
+                        bitst->target_offset = table->packing.row_width.byte_offset + (this_bit >> 3);
+                        OINKY_ASSERT(cc.frow_bit_offset < 8);
+                        bitst->src_mask = 1 << cc.frow_bit_offset;
+                        bitst->rshift = cc.frow_bit_offset - (this_bit & 7);
+                        ++this_bit;
+
+                        //  Merge into previous if we can.  This is the common case.
+                        if ((bitst != btdefs) &&
+                            ((bitst-1)->src_offset == bitst->src_offset) &&
+                            ((bitst-1)->target_offset == bitst->target_offset) &&
+                            ((bitst-1)->rshift == bitst->rshift)) 
+                        {
+                            OINKY_ASSERT(((bitst-1)->src_mask & bitst->src_mask) == 0);
+                            (bitst-1)->src_mask |= bitst->src_mask;
+                        } else {
+                            ++bitst;
+                        }
+                    } else {
+                        bt->src_offset = cc.frow_byte_offset;
+                        bt->width = compute_serialized_width(cc.ctype);
+                        bt->target_offset = cc.new_row_offset_bytes;
+                        //  Extend the limit or append to the previous.
+                        if ((bt != bdefs) &&
+                            ((bt-1)->src_offset + (bt-1)->width == bt->src_offset) &&
+                            ((bt-1)->target_offset + (bt-1)->width == bt->target_offset)) 
+                        {
+                            (bt-1)->width += bt->width;
+                        } else {
+                            ++bt;
+                        }
+                    }
+                }
+            }
+            
+            if (PREPARE) {
+                //  Mark the strings
+                for (;fi != fe; ++fi) {
+                    if (fi.is_deleted()) {
+                        continue;
+                    }
+                    prepare_pack_row_strings(table, table->db->userstrings, sdefs, st, fi);
+                    prepare_pack_row_variants(table, table->db->userstrings, vdefs, vt, fi);
+                    ++new_rowkey;
+                }
+                //  Just advance rowcursor all at once.
+                rowcursor += table->packing.row_width.full_width() * new_rowkey;
+            } else {
+                uint32 bitfield_offset = table->packing.row_width.byte_offset;
+                uint32 full_row_width = table->packing.row_width.full_width();
+                uint32 bitfield_width = table->packing.row_width.full_width() - bitfield_offset;
+                //  Iterate over fixed rows.
+                for (;fi != fe; ++fi) {
+                    if (fi.is_deleted()) {
+                        continue;
+                    }
+                    
+                    //  Pack the string values.  Neither of the following routines
+                    //  updates rowcursor.  We do that at the end of this iteration.
+                    complete_pack_frow_strings(table, table->db->userstrings, sdefs, st, fi, rowcursor);
+                    complete_pack_frow_variants(table, table->db->userstrings, vdefs, vt, fi, rowcursor);
+                    //  Pack the string values.
+                    complete_pack_frow_bytes(table, bdefs, bt, fi, rowcursor);
+                    if (bitst != btdefs) {
+                        //  Zero the target bitfield, so we can focus on setting only.
+                        memset(rowcursor + bitfield_offset, 0, bitfield_width);
+                        complete_pack_frow_bits(table, btdefs, bitst, fi, rowcursor);
+                    }
+                    //  Update the row re-map.
+                    row_idx_t oldrowkey = *fi;
+                    if (remap_v) {
+                        remap_v[oldrowkey] = new_rowkey;
+                    }
+                    //  Advance row cursor and rowkey.
+                    rowcursor += full_row_width;
+                    ++new_rowkey;
+                }
+            }
+        } //if (fixed_rowcount)
+        
+        OINKY_ASSERT(fixed_rowcount == new_rowkey);
+        
+        //  Now the dynamic entries.
+        typename table_ctx::pitr_t di = table->live_pending.begin();
+        typename table_ctx::pitr_t de = table->live_pending.end();
+        
+        if (table->live_pending.size()) {
+            //  Now write the rows.
+            uint32 serialized_row_width = table->packing.row_width.full_width();
+            if (PREPARE) {
+                //  During prepare, we only need to iterate over the indirect
+                //  columns.  Create a consolidated set of columns for this
+                //  pass.
+                const column_ctx **defs = (const column_ctx **) alloca(sizeof(const column_ctx *) * table->cols_by_position.size());
+                const column_ctx **t = defs;
+
+                cols_itr_t ci = table->cols_by_position.begin();
+                cols_itr_t cend = table->cols_by_position.end();
+                for (;ci != cend; ++ci) {
+                    if (((*ci)->ctype == column_types::Variant) || ((*ci)->ctype == column_types::String)) {
+                        *t = *ci;
+                        ++t;
+                    }
+                }
+
+                //  Iterate rows and mark strings.
+                for (;di != de; ++di) {
+                    prepare_pack_prow(defs, t, &table->db->userstrings, di);
+                    ++new_rowkey;
+                }
+                rowcursor += serialized_row_width * table->live_pending.size();
+            } else {
+                for (;di != de; ++di) {
+                    complete_pack_prow(table, di, rowcursor);
+                    rowcursor += serialized_row_width;
+                    di->new_rowkey = new_rowkey;
+                    ++new_rowkey;
+                }
+            }
+        }
+        OINKY_ASSERT(new_rowkey == table->row_count());
+        return rowcursor - rowdatabegin;
+    }
+    
+    static void complete_pack_table(
+        table_ctx *table, 
+        char *&header_cursor,
+        char *tableset_base, 
+        const char *end_buf,
+        uint32 *last_data_offset)
+    {
+        //###############
+        //  First prepare the header.
+        s_table_hdr::pack(
+            //  Extract the new stringreference, which may differ from the old,
+            //  if it existed at all before.
+            table->db->metastrings.xform_ref(table->tablename), 
+            //  This routine will alternate with complete_pack_table during 
+            //  serialization, and that routine will advance this pointer after
+            //  packing this table.
+            *last_data_offset, 
+            header_cursor, 
+            end_buf);
+
+        //###############
+        //  Now the table context itself.
+        char *write_cursor = tableset_base + *last_data_offset;
+    
+        Serializer<row_idx_t, scheme>::pack((row_idx_t) table->row_count(), write_cursor, end_buf);
+        //  Save this position so we can write the rowdata offset once we know it.
+        //  
+        uint32 rowdataoffset = 
+            write_cursor - tableset_base +      //here
+            4 +                                 // + self
+            table->columns.computed_packed_header_bytes + // column data
+            table->packing.indexset_size;       // index_data;
+        Serializer<uint32, scheme>::pack(rowdataoffset, write_cursor, end_buf);//rowdata_offset
+
+        //  Pack the column data
+        complete_pack_set(
+            table->columns, 
+            write_cursor,
+            boost::bind(&complete_pack_column, _1, _2, table->db, end_buf));
+            
+        OINKY_ASSERT( write_cursor - tableset_base + 
+            table->packing.indexset_size == rowdataoffset);
+
+        //  The index data appears next in the buffer, but before we can store 
+        //  it we need to calculate the new row positions.  
+        char *ixsetbegin = write_cursor;
+        
+        //###############
+        //  Rowdata
+        row_idx_t *remap_v = NULL;
+        if (must_remap_fixedkeys(table)) 
+        {
+            //  In this case the fixed set was partially but not completely deleted.
+            //  We need to remap it.
+            OINKY_ASSERT((uint32) table->fixed.tabular.row_count <= table->db->packing.max_fixed_table_remap_size);
+            
+            //  check-alloc remap buffer.
+            //  This will be zero if we've never initialized it.  When we initialize it, 
+            //  we set it to the max table size discovered during pack.  However, it
+            //  may still be smaller than the present table if subsequent to
+            //  a previous pack, a savepoint was reverted, restoring a deleted table
+            //  larger than all the others.
+            if (table->db->packing.row_remap_vector.size() < (uint32) table->fixed.tabular.row_count) {
+                //  Assign with zero size (so we don't create a temporary), in order
+                //  to assign the allocator.
+                table->db->packing.row_remap_vector = db_vector<row_idx_t>(&table->db->allocator);
+                //  Now resize in place.
+                //  Resize to zero first so that we don't bother copying the old (junk) data.
+                table->db->packing.row_remap_vector.resize(0);
+                table->db->packing.row_remap_vector.resize(table->db->packing.max_fixed_table_remap_size);
+            }
+            remap_v = table->db->packing.row_remap_vector.begin();
+        }
+
+        //  Pack the row data.
+        char *rowdatabegin = ixsetbegin + table->packing.indexset_size;
+        OINKY_ASSERT( tableset_base + rowdataoffset == rowdatabegin );
+        uint32 rowdata_bytes = pack_row_data<false>(table, remap_v, rowdatabegin);
+        OINKY_ASSERT(rowdata_bytes == table->packing.rowdata_bytes);
+
+        uint32 next_tbl_data_offset = rowdatabegin + rowdata_bytes - tableset_base;
+        OINKY_ASSERT(next_tbl_data_offset - *last_data_offset == table->packing.total_size);
+        *last_data_offset = next_tbl_data_offset;
+
+        //  Write the rowdata pointer.
+
+        //#########
+        //  Index data.
+        write_cursor = ixsetbegin;
+        const char *ixend = ixsetbegin + table->packing.indexset_size;
+        Serializer<uint32, scheme>::pack(table->packing.indexset_size, write_cursor, ixend);
+
+        char *prehdr = write_cursor;
+        uint32 indexdata_offset = (write_cursor - ixsetbegin) + 
+            table->indexes.computed_packed_header_bytes;
+        
+        complete_pack_set(
+            table->indexes,
+            write_cursor,
+            boost::bind(
+                &complete_pack_index, 
+                _1, 
+                _2,
+                ixsetbegin, 
+                end_buf, 
+                &indexdata_offset,
+                remap_v));
+                
+        OINKY_ASSERT(write_cursor == prehdr + table->indexes.computed_packed_header_bytes);
+        OINKY_ASSERT(indexdata_offset == table->packing.indexset_size);
+    }
+    
+    template<typename HDR_T, typename CTX_TRAITS, typename FN>
+    static uint32 prepare_pack_set(context_map_t<CTX_TRAITS> &map, FN fn)
+    {
+        typedef typename CTX_TRAITS::index_t index_t;
+        typedef context_map_t<CTX_TRAITS> map_t;
+        typedef typename map_t::by_name_iterator bni;
+        
+        bni i = map.by_name().begin();
+        bni end = map.by_name().end();
+        
+        uint32 bytes = 0;
+        uint32 j = 0;
+        for (;i != end; ++i, ++j) {
+            //  Reference the metastring, so it will get stored.
+            map.stringtable->mark(CTX_TRAITS::key_from_ctx(*i));
+            
+            bytes += fn(*i);
+        }
+        map.computed_packed_header_bytes = j * sizeof(HDR_T);
+        //  For the count.
+        map.computed_packed_header_bytes += Serializer<index_t,scheme>::virtual_pack();
+
+        bytes += map.computed_packed_header_bytes;
+        return bytes;
+    }
+
+    template<typename CTX_TRAITS, typename FN>
+    static void complete_pack_set(
+        context_map_t<CTX_TRAITS> &map,
+        char *&cursor,
+        FN fn)
+    {
+        typedef typename CTX_TRAITS::index_t index_t;
+        typedef context_map_t<CTX_TRAITS> map_t;
+        typedef typename map_t::by_name_iterator bni;
+        
+        bni end = map.by_name().end();
+        
+        //  Save the position where we'll write the count.
+        char *count_cursor = cursor;
+        cursor += Serializer<index_t,scheme>::virtual_pack();
+
+        uint32 j = 0;
+        //  Write each of the headers
+        for (bni i = map.by_name().begin();i != end; ++i, ++j) {
+            fn(*i, cursor);
+        }
+        
+        //  Write the count.
+        Serializer<index_t,scheme>::pack((index_t) j, count_cursor, cursor);
+    }
+
+    //  This does two things.  One is it does an initial pack phase, preparing
+    //  the database for serialization.  This may allocate memory internally
+    //  for sorting or other operations which are required prior to pack.
+    //  It returns the number of bytes that will be required of the buffer
+    //  to contain the serialized database.  complete_pack should be called 
+    //  after phase1_pack, with no intervening changes.
+    static uint32 prepare_pack(db_handle_internal &db)
+    {
+        uint32 bytes = 0;
+        //  Encoding scheme.
+        bytes += Serializer<scheme,scheme>::virtual_pack();
+        
+        //  DB-size : We always serialize as a 4-byte integer.
+        bytes += Serializer<uint32,scheme>::virtual_pack();
+        
+        //  Clear stringtable reference counts.  Allocate vectors to 
+        //  store reference counts if necessary.
+        db.metastrings.clear_references();
+        db.userstrings.clear_references();
+
+        uint32 tblbytes = 0;
+        //  indicator - size in bytes of the serialied tableset.
+        tblbytes += Serializer<uint32,scheme>::virtual_pack();
+        
+        //  Compute the space required to store all tables.
+        //  While we're at it, mark all referenced strings.
+        tblbytes += prepare_pack_set<s_table_hdr>(
+            db.tables, 
+            boost::bind(&prepare_pack_table, _1, &db));
+
+        //  Use string markings to transform string indexes, and compute
+        //  new stringtable sizes.
+        //
+        //  These are NOT part of the tableset.
+        bytes += db.metastrings.compute_indexes_and_length();
+        bytes += db.userstrings.compute_indexes_and_length();
+        
+        //  Remember the computed size.
+        db.packing.tableset_size = tblbytes;
+        db.packing.total_bytes = bytes + tblbytes;
+        
+        //  The trailer.
+        db.packing.total_bytes += Serializer<v1_trailer, v1_sformat_tag>::virtual_pack();
+        
+        return db.packing.total_bytes;
+    }
+
+    //  This must be called after prepare_pack.  If any changes to the database
+    //  are made in between, the resulting serialized database is likely to be
+    //  corrupted.
+    static void complete_pack(db_handle_internal &db, char *&next_buffer, const char *end_buf) 
+    {
+        char *begin = next_buffer;
+        if (end_buf - begin < db.packing.total_bytes) {
+            throw_error(buffer_overflow());
+        }
+        //  Limit end buffer to what we computed.
+        end_buf = begin + db.packing.total_bytes;
+        
+        //  Check the encoding.
+        //  This will throw if the scheme is wrong.
+        Serializer<scheme,scheme>::pack(next_buffer, end_buf);
+
+        Serialization::pack<scheme>(db.packing.total_bytes, next_buffer, end_buf);
+
+        //  Pack the string tables.  The string tables aren't exactly separable
+        //  from their encoding, so we just call member functions.
+        db.metastrings.pack<scheme>(next_buffer, end_buf);
+        db.userstrings.pack<scheme>(next_buffer, end_buf);
+        
+        //  Write the tableset map and tables.
+        char *const tableset_begin(next_buffer);
+        Serialization::pack<scheme>(db.packing.tableset_size, next_buffer, end_buf);
+        
+        uint32 last_tableset_data_offset = 
+            (next_buffer - tableset_begin) + 
+            db.tables.computed_packed_header_bytes;
+        
+        complete_pack_set(
+            db.tables, 
+            next_buffer,
+            boost::bind(&complete_pack_table, _1, _2, tableset_begin, end_buf, &last_tableset_data_offset));
+
+        //  The tableset is framed by the DB size itself.
+        OINKY_ASSERT(last_tableset_data_offset == db.packing.tableset_size);
+        next_buffer = tableset_begin + last_tableset_data_offset;
+        OINKY_ASSERT(next_buffer + 4 == end_buf);
+        
+        //  Write the trailer.
+        Serializer<v1_trailer, v1_sformat_tag>::pack(next_buffer, end_buf);
+        OINKY_ASSERT(next_buffer == end_buf);
+    }
+};
+
+} //namespace Serialization
+} //namespace Oinky
+