amalgalite 0.2.4 → 0.4.0

data/examples/requires.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+#
+# An Amalgalite example showing how to 'require' data in an amalgalite database
+#
+# We'll make a database with one table, that we store file contents in.
+#
+
+$: << "../lib"
+$: << "../ext"
+require 'rubygems'
+require 'amalgalite'
+
+#
+# create the database 
+#
+File.unlink( "lib.db" ) if File.exist?( "lib.db" )
+db = Amalgalite::Database.new( "lib.db" )
+STDERR.puts "Creating rubylibs table"
+db.execute(<<-create)
+CREATE TABLE rubylibs(
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  filename  VARCHAR UNIQUE,
+  contents  TEXT
+)
+create
+
+
+#
+# insert some source code into a row
+#
+db.execute("INSERT INTO rubylibs(filename, contents) VALUES ( $filename, $contents )",
+           { "$filename" => "example",
+             "$contents" => <<code 
+class ExampleCode
+  def initialize( x )
+    puts "Initializing ExampleCode"
+    @x = x
+  end
+  
+  def foo
+   puts @x
+  end
+end
+code
+})
+db.close
+
+require 'amalgalite/requires'
+Amalgalite::Requires.new( :dbfile_name => "lib.db" )
+require 'example'
+e = ExampleCode.new( 'it works!' )
+e.foo
+                            

data/examples/schema-info.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'amalgalite'
+
+db_name = ARGV.shift
+unless db_name 
+  puts "Usage: #{File.basename($0)} dbname" 
+  exit 1
+end
+db = Amalgalite::Database.new( db_name )
+col_info = %w[ default_value declared_data_type collation_sequence_name not_null_constraint primary_key auto_increment ]
+max_width = col_info.collect { |c| c.length }.sort.last
+
+db.schema.tables.keys.sort.each do |table_name|
+  puts "Table: #{table_name}"
+  puts "=" * 42
+  db.schema.tables[table_name].columns.each_pair do |col_name, col|
+    puts "  Column : #{col.name}"
+    col_info.each do |ci|
+      puts "    |#{ci.rjust( max_width, "." )} : #{col.send( ci )}"
+    end
+    puts 
+  end
+
+  db.schema.tables[table_name].indexes.each_pair do |idx_name, index|
+    puts "  Index : #{index.name}"
+    puts "    |#{"sequence_number".rjust( max_width, "." )} : #{index.sequence_number}"
+    puts "    |#{"is unique?".rjust( max_width, ".")} : #{index.unique?}"
+    puts "    |#{"columns".rjust( max_width, ".")} : #{index.columns.collect { |c| c.name }.join(',') }"
+    puts
+  end
+end
+

data/ext/amalgalite3.c

@@ -12,6 +12,7 @@ VALUE mA;              /* module Amalgalite                     */
 VALUE mAS;             /* module Amalgalite::SQLite3            */
 VALUE mASV;            /* module Amalgalite::SQLite3::Version   */
 VALUE eAS_Error;       /* class  Amalgalite::SQLite3::Error     */
+VALUE cAS_Stat;        /* class  Amalgalite::SQLite3::Stat      */
 
 /*----------------------------------------------------------------------
  * module methods for Amalgalite::SQLite3
@@ -69,39 +70,40 @@ VALUE am_sqlite3_complete(VALUE self, VALUE args)
 
 /*
  * call-seq:
- *    Amalgalite::SQLite3.memory_used -> Numeric
+ *    Amalgalite::SQLite3::Stat.update!( reset = false ) -> nil
  *
- * Return the number of bytes of memory outstanding in the SQLite extension
- */
-VALUE am_sqlite3_memory_used(VALUE self)
-{
-    return SQLINT64_2NUM(sqlite3_memory_used());
-}
-
-/*
- * call-seq:
- *    Amalgalite::SQLite3.memory_highwater_mark -> Numeric
- *
- * Return the maximum value of Amalgalite::SQLite3.memory_used since the last
- * time the highwater mark was reset.
+ * Populates the _@current_ and _@higwater_ instance variables of self
+ * object with the values from the sqlite3_status call.  If reset it true then
+ * the highwater mark for the stat is reset
  *
  */
