amalgalite 0.10.1-x86-mingw32

data/ext/amalgalite/amalgalite3.h

@@ -0,0 +1,151 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#ifndef __AMALGALITE_H__
+#define __AMALGALITE_H__
+
+#include "ruby.h"
+#include "sqlite3.h"
+#include <string.h>
+
+/* wrapper struct around the sqlite3 opaque pointer */
+typedef struct am_sqlite3 {
+  sqlite3 *db;
+  VALUE    trace_obj;
+  VALUE    profile_obj;
+  VALUE    busy_handler_obj;
+  VALUE    progress_handler_obj;
+} am_sqlite3;
+
+/* wrapper struct around the sqlite3_statement opaque pointer */
+typedef struct am_sqlite3_stmt {
+  sqlite3_stmt *stmt;
+  VALUE         remaining_sql;
+} am_sqlite3_stmt;
+
+/* wrapper struct around the sqlite3_blob opaque ponter */
+typedef struct am_sqlite3_blob {
+  sqlite3_blob *blob;
+  sqlite3      *db;
+  int           length;
+  int           current_offset;
+} am_sqlite3_blob;
+
+/* wrapper struct around the information needed to call rb_apply
+ * used to encapsulate data into a call for amalgalite_wrap_apply
+ */
+typedef struct am_protected {
+    VALUE     instance;
+    ID        method;
+    int       argc;
+    VALUE    *argv;
+} am_protected_t;
+
+/** module and classes **/
+extern VALUE mA;              /* module Amalgalite                     */
+extern VALUE mAS;             /* module Amalgalite::SQLite3            */
+extern VALUE mASV;            /* module Amalgalite::SQLite3::Version   */
+extern VALUE eAS_Error;       /* class  Amalgalite::SQLite3::Error     */
+extern VALUE cAR;             /* class  Amalgalite::Requries */
+extern VALUE cARB;            /* class  Amalgalite::Requries::Bootstrap  */
+
+/*----------------------------------------------------------------------
+ * Prototype for Amalgalite::SQLite3::Database
+ *---------------------------------------------------------------------*/
+extern VALUE cAS_Database;    /* class  Amalgalite::SQLite3::Database  */
+
+extern void  am_define_constants_under(VALUE);
+extern VALUE am_sqlite3_database_alloc(VALUE klass);
+extern void  am_sqlite3_database_free(am_sqlite3*);
+extern VALUE am_sqlite3_database_open(int argc, VALUE* argv, VALUE self);
+extern VALUE am_sqlite3_database_close(VALUE self);
+extern VALUE am_sqlite3_database_open16(VALUE self, VALUE rFilename);
+extern VALUE am_sqlite3_database_last_insert_rowid(VALUE self);
+extern VALUE am_sqlite3_database_is_autocommit(VALUE self);
+extern VALUE am_sqlite3_database_row_changes(VALUE self);
+extern VALUE am_sqlite3_database_total_changes(VALUE self);
+extern VALUE am_sqlite3_database_table_column_metadata(VALUE self, VALUE db_name, VALUE tbl_name, VALUE col_name);
+
+extern VALUE am_sqlite3_database_prepare(VALUE self, VALUE rSQL);
+extern VALUE am_sqlite3_database_register_trace_tap(VALUE self, VALUE tap);
+extern VALUE am_sqlite3_database_register_profile_tap(VALUE self, VALUE tap);
+extern VALUE am_sqlite3_database_busy_handler(VALUE self, VALUE handler);
+
+/*----------------------------------------------------------------------
+ * Prototype for Amalgalite::SQLite3::Statement 
+ *---------------------------------------------------------------------*/
+extern VALUE cAS_Statement;   /* class  Amalgalite::SQLite3::Statement */
+
+extern VALUE am_sqlite3_statement_alloc(VALUE klass);
+extern void  am_sqlite3_statement_free(am_sqlite3_stmt* );
+extern VALUE am_sqlite3_statement_sql(VALUE self);
+extern VALUE am_sqlite3_statement_close(VALUE self);
+extern VALUE am_sqlite3_statement_step(VALUE self);
+extern VALUE am_sqlite3_statement_column_count(VALUE self);
+extern VALUE am_sqlite3_statement_column_name(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_decltype(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_type(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_blob(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_text(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_int(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_int64(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_double(VALUE self, VALUE index);
+
+extern VALUE am_sqlite3_statement_column_database_name(VALUE self, VALUE position);
+extern VALUE am_sqlite3_statement_column_table_name(VALUE self, VALUE position);
+extern VALUE am_sqlite3_statement_column_origin_name(VALUE self, VALUE position);
+
+extern VALUE am_sqlite3_statement_reset(VALUE self);
+extern VALUE am_sqlite3_statement_clear_bindings(VALUE self);
+extern VALUE am_sqlite3_statement_bind_parameter_count(VALUE self);
+extern VALUE am_sqlite3_statement_bind_parameter_index(VALUE self, VALUE parameter_name);
+extern VALUE am_sqlite3_statement_remaining_sql(VALUE self);
+extern VALUE am_sqlite3_statement_bind_text(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_blob(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_zeroblob(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_int(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_int64(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_double(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_null(VALUE self, VALUE position);
+
+/*----------------------------------------------------------------------
+ * Prototype for Amalgalite::SQLite3::Blob
+ *---------------------------------------------------------------------*/
+extern VALUE cAS_Blob; /* class Amalgalite::SQLite3::Blob */
+
+extern VALUE am_sqlite3_blob_alloc(VALUE klass);
+extern VALUE am_sqlite3_blob_initialize( VALUE self, VALUE db, VALUE db_name, VALUE table_name, VALUE column_name, VALUE rowid, VALUE flag) ;
+extern void  am_sqlite3_blob_free(am_sqlite3_blob* );
+extern VALUE am_sqlite3_blob_read(VALUE self, VALUE length);
+extern VALUE am_sqlite3_blob_write(VALUE self, VALUE buffer);
+extern VALUE am_sqlite3_blob_close(VALUE self);
+extern VALUE am_sqlite3_blob_length(VALUE self);
+
+/*----------------------------------------------------------------------
+ * more initialization methods
+ *----------------------------------------------------------------------*/
+extern void Init_amalgalite3_constants( );
+extern void Init_amalgalite3_database( );
+extern void Init_amalgalite3_statement( );
+extern void Init_amalgalite3_blob( );
+extern void Init_amalgalite3_requires_bootstrap( );
+
+ 
+/***********************************************************************
+ * Type conversion macros between sqlite data types and ruby types
+ **********************************************************************/
+
+#define SQLINT64_2NUM(x)      ( LL2NUM( x ) )
+#define SQLUINT64_2NUM(x)     ( ULL2NUM( x ) )
+#define NUM2SQLINT64( obj )   ( NUM2LL( obj ) )
+#define NUM2SQLUINT64( obj )  ( NUM2ULL( obj ) )
+
+/***********************************************************************
+ * return the last exception in ruby's error message
+ */
+#define ERROR_INFO_MESSAGE()  ( rb_obj_as_string( rb_gv_get("$!") ) )
+#endif

data/ext/amalgalite/amalgalite3_blob.c

@@ -0,0 +1,240 @@
+#include "amalgalite3.h"
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+/* class  Amalgliate::SQLite3::Blob */
+VALUE cAS_Blob;   
+
+/**
+ * call-seq:
+ *   Blob.new( database, table_name, column_name, row_id, flag ) -> Blob
+ *
+ * Create a new Blob object and associate it with the approriate, database,
+ * table, column and row.  +flag+ indicates if the Blob is to be opened for
+ * writing "w" or reading "r".
+ *
+ */
+VALUE am_sqlite3_blob_initialize( VALUE self, VALUE db, VALUE db_name, VALUE table_name, VALUE column_name, VALUE rowid, VALUE flag) 
+{
+    am_sqlite3_blob *am_blob;
+    int              rc;
+    am_sqlite3      *am_db;
+    char            *zDb      = StringValuePtr( db_name );
+    char            *zTable   = StringValuePtr( table_name );
+    char            *zColumn  = StringValuePtr( column_name );
+    sqlite3_int64    iRow     = NUM2SQLINT64( rowid )  ;
+    VALUE            flag_str = StringValue( flag );
+    int              flags    = 0;
+
+    /* extract the blob struct */
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+    
+    /* extract the sqlite3 db struct */
+    Data_Get_Struct(db, am_sqlite3, am_db);
+
+    /* make sure that the flags are valid, only 'r' or 'w' are allowed */
+    if ( ( RSTRING_LEN( flag_str ) != 1) || 
+         ( ( 'r' != RSTRING_PTR( flag_str )[0] ) && 
+           ( 'w' != RSTRING_PTR( flag_str )[0] ))) {
+        rb_raise( eAS_Error, "Error opening Blob in db = %s, table = %s, column = %s, rowid = %lu.  Invalid flag '%s'.  Must be either 'w' or 'r'\n",
+                             zDb, zTable, zColumn, (unsigned long)iRow, RSTRING_PTR( flag_str ));
+    }
+
+    /* switch to write mode */
+    if ( 'w' == RSTRING_PTR( flag_str )[0] ) { 
+        flags = 1;
+    }
+
+    /* open the blob and associate the db to it */
+    rc = sqlite3_blob_open( am_db->db, zDb, zTable, zColumn, iRow, flags, &( am_blob->blob ) );
+    if ( SQLITE_OK != rc ) {
+        rb_raise( eAS_Error, "Error opening Blob in db = %s, table = %s, column = %s, rowid = %lu : [SQLITE_ERROR %d] %s\n", zDb, zTable, zColumn, (unsigned long)iRow, rc, sqlite3_errmsg( am_db->db) );  
+    }
+    am_blob->length = sqlite3_blob_bytes( am_blob->blob );
+    am_blob->db = am_db->db;
+
+    /* if a block is given then yield self and close the blob when done */
+    if ( rb_block_given_p() ) {
+        rb_yield( self );
+        am_sqlite3_blob_close( self );
+        return Qnil;
+    } else {
+        return self;
+    }
+}
+
+/**
+ * call-seq:
+ *  blob.close -> nil
+ *
+ * Closes the blob.
+ */
+VALUE am_sqlite3_blob_close( VALUE self )
+{
+    am_sqlite3_blob *am_blob;
+    int              rc;
+    
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+    rc = sqlite3_blob_close( am_blob->blob );
+    if ( SQLITE_OK != rc ) {
+        rb_raise(eAS_Error, "Error closing blob: [SQLITE_ERROR %d] %s\n",
+                rc, sqlite3_errmsg( am_blob->db ));
+    }
+
+
+    return Qnil;
+}
+
+
+/**
+ * call-seq:
+ *  blob.length -> length in bytes of the blob
+ *
+ * Returns the number of bytes in the blob.
+ */
+VALUE am_sqlite3_blob_length( VALUE self )
+{
+    am_sqlite3_blob *am_blob;
+
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+
+    return INT2FIX( am_blob->length );
+}
+
+/**
+ * call-seq:
+ *   blob.read( int ) -> String containting int number of  bytes or nil if eof.
+ *
+ * returns int number of bytes as a String from the database
+ */
+VALUE am_sqlite3_blob_read( VALUE self, VALUE length )
+{
+    am_sqlite3_blob *am_blob;
+    int             rc;
+    int              n = NUM2INT( length );
+    void           *buf = NULL;
+    VALUE          result;
+
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+
+    /* we have to be exact on the number of bytes to read.  n + current_offset
+     * cannot be larger than the blob's length
+     */
+    if ( (n + am_blob->current_offset > am_blob->length)) {
+        n = am_blob->length - am_blob->current_offset;
+    }
+
+    if ( am_blob->current_offset == am_blob->length ) {
+        return Qnil;
+    }
+
+    buf = (void *)malloc( n );
+    rc = sqlite3_blob_read( am_blob->blob, buf, n, am_blob->current_offset); 
+
+    if ( rc != SQLITE_OK ) {
+        rb_raise(eAS_Error, "Error reading %d bytes blob at offset %d: [SQLITE_ERROR %d] %s\n",
+                n, am_blob->current_offset, rc, sqlite3_errmsg( am_blob->db ));
+    }
+
+    am_blob->current_offset += n;
+
+    result = rb_str_new( (char*)buf, n );
+    free( buf );
+    return result;
+
+}
+
+/**
+ * call-seq:
+ *   blob.write( buf ) -> int
+ *
+ * writes the contents of the string buffer to the blob and returns the number
+ * of bytes written.
+ *
+ */
+VALUE am_sqlite3_blob_write( VALUE self, VALUE buf )
+{
+    am_sqlite3_blob *am_blob;
+    int              rc;
+    VALUE            str = StringValue( buf );
+    int              n   = RSTRING_LEN( str );
+    char            *chk_buf = NULL;
+
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+
+    rc = sqlite3_blob_write( am_blob->blob, RSTRING_PTR(str), n, am_blob->current_offset); 
+
+    if ( rc  != SQLITE_OK ) {
+        rb_raise(eAS_Error, "Error writing %d bytes blob at offset %d: [SQLITE_ERROR %d] %s\n",
+                n, am_blob->current_offset, rc, sqlite3_errmsg( am_blob->db ));
+    }
+
+    chk_buf = (char *) malloc( n  + 1);
+    chk_buf[n] = '\0';
+    sqlite3_blob_read( am_blob->blob, chk_buf, n, 0);
+
+    am_blob->current_offset += n;
+
+    return INT2FIX( n );
+
+}
+
+
+/***********************************************************************
+ * Ruby life cycle methods
+ ***********************************************************************/
+
+/*
+ * garbage collector free method for the am_sqlite3_blob structure
+ */
+void am_sqlite3_blob_free(am_sqlite3_blob* wrapper)
+{
+    free(wrapper);
+    return;
+}
+
+/*
+ * allocate the am_blob structure
+ */
+VALUE am_sqlite3_blob_alloc(VALUE klass)
+{
+    am_sqlite3_blob  *wrapper = ALLOC( am_sqlite3_blob );
+    VALUE             obj     ; 
+
+    wrapper->current_offset = 0;
+    wrapper->db             = NULL;
+    obj = Data_Wrap_Struct(klass, NULL, am_sqlite3_blob_free, wrapper);
+    return obj;
+}
+
+
+/**
+ * Document-class: Amalgalite::SQLite3::Blob
+ *
+ * The Blob class enables incremental IO on blob items.  If you do not need
+ * incremental IO on a binary object, then you do not need to use Blob.
+ */
+
+void Init_amalgalite3_blob( )
+{
+
+    VALUE ma  = rb_define_module("Amalgalite");
+    VALUE mas = rb_define_module_under(ma, "SQLite3");
+
+    /*
+     * Encapsulate the SQLite3 Statement handle in a class
+     */
+    cAS_Blob = rb_define_class_under( mas, "Blob", rb_cObject ); 
+    rb_define_alloc_func(cAS_Blob, am_sqlite3_blob_alloc); 
+    rb_define_method(cAS_Blob, "initialize", am_sqlite3_blob_initialize, 6); 
+    rb_define_method(cAS_Blob, "close", am_sqlite3_blob_close, 0); 
+    rb_define_method(cAS_Blob, "read", am_sqlite3_blob_read, 1); 
+    rb_define_method(cAS_Blob, "write", am_sqlite3_blob_write, 1); 
+    rb_define_method(cAS_Blob, "length", am_sqlite3_blob_length, 0); 
+}
+
+

data/ext/amalgalite/amalgalite3_constants.c

@@ -0,0 +1,221 @@
+/* Generated by gen_constants.rb -- do not edit */
+
+#include "amalgalite3.h"
+/**
+ * Document-class: Amalgalite::SQLite3::Constants
+ *
+ * class holding constants in the sqlite extension
+ */
+void Init_amalgalite3_constants( )
+{
+
+    VALUE ma  = rb_define_module("Amalgalite");
+    VALUE mas = rb_define_module_under(ma, "SQLite3");
+
+    /*
+     * module encapsulating all the SQLite C extension constants 
+     */
+    VALUE mC = rb_define_module_under( mas, "Constants");
+    /**
+     * module encapsulating the SQLite3 C extension constants for DBStatus 
+     */
+    VALUE mC_DBStatus = rb_define_module_under(mC, "DBStatus");
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "LOOKASIDE_USED", INT2FIX(SQLITE_DBSTATUS_LOOKASIDE_USED));
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for DataType 
+     */
+    VALUE mC_DataType = rb_define_module_under(mC, "DataType");
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "BLOB", INT2FIX(SQLITE_BLOB));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "FLOAT", INT2FIX(SQLITE_FLOAT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "INTEGER", INT2FIX(SQLITE_INTEGER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "NULL", INT2FIX(SQLITE_NULL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "TEXT", INT2FIX(SQLITE_TEXT));
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Open 
+     */
+    VALUE mC_Open = rb_define_module_under(mC, "Open");
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Open, "CREATE", INT2FIX(SQLITE_OPEN_CREATE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Open, "READONLY", INT2FIX(SQLITE_OPEN_READONLY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Open, "READWRITE", INT2FIX(SQLITE_OPEN_READWRITE));
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for ResultCode 
+     */
+    VALUE mC_ResultCode = rb_define_module_under(mC, "ResultCode");
+
+    /*  4 -- Callback routine requested an abort */
+    rb_define_const(mC_ResultCode, "ABORT", INT2FIX(SQLITE_ABORT));
+
+    /*  23 -- Authorization denied */
+    rb_define_const(mC_ResultCode, "AUTH", INT2FIX(SQLITE_AUTH));
+
+    /*  5 -- The database file is locked */
+    rb_define_const(mC_ResultCode, "BUSY", INT2FIX(SQLITE_BUSY));
+
+    /*  14 -- Unable to open the database file */
+    rb_define_const(mC_ResultCode, "CANTOPEN", INT2FIX(SQLITE_CANTOPEN));
+
+    /*  19 -- Abort due to constraint violation */
+    rb_define_const(mC_ResultCode, "CONSTRAINT", INT2FIX(SQLITE_CONSTRAINT));
+
+    /*  11 -- The database disk image is malformed */
+    rb_define_const(mC_ResultCode, "CORRUPT", INT2FIX(SQLITE_CORRUPT));
+
+    /*  101 -- sqlite3_step() has finished executing */
+    rb_define_const(mC_ResultCode, "DONE", INT2FIX(SQLITE_DONE));
+
+    /*  16 -- Database is empty */
+    rb_define_const(mC_ResultCode, "EMPTY", INT2FIX(SQLITE_EMPTY));
+
+    /*  1 -- SQL error or missing database */
+    rb_define_const(mC_ResultCode, "ERROR", INT2FIX(SQLITE_ERROR));
+
+    /*  24 -- Auxiliary database format error */
+    rb_define_const(mC_ResultCode, "FORMAT", INT2FIX(SQLITE_FORMAT));
+
+    /*  13 -- Insertion failed because database is full */
+    rb_define_const(mC_ResultCode, "FULL", INT2FIX(SQLITE_FULL));
+
+    /*  2 -- Internal logic error in SQLite */
+    rb_define_const(mC_ResultCode, "INTERNAL", INT2FIX(SQLITE_INTERNAL));
+
+    /*  9 -- Operation terminated by sqlite3_interrupt() */
+    rb_define_const(mC_ResultCode, "INTERRUPT", INT2FIX(SQLITE_INTERRUPT));
+
+    /*  10 -- Some kind of disk I/O error occurred */
+    rb_define_const(mC_ResultCode, "IOERR", INT2FIX(SQLITE_IOERR));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_BLOCKED", INT2FIX(SQLITE_IOERR_BLOCKED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_DELETE", INT2FIX(SQLITE_IOERR_DELETE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_DIR_FSYNC", INT2FIX(SQLITE_IOERR_DIR_FSYNC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_FSTAT", INT2FIX(SQLITE_IOERR_FSTAT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_FSYNC", INT2FIX(SQLITE_IOERR_FSYNC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_NOMEM", INT2FIX(SQLITE_IOERR_NOMEM));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_RDLOCK", INT2FIX(SQLITE_IOERR_RDLOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_READ", INT2FIX(SQLITE_IOERR_READ));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_SHORT_READ", INT2FIX(SQLITE_IOERR_SHORT_READ));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_TRUNCATE", INT2FIX(SQLITE_IOERR_TRUNCATE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_UNLOCK", INT2FIX(SQLITE_IOERR_UNLOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_WRITE", INT2FIX(SQLITE_IOERR_WRITE));
+
+    /*  6 -- A table in the database is locked */
+    rb_define_const(mC_ResultCode, "LOCKED", INT2FIX(SQLITE_LOCKED));
+
+    /*  20 -- Data type mismatch */
+    rb_define_const(mC_ResultCode, "MISMATCH", INT2FIX(SQLITE_MISMATCH));
+
+    /*  21 -- Library used incorrectly */
+    rb_define_const(mC_ResultCode, "MISUSE", INT2FIX(SQLITE_MISUSE));
+
+    /*  22 -- Uses OS features not supported on host */
+    rb_define_const(mC_ResultCode, "NOLFS", INT2FIX(SQLITE_NOLFS));
+
+    /*  7 -- A malloc() failed */
+    rb_define_const(mC_ResultCode, "NOMEM", INT2FIX(SQLITE_NOMEM));
+
+    /*  26 -- File opened that is not a database file */
+    rb_define_const(mC_ResultCode, "NOTADB", INT2FIX(SQLITE_NOTADB));
+
+    /*  12 -- NOT USED. Table or record not found */
+    rb_define_const(mC_ResultCode, "NOTFOUND", INT2FIX(SQLITE_NOTFOUND));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "OK", INT2FIX(SQLITE_OK));
+
+    /*  3 -- Access permission denied */
+    rb_define_const(mC_ResultCode, "PERM", INT2FIX(SQLITE_PERM));
+
+    /*  15 -- NOT USED. Database lock protocol error */
+    rb_define_const(mC_ResultCode, "PROTOCOL", INT2FIX(SQLITE_PROTOCOL));
+
+    /*  25 -- 2nd parameter to sqlite3_bind out of range */
+    rb_define_const(mC_ResultCode, "RANGE", INT2FIX(SQLITE_RANGE));
+
+    /*  8 -- Attempt to write a readonly database */
+    rb_define_const(mC_ResultCode, "READONLY", INT2FIX(SQLITE_READONLY));
+
+    /*  100 -- sqlite3_step() has another row ready */
+    rb_define_const(mC_ResultCode, "ROW", INT2FIX(SQLITE_ROW));
+
+    /*  17 -- The database schema changed */
+    rb_define_const(mC_ResultCode, "SCHEMA", INT2FIX(SQLITE_SCHEMA));
+
+    /*  18 -- String or BLOB exceeds size limit */
+    rb_define_const(mC_ResultCode, "TOOBIG", INT2FIX(SQLITE_TOOBIG));
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Status 
+     */
+    VALUE mC_Status = rb_define_module_under(mC, "Status");
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "MALLOC_SIZE", INT2FIX(SQLITE_STATUS_MALLOC_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "MEMORY_USED", INT2FIX(SQLITE_STATUS_MEMORY_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PAGECACHE_OVERFLOW", INT2FIX(SQLITE_STATUS_PAGECACHE_OVERFLOW));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PAGECACHE_SIZE", INT2FIX(SQLITE_STATUS_PAGECACHE_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PAGECACHE_USED", INT2FIX(SQLITE_STATUS_PAGECACHE_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PARSER_STACK", INT2FIX(SQLITE_STATUS_PARSER_STACK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "SCRATCH_OVERFLOW", INT2FIX(SQLITE_STATUS_SCRATCH_OVERFLOW));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "SCRATCH_SIZE", INT2FIX(SQLITE_STATUS_SCRATCH_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "SCRATCH_USED", INT2FIX(SQLITE_STATUS_SCRATCH_USED));
+
+}