oinky 0.1.0

data/ext/nky_lib.cpp

@@ -0,0 +1,390 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+#include "nky_lib_core.hpp"
+
+
+const char *convert_oinky_error(oinky_error err)
+{
+    return Oinky::Errors::oinky_category_impl::messagebytes(-(int)err);
+}
+
+oinky_db_variant _nky_variant_from_immediate_s(const char *str) {
+    return nky_variant_from_immediate_s(str);
+}
+oinky_db_variant _nky_variant_from_immediate_dt(oinky_datetime_t dt) {
+    return nky_variant_from_immediate_dt(dt);
+}
+//int
+oinky_db_variant _nky_variant_from_immediate_i64(int64_t x) {
+    return nky_variant_from_immediate_i64(x);
+}
+oinky_db_variant _nky_variant_from_immediate_i32(int32_t x) {
+    return nky_variant_from_immediate_i32(x);
+}
+oinky_db_variant _nky_variant_from_immediate_i16(int16_t x) {
+    return nky_variant_from_immediate_i16(x);
+}
+oinky_db_variant _nky_variant_from_immediate_i8(int8_t x) {
+    return nky_variant_from_immediate_i8(x);
+}
+//uint
+oinky_db_variant _nky_variant_from_immediate_ui64(uint64_t x) {
+    return nky_variant_from_immediate_ui64(x);
+}
+oinky_db_variant _nky_variant_from_immediate_ui32(uint32_t x) {
+    return nky_variant_from_immediate_ui32(x);
+}
+oinky_db_variant _nky_variant_from_immediate_ui16(uint16_t x) {
+    return nky_variant_from_immediate_ui16(x);
+}
+oinky_db_variant _nky_variant_from_immediate_ui8(uint8_t x) {
+    return nky_variant_from_immediate_ui8(x);
+}
+//float
+oinky_db_variant _nky_variant_from_immediate_f64(float64_t x) {
+    return nky_variant_from_immediate_f64(x);
+}
+oinky_db_variant _nky_variant_from_immediate_f32(float32_t x) {
+    return nky_variant_from_immediate_f32(x);
+}
+
+oinky_db_variant _nky_variant_from_immediate_bit(int x) {
+    return nky_variant_from_immediate_bit(x);
+}
+
+oinky_error nky_pack_datetime(oinky_datetime_t *dt, nky_datetime_unpacked unpacked)
+{
+    dt->value = datetime_t::compose(
+        unpacked.years_since_1900,
+        unpacked.months_since_january,
+        unpacked.days_since_first_of_month,
+        unpacked.hours_since_midnight,
+        unpacked.minutes_since_hour,
+        unpacked.seconds_since_minute,
+        unpacked.microseconds_since_second)._val;
+    return nky_success;
+}
+
+oinky_error nky_unpack_datetime(oinky_datetime_t packed, nky_datetime_unpacked *unpacked)
+{
+    datetime_t dt;
+    dt._val = packed.value;
+    unpacked->years_since_1900            = dt.years_since_1900();
+    unpacked->months_since_january        = dt.months_since_january();
+    unpacked->days_since_first_of_month   = dt.days_since_first_of_month();
+    unpacked->hours_since_midnight        = dt.hours_since_midnight();
+    unpacked->minutes_since_hour          = dt.minutes_since_hour();
+    unpacked->seconds_since_minute        = dt.seconds_since_minute();
+    unpacked->microseconds_since_second   = dt.microseconds_since_second();
+    return nky_success;
+}
+
+
+//#############################################################################
+//  Managing DB instances
+
+//  Allocate a new, empty DB instance.  This must be freed with oinky_db_free.
+//  Returns NULL on error.
+oinky_db_handle_t *oinky_db_new()
+{
+    oinky_db_handle_t *db = new oinky_db_handle_t();
+    return db;
+}
+
+//  Create a new DB instance from serialized bytes.  The new handle will 
+//  continue to access the given buffer until it is destroyed and the caller
+//  should manage the lifetimes of both the DB handle and bytestring appropriately.
+static oinky_error oinky_db_mount_impl(oinky_db_handle_t **handle, size_t bufferlen, const char *bytes)
+{
+    if (bufferlen > (1 << 30)) {
+        throw_error(Oinky::Errors::invalid_argument());
+    }
+    auto_ptr<oinky_db_handle_t> db(new oinky_db_handle_t());
+    db_t::mount(&db->db, bytes, (uint32) bufferlen);
+    //  Caller now owns the reference.
+    *handle = db.release();
+    return nky_success;
+}
+
+oinky_error oinky_db_mount(oinky_db_handle_t **handle, size_t bufferlen, const char *bytes)
+{
+    return wrap_exception(boost::bind(oinky_db_mount_impl, handle, bufferlen, bytes));
+}
+
+//  Destroy and deallocate an oinky DB instance.
+void oinky_db_free(oinky_db_handle_t *db)
+{
+    delete db;
+}
+
+static oinky_error oinky_db_prepare_pack_impl(oinky_db_handle_t *db, size_t *required_bytes)
+{
+    *required_bytes = db->db.prepare_pack();
+    return nky_success;
+}
+
+//  Compute the number of bytes required to serialize the given database.
+oinky_error oinky_db_prepare_pack(oinky_db_handle_t *db, size_t *required_bytes)
+{
+    return wrap_exception(boost::bind(oinky_db_prepare_pack_impl, db, required_bytes));
+}
+//  Serialize the database to the given buffer.
+static oinky_error oinky_db_complete_pack_impl(oinky_db_handle_t *db, size_t bufferlen, char *buffer)
+{
+    if (bufferlen > (1 << 30)) {
+        throw_error(Oinky::Errors::invalid_argument());
+    }
+    db->db.complete_pack(buffer, (uint32) bufferlen);
+    return nky_success;
+}
+oinky_error oinky_db_complete_pack(oinky_db_handle_t *db, size_t bufferlen, char *buffer)
+{
+    return wrap_exception(boost::bind(oinky_db_complete_pack_impl, db, bufferlen, buffer));
+}
+
+//  Create a savepoint and save the marker at the given address.
+static oinky_error oinky_db_create_savepoint_impl(oinky_db_handle_t *db, oinky_savepoint_t *sp)
+{
+    sp_marker_t spmarker = db->db.new_sp();
+    *sp = (uint64_t) spmarker.val;
+    return nky_success;
+}
+oinky_error oinky_db_create_savepoint(oinky_db_handle_t *db, oinky_savepoint_t *sp)
+{
+    return wrap_exception(boost::bind(oinky_db_create_savepoint_impl, db, sp));
+}
+static oinky_error oinky_db_savepoint_rollback_impl(oinky_db_handle_t *db, oinky_savepoint_t sp)
+{
+    sp_marker_t spmarker;
+    spmarker.val = (uint32_t) sp;
+    db->db.sp_rollback(spmarker);
+    return nky_success;
+}
+oinky_error oinky_db_savepoint_rollback(oinky_db_handle_t *db, oinky_savepoint_t sp)
+{
+    return wrap_exception(boost::bind(oinky_db_savepoint_rollback_impl, db, sp));
+}
+
+//##############
+//  Stats/Properties
+
+int oinky_db_is_modified_since(oinky_db_handle_t *db, oinky_savepoint_t sp)
+{
+    sp_marker_t spmarker;
+    spmarker.val = (uint32_t) sp;
+    return db->db.modified_since(spmarker) ? 1 : 0;
+}
+
+size_t oinky_table_count(oinky_db_handle_t *db)
+{
+    //TBD: This should be more efficient.
+    return std::distance(db->db.tables().begin(), db->db.tables().end());
+}
+
+size_t oinky_tbl_column_count(oinky_table_handle_t *table)
+{
+    return make_handle(table).columns().count();
+}
+
+size_t oinky_idx_column_count(oinky_index_handle_t *index)
+{
+    return make_handle(index).column_count();
+}
+
+size_t oinky_tbl_index_count(oinky_table_handle_t *table)
+{
+    return make_handle(table).indices().count();
+}
+
+size_t oinky_tbl_row_count(oinky_table_handle_t *table)
+{
+    return make_handle(table).row_count();
+}
+
+size_t oinky_idx_row_count(oinky_index_handle_t *index)
+{
+    return make_handle(index).row_count();
+}
+
+oinky_db_string oinky_table_name(oinky_table_handle_t *table)
+{
+    return make_str(make_handle(table).name());
+}
+
+oinky_db_string oinky_index_name(oinky_index_handle_t *index)
+{
+    return make_str(make_handle(index).name());
+}
+
+
+//#############################################################################
+//  Enumerating objects
+
+size_t oinky_db_get_table_handles(oinky_db_handle_t *db, oinky_table_handle_t **handle_array, size_t array_size)
+{
+    db_t::table_itr i = db->db.tables().begin();
+    db_t::table_itr end = db->db.tables().end();
+    size_t idx=0;
+    for (;idx < array_size; ++idx, ++i) {
+        if (i == end) {
+            break;
+        }
+        handle_array[idx] = (oinky_table_handle_t *) i->raw();
+    }
+    return idx;
+}
+
+size_t oinky_table_get_index_handles(oinky_table_handle_t *table, oinky_index_handle_t **handle_array, size_t array_size)
+{
+    db_t::index_itr i = make_handle(table).indices().begin();
+    db_t::index_itr end = make_handle(table).indices().end();
+    size_t idx=0;
+    for (;idx < array_size; ++idx, ++i) {
+        if (i == end) {
+            break;
+        }
+        handle_array[idx] = (oinky_index_handle_t *) i->raw();
+    }
+    return idx;
+}
+
+static void oinky_table_get_column_defs_impl(oinky_table_handle_t *table, oinky_column_def *def_array, size_t array_size, size_t *result)
+{
+    db_t::column_itr i = make_handle(table).columns().begin();
+    db_t::column_itr end = make_handle(table).columns().end();
+    size_t idx=0;
+    for (;idx < array_size; ++idx, ++i) {
+        if (i == end) {
+            break;
+        }
+        def_array[idx].column_name = make_str(i->column_name);
+        def_array[idx].column_type = (oinky_column_type_code_t) i->column_type;
+        def_array[idx].default_value = nky_variant_from_variant(i->default_value);
+    }
+    *result = idx;
+}
+
+size_t oinky_table_get_column_defs(oinky_table_handle_t *table, oinky_column_def *def_array, size_t array_size)
+{
+    size_t result = 0;
+    wrap_void(boost::bind(oinky_table_get_column_defs_impl, table, def_array, array_size, &result));
+    return result;
+}
+
+static oinky_error oinky_index_get_definition_impl(oinky_index_handle_t *index, oinky_db_string *name, char *is_unique, oinky_index_column_def *def_array, size_t array_size)
+{
+    db_t::index_handle ih(make_handle(index));
+    
+    if (array_size != ih.column_count()) {
+        return nky_invalid_argument;
+    }
+    
+    *name = make_str(ih.name());
+    *is_unique = ih.is_unique() ? 1 : 0;
+    
+    db_t::index_column_itr i = make_handle(index).columns().begin();
+    db_t::index_column_itr end = make_handle(index).columns().end();
+    size_t idx=0;
+    for (;idx < array_size; ++idx, ++i) {
+        if (i == end) {
+            break;
+        }
+        def_array[idx].column_name = make_str(i->column_name);
+        def_array[idx].sort_ascending = i->sort_ascending ? 1 : 0;
+    }
+    return nky_success;
+}
+
+oinky_error oinky_index_get_definition(oinky_index_handle_t *index, oinky_db_string *name, char *is_unique, oinky_index_column_def *def_array, size_t array_size)
+{
+    return wrap_exception(boost::bind(oinky_index_get_definition_impl, index, name, is_unique, def_array, array_size));
+}
+
+
+//#############################################################################
+//  Schema Modification
+static oinky_error oinky_db_create_table_impl(oinky_db_handle_t *db, const char *name, oinky_table_handle_t **handle)
+{
+    db_t::table_itr i = db->db.tables().create(name);
+    *handle = (oinky_table_handle_t *) i->raw();
+    return nky_success;
+}
+oinky_error oinky_db_create_table(oinky_db_handle_t *db, const char *name, oinky_table_handle_t **handle)
+{
+    return wrap_exception(boost::bind(oinky_db_create_table_impl, db, name, handle));
+}
+
+static oinky_error oinky_db_drop_table_impl(oinky_db_handle_t *db, db_string tblname)
+{
+    db_t::tables_accessor_t tbs(db->db.tables());
+    db_t::table_itr i = tbs.find(tblname);
+    if (i == tbs.end()) {
+    
+        throw_error(object_not_found());
+    }
+    tbs.drop(i);
+    return nky_success;
+}
+oinky_error oinky_db_drop_table(oinky_db_handle_t *db, oinky_db_string tblname)
+{
+    return wrap_exception(boost::bind(oinky_db_drop_table_impl, db, nky_string_xform(tblname)));
+}
+
+static oinky_error oinky_table_add_index_impl(oinky_table_handle_t *table, const char *idxname, char unique, size_t col_count, const oinky_index_column_def *coldefs, oinky_index_handle_t **ih)
+{
+    db_t::table_handle th(make_handle(table));
+    
+    db_t::index_column_def *defs = (db_t::index_column_def *) alloca(sizeof(db_t::index_column_def) * col_count);
+    for (size_t i=0;i<col_count;++i) {
+        defs[i].column_name = nky_string_xform(coldefs[i].column_name);
+        defs[i].sort_ascending = coldefs[i].sort_ascending != 0;
+    }
+    
+//    db_t::column_selector_t cs = th.select(colnames, colnames + col_count);
+    db_t::index_itr it = th.indices().create(
+        db_string(idxname), 
+        unique ? Oinky::Unique : Oinky::NonUnique, 
+        defs, defs + col_count);
+    *ih = (oinky_index_handle_t *) it->raw();
+    return nky_success;
+}
+
+oinky_error oinky_table_add_index(oinky_table_handle_t *table, const char *idxname, char unique, size_t col_count, const oinky_index_column_def *coldefs, oinky_index_handle_t **ih)
+{
+    return wrap_exception(boost::bind(oinky_table_add_index_impl, table, idxname, unique, col_count, coldefs, ih));
+}
+
+//##############
+//  Data Access
+
+static oinky_error oinky_table_make_column_selector_impl(oinky_table_handle_t *table, size_t col_count, char **colnames, oinky_column_selector_t **selector)
+{
+    auto_ptr<oinky_column_selector_t> s(new oinky_column_selector_t());
+    s->cs = make_handle(table).make_selector(colnames, colnames + col_count);
+    *selector = s.get();
+    s.release();
+    return nky_success;
+}
+
+oinky_error oinky_table_make_column_selector(oinky_table_handle_t *table, size_t col_count, char **colnames, oinky_column_selector_t **selector)
+{
+    return wrap_exception(boost::bind(oinky_table_make_column_selector_impl, table, col_count, colnames, selector));
+}
+
+oinky_error oinky_table_delete_column_selector(oinky_table_handle_t *table, oinky_column_selector_t *selector)
+
+{   
+    //  This actually has no reference whatsoever on the table or the DB, so 
+    //  it is safe even to delete it out of order, or at any time.
+    delete selector;
+    return nky_success;
+}
+
+//###############
+//  Test support
+void oinky_debug_break()
+{
+}