-VALUE am_sqlite3_memory_highwater(VALUE self)
+VALUE am_sqlite3_stat_update_bang( int argc, VALUE *argv, VALUE self )
 {
-    return SQLINT64_2NUM(sqlite3_memory_highwater(0));
-}
+    int status_op  = -1;
+    int current    = -1;
+    int highwater  = -1;
+    VALUE reset    = Qfalse;
+    int reset_flag = 0;
+    int rc;
+
+    status_op  = FIX2INT( rb_iv_get( self, "@code" ) );
+    if ( argc > 0 ) {
+        reset = argv[0];
+        reset_flag = ( Qtrue == reset ) ? 1 : 0 ;
+    }
 
-/*
- * call-seq:
- *    Amalgalite::SQLite3.memory_highwater_mark_reset! 
- *
- * Reset the memory highwater mark.  The highwater mark becomes the current
- * value of memory_used.
- *
- */
-VALUE am_sqlite3_memory_highwater_reset(VALUE self)
-{
-    return SQLINT64_2NUM(sqlite3_memory_highwater(1));
+    rc = sqlite3_status( status_op, &current, &highwater, reset_flag );
+
+    if ( SQLITE_OK != rc ) {
+        VALUE n    = rb_iv_get( self,  "@name" ) ;
+        char* name = StringValuePtr( n );
+        rb_raise(eAS_Error, "Failure to retrieve status for %s : [SQLITE_ERROR %d] \n", name, rc);
+    }
+
+    rb_iv_set( self, "@current", INT2NUM( current ) );
+    rb_iv_set( self, "@highwater", INT2NUM( highwater) );
+
+    return Qnil;
 }
 
 /*
@@ -148,6 +150,9 @@ VALUE am_sqlite3_libversion_number(VALUE self)
     return INT2FIX(sqlite3_libversion_number());
 }
 
+/**
+ * The Amalgalite ruby extension
+ */
 
 void Init_amalgalite3()
 {
@@ -162,11 +167,14 @@ void Init_amalgalite3()
     mAS  = rb_define_module_under(mA, "SQLite3");
     rb_define_module_function(mAS, "threadsafe?", am_sqlite3_threadsafe, 0);
     rb_define_module_function(mAS, "complete?", am_sqlite3_complete, -2);
-    rb_define_module_function(mAS, "memory_used", am_sqlite3_memory_used,0);
-    rb_define_module_function(mAS, "memory_highwater_mark", am_sqlite3_memory_highwater,0);
-    rb_define_module_function(mAS, "memory_highwater_mark_reset!", am_sqlite3_memory_highwater_reset,0);
     rb_define_module_function(mAS, "randomness", am_sqlite3_randomness,1);
 
+    /*
+     * class encapsulating a single Stat
+     */
+    cAS_Stat = rb_define_class_under(mAS, "Stat", rb_cObject);
+    rb_define_method(cAS_Stat, "update!", am_sqlite3_stat_update_bang, -1);
+
     /* 
      * Base class of all SQLite3 errors
      */
@@ -186,6 +194,7 @@ void Init_amalgalite3()
     Init_amalgalite3_database( );
     Init_amalgalite3_statement( );
     Init_amalgalite3_blob( );
+    Init_amalgalite3_requires_bootstrap( );
 
  }
 

data/ext/amalgalite3_blob.c

@@ -39,8 +39,8 @@ VALUE am_sqlite3_blob_initialize( VALUE self, VALUE db, VALUE db_name, VALUE tab
     if ( ( RSTRING( flag_str )->len != 1) || 
          ( ( 'r' != RSTRING( flag_str )->ptr[0] ) && 
            ( 'w' != RSTRING( flag_str )->ptr[0] ))) {
-        rb_raise( eAS_Error, "Error opening Blob in db = %s, table = %s, column = %s, rowid = %d.  Invalid flag '%s'.  Must be either 'w' or 'r'\n",
-                             zDb, zTable, zColumn, iRow, RSTRING( flag_str )->ptr);
+        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( flag_str )->ptr);
     }
 
     /* switch to write mode */