data/ext/nky_lib_core.hpp

@@ -0,0 +1,212 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+#include <iostream>
+
+//  C function definitions.
+#include "oinky.h"
+#include "oinky.hpp"
+
+using namespace std;
+using namespace Oinky;
+
+using Oinky::variant_cv_t;
+using Oinky::sp_marker_t;
+using Oinky::db_t;
+
+struct _oinky_db_handle_t {
+    db_t db;
+};
+
+struct _oinky_column_selector_t {
+    db_t::column_selector_t cs;
+};
+
+//  These types are merely tags.  
+struct _oinky_table_handle_t {};
+struct _oinky_index_handle_t {};
+struct _oinky_table_row_cursor_t {};
+struct _oinky_index_row_cursor_t {};
+
+
+static Oinky::column_type_code_t nky_column_type_xform(oinky_column_type_code_t cc)
+{
+    switch (cc) {
+        case nky_Variant : return column_types::Variant;
+        case nky_Bit : return column_types::Bit;
+        
+        case nky_Int8 : return column_types::Int8;
+        case nky_Int16 : return column_types::Int16;
+        case nky_Int32 : return column_types::Int32;
+        case nky_Int64 : return column_types::Int64;
+        
+        case nky_Uint8 : return column_types::Uint8;
+        case nky_Uint16 : return column_types::Uint16;
+        case nky_Uint32 : return column_types::Uint32;
+        case nky_Uint64 : return column_types::Uint64;
+        
+        case nky_Float32 : return column_types::Float32;
+        case nky_Float64 : return column_types::Float64;
+        
+        case nky_String : return column_types::String;
+        case nky_Datetime : return column_types::Datetime;
+    }
+    throw_error(Oinky::Errors::invalid_argument());
+}
+
+static db_string nky_string_xform(const oinky_db_string &str)
+{
+    if (str.length > (1 << 30)) {
+        throw_error(Oinky::Errors::invalid_argument());
+    }
+    return db_string(str.bytes, (uint32) str.length);
+}
+
+static variant_cv_t nky_variant_xform(const oinky_db_variant &var)
+{
+    switch (var.type) {
+        case nky_Bit : 
+            return variant_cv_t(var.value.int_value != 0);
+        case nky_Int8 : 
+        case nky_Int16 : 
+        case nky_Int32 : 
+        case nky_Int64 : 
+            return variant_cv_t(var.value.int_value);
+        case nky_Uint8 : 
+        case nky_Uint16 : 
+        case nky_Uint32 : 
+        case nky_Uint64 : 
+            return variant_cv_t(var.value.uint_value);
+        case nky_Float32 : 
+            return variant_cv_t(var.value.f32_value);
+        case nky_Float64 : 
+            return variant_cv_t(var.value.f64_value);
+        case nky_String : 
+            return variant_cv_t(nky_string_xform(var.value.string_value));
+        case nky_Datetime : {
+                datetime_t x;
+                *(oinky_datetime_t *)&x = var.value.dt_value;
+                return variant_cv_t(x);
+            }
+        case nky_Variant:
+            //  This is bogus.  A column can have variant type, but not a value.
+            //  Fall through.
+            break;
+    }
+    throw_error(Oinky::Errors::invalid_argument());
+    return variant_cv_t();
+}
+
+
+
+
+//##############
+//  Auto-convert the C-types to our familiar object instances.
+static inline oinky_db_string make_str(const db_string &dbs) 
+{
+    oinky_db_string r;
+    r.bytes = dbs.begin();
+    r.length = dbs.length();
+    return r;
+}
+
+static inline oinky_datetime_t make_dt(const datetime_t &dt) {
+    return *(const oinky_datetime_t *)&dt;
+}
+
+//
+//  Construct a legit index handle from the opaque context pointer.
+//  The handle objects are all trivially copyable, but contain no more
+//  information than a simple pointer value, and can be cast to/from
+//  this raw format to fit them into container/host objects without
+//  requiring an extra level of indirection.
+//
+static inline db_t::table_handle make_handle(oinky_table_handle_t *table) 
+{
+    return db_t::table_handle((db_t::table_handle::raw_handle_t *)table);
+}
+static inline db_t::index_handle make_handle(oinky_index_handle_t *index) 
+{
+    return db_t::index_handle((db_t::index_handle::raw_handle_t *)index);
+}
+static inline db_t::table_cursor_handle make_handle(oinky_table_row_cursor_t *tc) 
+{
+    return db_t::table_cursor_handle((db_t::table_cursor_handle::raw_handle_t *)tc);
+}
+static inline db_t::index_cursor_handle make_handle(oinky_index_row_cursor_t *ic) 
+{
+    return db_t::index_cursor_handle((db_t::index_cursor_handle::raw_handle_t *)ic);
+}
+
+
+static oinky_db_variant nky_variant_from_variant(const variant_cv_t &v) {
+    if (v.is_string()) {
+        return nky_variant_from_immediate_dbs(make_str(v.string_value()));
+    }
+    if (v.is_f32()) {
+        return nky_variant_from_immediate_f32(v.f32_value());
+    }
+    if (v.is_f64()) {
+        return nky_variant_from_immediate_f64(v.f64_value());
+    }
+    if (v.is_int()) {
+        return nky_variant_from_immediate_i64(v.int_value());
+    }
+    if (v.is_uint()) {
+        return nky_variant_from_immediate_ui64(v.uint_value());
+    }
+    if (v.is_date()) {
+        return nky_variant_from_immediate_dt(make_dt(v.dt_value()));
+    }
+    if (v.is_bit()) {
+        return nky_variant_from_immediate_bit(v.bit_value() ? 1 : 0);
+    }
+    throw_error(bad_encoding());
+    return nky_variant_from_immediate_i64(0);
+}
+
+
+template<typename FN>
+static oinky_error wrap_exception(FN fn)
+{
+    try {
+        return fn();
+    } catch (boost::system::system_error err) {
+        return (oinky_error) -err.code().value();
+    } catch (...) {
+        return nky_unknown_exception;
+    }
+}
+template<typename FN>
+static oinky_error wrap_void(FN fn)
+{
+    try {
+        fn();
+    } catch (boost::system::system_error err) {
+        return (oinky_error) -err.code().value();
+    } catch (...) {
+        return nky_unknown_exception;
+    }
+    return nky_success;
+}
+
+
+template<typename FN>
+static oinky_error wrap_unpack_variant_list(FN fn, size_t count, const oinky_db_variant *values)
+{
+    try {
+        variant_cv_t *vars = (variant_cv_t *) alloca(count * sizeof(variant_cv_t));
+        for (size_t i = 0;i < count; ++i) {
+            vars[i] = nky_variant_xform(values[i]);
+        }
+        fn(vars);
+    } catch (boost::system::system_error err) {
+        return (oinky_error) -err.code().value();
+    } catch (...) {
+        return nky_unknown_exception;
+    }
+    return nky_success;
+}
+