@@ -49,10 +49,9 @@ VALUE am_sqlite3_blob_initialize( VALUE self, VALUE db, VALUE db_name, VALUE tab
     }
 
     /* 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 ( rc != SQLITE_OK ) {
-        rb_raise( eAS_Error, "Error opening Blob in db = %s, table = %s, column = %s, rowid = %ld  : [SQLITE_ERROR %d] %s\n", 
-                  zDb, zTable, zColumn, iRow, rc, sqlite3_errmsg( am_db->db ));
+    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;
@@ -203,8 +202,8 @@ void am_sqlite3_blob_free(am_sqlite3_blob* wrapper)
  */
 VALUE am_sqlite3_blob_alloc(VALUE klass)
 {
-    am_sqlite3_blob  *wrapper = ALLOC(am_sqlite3_blob);
-    VALUE             obj     = (VALUE)NULL;
+    am_sqlite3_blob  *wrapper = ALLOC( am_sqlite3_blob );
+    VALUE             obj     ; 
 
     wrapper->current_offset = 0;
     wrapper->db             = NULL;
@@ -216,10 +215,6 @@ VALUE am_sqlite3_blob_alloc(VALUE klass)
 void Init_amalgalite3_blob( )
 {
 
-    /** :stopdoc:
-     * These calls are here just to allow for rdoc generation
-     * :startdoc:
-     */
     VALUE ma  = rb_define_module("Amalgalite");
     VALUE mas = rb_define_module_under(ma, "SQLite3");
 

data/ext/amalgalite3_constants.c

@@ -3,10 +3,7 @@
 #include "amalgalite3.h";
 void Init_amalgalite3_constants( )
 {
-    /** :stopdoc:
-     * These calls are here just to allow for rdoc generation
-     * :startdoc:
-     */
+
     VALUE ma  = rb_define_module("Amalgalite");
     VALUE mas = rb_define_module_under(ma, "SQLite3");
 
@@ -14,6 +11,14 @@ void Init_amalgalite3_constants( )
      * 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 
      */
@@ -176,4 +181,36 @@ void Init_amalgalite3_constants( )
     /*  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));
+
 }

data/ext/amalgalite3_database.c

@@ -6,7 +6,8 @@
  * vim: shiftwidth=4 
  */ 
 
-VALUE cAS_Database;    /* class  Amalgliate::SQLite3::Database  */
+VALUE cAS_Database;       /* class  Amalgliate::SQLite3::Database        */
+VALUE cAS_Database_Stat;  /* class  Amalgliate::SQLite3::Database::Stat  */
 
 /**
  * Document-method: open
@@ -218,6 +219,50 @@ VALUE am_sqlite3_database_total_changes(VALUE self)
     return INT2FIX(rc);
 }
 
+/*
+ * call-seq:
+ *    stat.update!(  reset = false ) -> nil
+ *
+ * Populates the _@current_ and _@higwater_ instance variables of the given 
+ * Database Stat object with the values from the sqlite3_db_status call.  
+ * If reset it true then the highwater mark for the stat is reset
+ *
+ */
+VALUE am_sqlite3_database_stat_update_bang( int argc, VALUE *argv, VALUE self )
+{
+    int current    = -1;
+    int highwater  = -1;
+    int reset_flag = 0;
+    int status_op  = FIX2INT( rb_iv_get( self, "@code" ) );
+    int rc;
+
+    am_sqlite3    *am_db;
+
+    VALUE reset    = Qfalse;
+    VALUE db       = rb_iv_get( self, "@api_db" );
+
+    Data_Get_Struct(db, am_sqlite3, am_db);
+
+    if ( argc > 0 ) {
+        reset = argv[0];
+        reset_flag = ( Qtrue == reset ) ? 1 : 0 ;
+    }
+
+    rc = sqlite3_db_status( am_db->db, status_op, &current, &highwater, reset_flag );
+
+    if ( SQLITE_OK != rc ) {
+        VALUE n    = rb_iv_get( self, "@name");
+        char* name = StringValuePtr( n );
+        rb_raise(eAS_Error, "Failure to retrieve database status for %s : [SQLITE_ERROR %d] \n", name, rc);
+    }
+
+    rb_iv_set( self, "@current", INT2NUM( current ) );
+    rb_iv_set( self, "@highwater", INT2NUM( highwater) );
+
+    return Qnil;
+}
+
+
 
 /**
  * call-seq:
@@ -463,13 +508,12 @@ VALUE am_sqlite3_database_alloc(VALUE klass)
     return obj;
 }
 
+/**
+ * Amalgalite Database 
+ */
 void Init_amalgalite3_database( )
 {
     
-    /** :stopdoc:
-     * These calls are here just to allow for rdoc generation
-     * :startdoc:
-     */
     VALUE ma  = rb_define_module("Amalgalite");
     VALUE mas = rb_define_module_under(ma, "SQLite3");
   
@@ -493,5 +537,11 @@ void Init_amalgalite3_database( )
     rb_define_method(cAS_Database, "last_error_code", am_sqlite3_database_last_error_code, 0); /* in amalgalite3_database.c */
     rb_define_method(cAS_Database, "last_error_message", am_sqlite3_database_last_error_message, 0); /* in amalgalite3_database.c */
 
+    /*
+     * Ecapuslate a SQLite3 Database stat
+     */
+    cAS_Database_Stat = rb_define_class_under( cAS_Database, "Stat", rb_cObject );
+    rb_define_method(cAS_Database_Stat, "update!", am_sqlite3_database_stat_update_bang, -1); /* in amalgalite3_database.c */
+
 }
 

data/ext/amalgalite3_requires_bootstrap.c

@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#include "amalgalite3.h"
+extern VALUE mA;
+static VALUE cAR;
+static VALUE cARB;
+static VALUE eARB_Error;
+
+/* 
+ * cleanup the datatbase and statment values if they are currently open and then
+ * raise the message.  It converts the error message to a String so that the C
+ * string can be free'd and then raise with a ruby object in the hopes that
+ * there is no memory leak from the C allocation.
+ */
+void am_bootstrap_cleanup_and_raise( char* msg, sqlite3* db, sqlite3_stmt* stmt )
+{
+    VALUE msg_obj = rb_str_new2( msg );
+
+    if ( NULL != stmt ) { sqlite3_finalize( stmt ); }
+    if ( NULL != db   ) { sqlite3_close( db ); }
+
+    free( msg );
+    rb_raise(eARB_Error, msg );
+}
+
+
+/**
+ * call-seq:
+ *   Amalgalite::Requires::Bootstrap.lift( 'dbfile' => "lib.db", 'table_name' => "bootload", 'rowid_column' => "id", 'filename_column' => "filename",  'content_column' => "contents" )
+ *
+ * *WARNING* *WARNING* *WARNING* *WARNING* *WARNING* *WARNING* *WARNING*
+ *
+ * This is a boostrap mechanism to eval all the code in a particular column in a
+ * specially formatted table in an sqlite database.  It should only be used for
+ * a specific purpose, mainly loading the Amalgalite ruby code directly from an
+ * sqlite table.  
+ *
+ * Amalgalite::Requires adds in the ability to _require_ code that is in an
+ * sqlite database.  Since Amalgalite::Requires is itself ruby code, if
+ * Amalgalite::Requires was in an sqlite database, it could not _require_
+ * itself.  Therefore this method is made available.  It is a pure C extension
+ * method that directly calls the sqlite3 C functions directly and uses the ruby
+ * C api to eval the data in the table.
+ *
+ * This method attaches to an sqlite3 database (filename) and then does:
+ *
+ *     SELECT filename_column_name, content_column_name 
+ *       FROM table_name
+ *   ORDER BY rowid_column_name
+ *
+ * For each row returned it does an _eval_ on the code in the
+ * *content_column_name* and then updates _$"_ directly with the value from
+ * *filename_column_name*.
+ *
+ * The database to be opened by _lift_ *must* be an sqlite3 UTF-8 database.
+ *
+ */
+VALUE am_bootstrap_lift( VALUE self, VALUE args )
+{
+    sqlite3*        db = NULL;
+    sqlite3_stmt* stmt = NULL;
+    int             rc;
+    int  last_row_good; 
+    char*    raise_msg = NULL;
+
+    VALUE     am_db_c  = rb_const_get( cARB, rb_intern("DEFAULT_DB") );
+    VALUE    am_tbl_c  = rb_const_get( cARB, rb_intern("DEFAULT_TABLE") );
+    VALUE     am_pk_c  = rb_const_get( cARB, rb_intern("DEFAULT_ROWID_COLUMN") );
+    VALUE  am_fname_c  = rb_const_get( cARB, rb_intern("DEFAULT_FILENAME_COLUMN") );
+    VALUE am_content_c = rb_const_get( cARB, rb_intern("DEFAULT_CONTENTS_COLUMN") );
+
+    char*     dbfile = NULL;
+    char*    tbl_name = NULL;
+    char*      pk_col = NULL;
+    char*   fname_col = NULL;
+    char* content_col = NULL;
+
+    char*            sql = NULL;
+    const char* sql_tail = NULL;
+    int        sql_bytes = 0;
+    
+    const unsigned char* result_text = NULL;
+    int                result_length = 0;
+
+    VALUE     require_name = Qnil;  /* ruby string of the file name for use in eval */
+    VALUE   eval_this_code = Qnil;  /* ruby string of the code to eval from the db  */
+    VALUE toplevel_binding = rb_const_get( rb_cObject, rb_intern("TOPLEVEL_BINDING") ) ;
+    VALUE    sqlite_errmsg = Qnil;
+    VALUE              tmp = Qnil;
+
+    ID             eval_id = rb_intern("eval");
+
+
+    if (   Qnil == args  ) {
+        args = rb_hash_new();
+    } else {
+        args = rb_ary_shift( args );
+    }
+
+    Check_Type( args, T_HASH );
+    
+    /* get the arguments */
+    dbfile      = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "dbfile"          ) ) ) ) ? StringValuePtr( am_db_c )      : StringValuePtr( tmp );
+    tbl_name    = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "table_name"      ) ) ) ) ? StringValuePtr( am_tbl_c )     : StringValuePtr( tmp );
+    pk_col      = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "rowid_column"    ) ) ) ) ? StringValuePtr( am_pk_c )      : StringValuePtr( tmp );
+    fname_col   = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "filename_column" ) ) ) ) ? StringValuePtr( am_fname_c )   : StringValuePtr( tmp );
+    content_col = ( Qnil == (tmp = rb_hash_aref( args, rb_str_new2( "contents_column" ) ) ) ) ? StringValuePtr( am_content_c ) : StringValuePtr( tmp );
+
+
+    /* open the database */
+    rc = sqlite3_open_v2( dbfile , &db, SQLITE_OPEN_READONLY, NULL);
+    if ( SQLITE_OK != rc ) {
+        asprintf(&raise_msg,"Failure to open database %s for bootload: [SQLITE_ERROR %d] : %s", dbfile, rc, sqlite3_errmsg( db ) );
+        am_bootstrap_cleanup_and_raise( raise_msg, db, stmt );
+    }
+
+    /* prepare the db query */
+    sql_bytes = asprintf( &sql, "SELECT %s, %s FROM %s ORDER BY %s", fname_col, content_col, tbl_name, pk_col );
+    rc = sqlite3_prepare_v2( db, sql, sql_bytes, &stmt, &sql_tail ) ;
+    free( sql );
+    if ( SQLITE_OK != rc) {
+        asprintf( &raise_msg, 
+                  "Failure to prepare bootload select statement table = '%s', rowid col = '%s', filename col ='%s', contents col = '%s' : [SQLITE_ERROR %d] %s\n",
+                  tbl_name, pk_col, fname_col, content_col, rc, sqlite3_errmsg( db ));
+        am_bootstrap_cleanup_and_raise( raise_msg, db, stmt );
+    }
+
+    /* loop over the resulting rows, eval'ing and loading $" */
+    last_row_good = -1;
+    while ( SQLITE_ROW == ( rc = sqlite3_step( stmt ) ) ) {
+        /* file name */
+        result_text   = sqlite3_column_text( stmt, 0 );
+        result_length = sqlite3_column_bytes( stmt, 0 );
+        require_name  = rb_str_new( (const char*)result_text, result_length );
+
+        /* ruby code */
+        result_text    = sqlite3_column_text( stmt, 1 );
+        result_length  = sqlite3_column_bytes( stmt, 1 );
+        eval_this_code = rb_str_new( (const char*)result_text, result_length );
+
+        /* Kernel.eval( code, TOPLEVEL_BINDING, filename, 1 ) */ 
+        rb_funcall(rb_mKernel, eval_id, 4, eval_this_code, toplevel_binding, require_name, INT2FIX(1) );
+
+        /* TODO: for ruby 1.9 -- put in ? sqlite3://path/to/database?tablename=tbl_name#require_name */
+        /* update $LOADED_FEATURES */
+        rb_ary_push( rb_gv_get( "$LOADED_FEATURES" ), require_name );
+    }
+
+    /* if there was some sqlite error in the processing of the rows */
+    if ( SQLITE_DONE != rc ) {
+        asprintf( &raise_msg, "Failure in bootloading, last successfully loaded rowid was %d : [SQLITE_ERROR %d] %s\n", 
+                  last_row_good, rc, sqlite3_errmsg( db ) );
+        am_bootstrap_cleanup_and_raise( raise_msg, db, stmt );
+    }
+
+    /* finalize the statement */    
+    rc = sqlite3_finalize( stmt );
+    if ( SQLITE_OK != rc ) {
+        asprintf( &raise_msg, "Failure to finalize bootload statement : [SQLITE_ERROR %d]\n", rc, sqlite3_errmsg( db ) );
+        am_bootstrap_cleanup_and_raise( raise_msg, db, stmt );
+    }
+
+    stmt = NULL;
+
+    /* close the database */
+    rc = sqlite3_close( db );
+    if ( SQLITE_OK != rc ) {
+        asprintf( &raise_msg, "Failure to close database : [SQLITE_ERROR %d] : %s\n", rc, sqlite3_errmsg( db )),
+        am_bootstrap_cleanup_and_raise( raise_msg, db,stmt );
+    }
+
+    return Qnil;
+}
+
+/**
+ * Bootstrapping module to help _require_ when Amalgalite::Requires is not
+ * availble in files.
+ */
+void Init_amalgalite3_requires_bootstrap()
+{
+
+    mA   = rb_define_module("Amalgalite");
+    cAR  = rb_define_class_under(mA, "Requires", rb_cObject);
+    cARB = rb_define_class_under(cAR, "Bootstrap", rb_cObject);
+
+    eARB_Error = rb_define_class_under(cARB, "Error", rb_eStandardError);
+
+    rb_define_module_function(cARB, "lift", am_bootstrap_lift, -2); 
+
+    /* constants for default db, table, column, rowid, contents */ 
+    rb_define_const(cARB,              "DEFAULT_DB", rb_str_new2( "lib.db" ));
+    rb_define_const(cARB,           "DEFAULT_TABLE", rb_str_new2( "bootstrap" ));
+    rb_define_const(cARB,    "DEFAULT_ROWID_COLUMN", rb_str_new2( "id" ));
+    rb_define_const(cARB, "DEFAULT_FILENAME_COLUMN", rb_str_new2( "filename" ));
+    rb_define_const(cARB, "DEFAULT_CONTENTS_COLUMN", rb_str_new2( "contents" ));
+
+    return;
+}
+