amalgalite 1.9.4 → 2.0.0

data/ext/amalgalite/c/amalgalite_requires_bootstrap.c

@@ -1,283 +0,0 @@
-/**
- * Copyright (c) 2008 Jeremy Hinegardner
- * All rights reserved.  See LICENSE and/or COPYING for details.
- *
- * vim: shiftwidth=4 
- */ 
-
-#include "amalgalite.h"
-#include <stdio.h>
-#include <stdnoreturn.h>
-extern VALUE mA;
-VALUE cAR;
-VALUE cARB;
-VALUE eARB_Error;
-
-/* 
- * cleanup the datatbase and statment values if they are currently open and then
- * raise the message.  It is assumed that the *msg pointer passed in is NOT
- * allocated via malloc() or the like.  It should be a local static buffer
- * that we do not have to worry about freeing.
- */
-noreturn void am_bootstrap_cleanup_and_raise( const char* msg, sqlite3* db, sqlite3_stmt* stmt )
-{
-
-    if ( NULL != stmt ) { sqlite3_finalize( stmt ); stmt = NULL; }
-    if ( NULL != db   ) { sqlite3_close( db ); }
-
-    rb_raise(eARB_Error, "%s", msg );
-}
-
-
-void am_bootstrap_from_db( sqlite3* db, VALUE args )
-{
-    sqlite3_stmt* stmt = NULL;
-    int             rc;
-    char raise_msg[BUFSIZ];
-    int  last_row_good; 
-
-    VALUE    am_tbl_c  = rb_const_get( cARB, rb_intern("DEFAULT_BOOTSTRAP_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*    tbl_name = NULL;
-    char*      pk_col = NULL;
-    char*   fname_col = NULL;
-    char* content_col = NULL;
-
-
-    char             sql[BUFSIZ];
-    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              tmp = Qnil;
-
-    ID             eval_id = rb_intern("eval");
-
-
-
-    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 );
-
-
-    /* prepare the db query */
-    memset( sql, 0, BUFSIZ );
-    sql_bytes = snprintf( sql, BUFSIZ, "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 ) ;
-    if ( SQLITE_OK != rc) {
-        memset( raise_msg, 0, BUFSIZ );
-        snprintf( raise_msg, BUFSIZ,
-                  "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 $LOADED_FEATURES */
-    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 ) {
-        memset( raise_msg, 0, BUFSIZ );
-        snprintf( raise_msg, BUFSIZ, "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 ) {
-        memset( raise_msg, 0, BUFSIZ );
-        snprintf( raise_msg, BUFSIZ, "Failure to finalize bootload statement : [SQLITE_ERROR %d] %s\n", rc, sqlite3_errmsg( db ) );
-        am_bootstrap_cleanup_and_raise( raise_msg, db, stmt );
-    }
-
-}
-
-
-/**
- * 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 _$LOADED_FEATURES_ 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;
-    int      rc;
-    char     raise_msg[BUFSIZ];
-    VALUE    tmp = Qnil;
-
-    VALUE    am_db_c  = rb_const_get( cARB, rb_intern("DEFAULT_DB") );
-
-    char    *dbfile = NULL;
-
-
-    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 );
-
-    /* open the database */
-    rc = sqlite3_open_v2( dbfile , &db, SQLITE_OPEN_READONLY, NULL);
-    if ( SQLITE_OK != rc ) {
-        memset( raise_msg, 0, BUFSIZ );
-        snprintf(raise_msg, BUFSIZ, "Failure to open database %s for bootload: [SQLITE_ERROR %d] : %s", dbfile, rc, sqlite3_errmsg( db ) );
-        am_bootstrap_cleanup_and_raise( raise_msg, db, NULL );
-    }
-
-    am_bootstrap_from_db( db, args );
-
-    /* close the database */
-    rc = sqlite3_close( db );
-    if ( SQLITE_OK != rc ) {
-        memset( raise_msg, 0, BUFSIZ );
-        snprintf( raise_msg, BUFSIZ, "Failure to close database : [SQLITE_ERROR %d] : %s\n", rc, sqlite3_errmsg( db )),
-        am_bootstrap_cleanup_and_raise( raise_msg, db, NULL );
-    }
-
-    return Qnil;
-}
-
-/**
- * call-seq:
- *   Amalgalite::Requires::Bootstrap.lift_str( sql, 'table_name' => "bootload", 'rowid_column' => "id", 'filename_column' => "filename",  'content_column' => "contents" )
- * 
- *  Bootstrap Amalgalite from a string containing an SQL dump. See Amalgalite::Requires::Bootstrap.lift.
- *
- *  For example:
- *
- *    Amalgalite::Requires::Bootstrap.lifts(File.read("lib.sql"))
- */
-VALUE am_bootstrap_lift_str( VALUE self, VALUE args )
-{
-  sqlite3 *db = NULL;
-  int rc;
-  char     raise_msg[BUFSIZ];
-  VALUE sql = Qnil;
-  VALUE args_hsh = Qnil;
-
-  sql = rb_ary_shift(args);
-  StringValue(sql);
-  if ( Qnil == sql ) { rb_raise(eARB_Error, "SQL required." );  }
-  
-  args_hsh = rb_ary_shift(args);
-  if ( Qnil == args_hsh ) { args_hsh = rb_hash_new(); }
-
-
-  rc = sqlite3_open_v2( ":memory:", &db, SQLITE_OPEN_READWRITE, NULL );
-  if ( SQLITE_OK != rc ) {
-    memset( raise_msg, 0, BUFSIZ );
-    snprintf(raise_msg, BUFSIZ, "Failure to open database :memory: for bootload: [SQLITE_ERROR %d] : %s", rc, sqlite3_errmsg( db ) );
-    am_bootstrap_cleanup_and_raise( raise_msg, db, NULL );
-  }
-
-  /* Load the bootstrap SQL into the database */
-  rc = sqlite3_exec( db, StringValuePtr( sql ), NULL, NULL, NULL );
-
-  if ( SQLITE_OK != rc ) {
-    memset( raise_msg, 0, BUFSIZ );
-    snprintf(raise_msg, BUFSIZ, "Failure to import bootload sql: [SQLITE_ERROR %d] : %s", rc, sqlite3_errmsg( db ) );
-    am_bootstrap_cleanup_and_raise( raise_msg, db, NULL );
-  }
-
-  am_bootstrap_from_db( db, args_hsh );
-
-  rc = sqlite3_close( db );
-  
-  if ( SQLITE_OK != rc ) {
-    memset( raise_msg, 0, BUFSIZ );
-    snprintf( raise_msg, BUFSIZ, "Failure to close database : [SQLITE_ERROR %d] : %s\n", rc, sqlite3_errmsg( db )),
-      am_bootstrap_cleanup_and_raise( raise_msg, db, NULL );
-  }
-
-  return Qnil;
-
-}
-
-
-/**
- * Bootstrapping module to help _require_ when Amalgalite::Requires is not
- * availble in files.
- */
-void Init_amalgalite_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);
-    rb_define_module_function(cARB, "lifts", 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( "rubylibs" ));
-    rb_define_const(cARB,   "DEFAULT_BOOTSTRAP_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" ));
-    rb_define_const(cARB, "DEFAULT_COMPRESSED_COLUMN", rb_str_new2( "compressed" ));
-
-    return;
-}
-

data/lib/amalgalite/core_ext/kernel/require.rb

@@ -1,21 +0,0 @@
-module Kernel
-  # alias the original require away to use later
-  alias :amalgalite_original_require :require
-
-  #
-  # hook into the system 'require' to allow for required text or blobs from an
-  # amalgalite database.  
-  #
-  def require( filename )
-    loaded = amalgalite_original_require( filename )
-  rescue LoadError => load_error
-    if load_error.message =~ /#{Regexp.escape filename}\z/ then
-      loaded = Amalgalite::Requires.require( filename )
-    else
-      raise load_error
-    end
-  end
-
-  private :require
-  private :amalgalite_original_require
-end

data/lib/amalgalite/packer.rb

@@ -1,231 +0,0 @@
-require 'optparse'
-require 'ostruct'
-require 'pathname'
-require 'zlib'
-
-require 'amalgalite'
-module Amalgalite
-  #
-  # Pack items into an amalgalite database.  
-  #
-  class Packer
-    attr_reader :packing_list
-    attr_reader :dbfile
-    attr_reader :options
-
-    class << self
-      def default_options
-        {
-          :table_name        => Requires::Bootstrap::DEFAULT_TABLE,
-          :filename_column   => Requires::Bootstrap::DEFAULT_FILENAME_COLUMN,
-          :contents_column   => Requires::Bootstrap::DEFAULT_CONTENTS_COLUMN,
-          :compressed_column => Requires::Bootstrap::DEFAULT_COMPRESSED_COLUMN,
-          :strip_prefix      => Dir.pwd,
-          :compressed        => false,
-          :verbose           => false,
-        }
-      end
-
-      #
-      # compress data
-      #
-      def gzip( data )
-        zipped = StringIO.new
-        Zlib::GzipWriter.wrap( zipped ) do |io|
-          io.write( data )
-        end
-        return zipped.string
-      end
-
-      # 
-      # uncompress gzip data
-      #
-      def gunzip( data )
-        data = StringIO.new( data )
-        Zlib::GzipReader.new( data ).read
-      end
-
-
-      #
-      # return the files in their dependency order for use for packing into a
-      # database
-      #
-      def amalgalite_require_order
-        @require_order ||= %w[
-          amalgalite.rb
-          amalgalite/sqlite3/database/function.rb
-          amalgalite/aggregate.rb
-          amalgalite/blob.rb
-          amalgalite/boolean.rb
-          amalgalite/busy_timeout.rb
-          amalgalite/column.rb
-          amalgalite/statement.rb
-          amalgalite/trace_tap.rb
-          amalgalite/profile_tap.rb
-          amalgalite/type_map.rb
-          amalgalite/type_maps/storage_map.rb
-          amalgalite/type_maps/text_map.rb
-          amalgalite/type_maps/default_map.rb
-          amalgalite/function.rb
-          amalgalite/progress_handler.rb
-          amalgalite/csv_table_importer.rb
-          amalgalite/database.rb
-          amalgalite/index.rb
-          amalgalite/memory_database.rb
-          amalgalite/paths.rb
-          amalgalite/table.rb
-          amalgalite/view.rb
-          amalgalite/schema.rb
-          amalgalite/version.rb
-          amalgalite/sqlite3/version.rb
-          amalgalite/sqlite3/constants.rb
-          amalgalite/sqlite3/status.rb
-          amalgalite/sqlite3/database/status.rb
-          amalgalite/sqlite3.rb
-          amalgalite/taps/io.rb
-          amalgalite/taps/console.rb
-          amalgalite/taps.rb
-          amalgalite/packer.rb
-          amalgalite/core_ext/kernel/require.rb
-          amalgalite/requires.rb
-        ]
-      end
-    end
-
-    # 
-    # Create a new packer instance with the list of items to pack and all the
-    # options
-    #
-    def initialize(  options = {} )
-      @options = Packer.default_options.merge( options )
-      @dbfile  = @options[:dbfile] || Requires::Bootstrap::DEFAULT_DB
-    end
-
-    # 
-    # The SQL to create the table for storing ruby code
-    #
-    def create_table_sql
-      <<-create
-      CREATE TABLE #{options[:table_name]} (
-      id                   INTEGER PRIMARY KEY AUTOINCREMENT,
-      #{options[:filename_column]}   TEXT UNIQUE,
-      #{options[:compressed_column]} BOOLEAN,
-      #{options[:contents_column]}   BLOB
-      );
-      create
-    end
-
-    #
-    # Make sure that the dbfile exists and has the appropriate schema.  
-    #
-    def check_db( db )
-      if db.schema.tables[ options[:table_name] ] and options[:drop_table] then
-        STDERR.puts "Dropping table #{options[:table_name]}" if options[:verbose]
-        db.execute("DROP TABLE #{options[:table_name]}")
-        db.reload_schema!
-      end
-
-      unless db.schema.tables[ options[:table_name] ]
-        db.execute( create_table_sql )
-        db.reload_schema!
-      end
-
-    end
-
-
-    #
-    # Stores all the .rb files in the list into the given database.  The prefix
-    # is the file system path to remove from the front of the path on each file
-    #
-    # manifest is an array of OpenStructs.  
-    #
-    def pack_files( manifest )
-      db = Amalgalite::Database.new( dbfile )
-      check_db( db )
-      max_width = manifest.collect{ |m| m.require_path.length }.sort.last
-      contents_column = db.schema.tables[ options[:table_name] ].columns[ options[:contents_column] ]
-      db.transaction do |trans|
-        manifest.each do |file_info|
-          msg  = "  -> #{file_info.require_path.ljust( max_width )} : "
-          begin
-            if options[:merge] then
-              trans.execute( "DELETE FROM #{options[:table_name]} WHERE #{options[:filename_column]} = ?", file_info.require_path )
-            end
-
-            trans.prepare("INSERT INTO #{options[:table_name]}(#{options[:filename_column]}, #{options[:compressed_column]}, #{options[:contents_column]}) VALUES( $filename, $compressed, $contents)") do |stmt|
-              contents = IO.readlines( file_info.file_path )
-              if options[:self] then
-                contents.each { |l| l.gsub!( /^(\s*require .*)$/m, "# commented out by #{self.class.name} \\1") }
-              end
-              contents = contents.join
-
-              if options[:compressed] then
-                contents = Packer.gzip( contents )
-              end
-              content_io = StringIO.new( contents )
-              stmt.execute( "$filename"   => file_info.require_path,
-                            "$contents"   => Amalgalite::Blob.new( :io => content_io,
-                                                                   :column => contents_column ),
-                            "$compressed" => options[:compressed] )
-              STDERR.puts "#{msg} stored #{file_info.file_path}" if options[:verbose]
-            end
-          rescue => e
-            STDERR.puts "#{msg} error #{e}"
-          end
-        end
-      end
-    end
-
-    #
-    # given a file, see if it can be found in the ruby load path, if so, return that
-    # full path
-    #
-    def full_path_of( rb_file )
-      $LOAD_PATH.each do |load_path|
-        guess = File.expand_path( File.join( load_path, rb_file ) )
-        return guess if File.exist?( guess )
-      end
-      return nil
-    end
-
-    # 
-    # Make the manifest for packing
-    #
-    def make_manifest( file_list )
-      manifest = []
-      prefix_path = ::Pathname.new( options[:strip_prefix] )
-      file_list.each do |f|
-        file_path = ::Pathname.new( File.expand_path( f ) )
-        m = ::OpenStruct.new
-        # if it is a directory then grab all the .rb files from it
-        if File.directory?( file_path ) then
-          manifest.concat( make_manifest( Dir.glob( File.join( f, "**", "*.rb" ) ) ) )
-          next
-        elsif File.readable?( file_path ) then
-          m.require_path = file_path.relative_path_from( prefix_path )
-          m.file_path    = file_path.realpath.to_s
-        elsif lp = full_path_of( f ) then
-          m.require_path = f
-          m.file_path    = lp
-        else
-          STDERR.puts "Unable to add #{f} to the manifest, cannot find the file on disk"
-          next
-        end
-        # Make sure that we can handle files without the .rb extension
-        # if we have to. This means bin/foo works as a require path
-        # without requiring bin/foo to actually be bin/foo.rb
-        m.require_path = m.require_path.to_s.sub(/\.rb\Z/,'')
-        manifest << m
-      end
-      return manifest
-    end
-
-    #
-    # Given a list of files pack them into the associated database and table.
-    #
-    def pack( file_list )
-      manifest = make_manifest( file_list )
-      pack_files( manifest )
-    end
-  end
-end

data/lib/amalgalite/requires.rb

@@ -1,151 +0,0 @@
-require 'amalgalite'
-require 'pathname'
-require 'zlib'
-require 'amalgalite/packer'
-
-module Amalgalite
-  #
-  # Requires encapsulates requiring items from the database
-  #
-  class Requires
-    class << self
-      def load_path_db_connections
-        @load_path_db_connections ||= {}
-      end
-
-      def load_path
-        @load_path ||= []
-      end
-
-      #
-      # Allocate a database connection to the given filename. For
-      # file databases, this means giving the same connection
-      # back if you ask for a connection to the same file.
-      # For in-memory databases, you get a new one each time.
-      #
-      def db_connection_to( dbfile_name )
-        if dbfile_name == ":memory:"
-          return ::Amalgalite::Database.new( dbfile_name )
-        else
-          unless connection = load_path_db_connections[ dbfile_name ] 
-            connection = ::Amalgalite::Database.new( dbfile_name )
-            load_path_db_connections[dbfile_name] = connection
-          end
-          return connection
-        end
-      end
-
-      #
-      # Setting a class level variable as a flag to know what we are currently
-      # in the middle of requiring
-      #
-      def requiring
-        @requiring ||= []
-      end
-
-      def require( filename )
-        if load_path.empty? then
-          raise ::LoadError, "Amalgalite load path is empty -- #{filename}"
-        elsif $LOADED_FEATURES.include?( filename ) then
-          return false
-        elsif Requires.requiring.include?( filename ) then 
-          return false
-        else
-          Requires.requiring << filename
-          load_path.each do |lp|
-            if lp.require( filename ) then
-              Requires.requiring.delete( filename )
-              return true
-            end
-          end
-          Requires.requiring.delete( filename )
-          raise ::LoadError, "amalgalite has no such file to load -- #{filename}"
-        end
-      end
-    end
-
-    attr_reader :dbfile_name
-    attr_reader :table_name
-    attr_reader :filename_column
-    attr_reader :contents_column
-    attr_reader :compressed_column
-    attr_reader :db_connection
-
-    def initialize( opts = {} )
-      @dbfile_name       = opts[:dbfile_name]       || Bootstrap::DEFAULT_DB
-      @table_name        = opts[:table_name]        || Bootstrap::DEFAULT_TABLE
-      @filename_column   = opts[:filename_column]   || Bootstrap::DEFAULT_FILENAME_COLUMN
-      @contents_column   = opts[:contents_column]   || Bootstrap::DEFAULT_CONTENTS_COLUMN
-      @compressed_column = opts[:compressed_column] || Bootstrap::DEFAULT_COMPRESSED_COLUMN
-      @db_connection   = Requires.db_connection_to( dbfile_name )
-      Requires.load_path << self
-    end
-
-    #
-    # return the sql to find the file contents for a file in this requires
-    #
-    def sql
-      @sql ||= "SELECT #{filename_column}, #{compressed_column}, #{contents_column} FROM #{table_name} WHERE #{filename_column} = ?"
-    end
-
-    #
-    # load a file in this database table.  This will check and see if the
-    # file is already required.  If it isn't it will select the contents
-    # associated with the row identified by the filename and eval those contents
-    # within the context of TOPLEVEL_BINDING.  The filename is then appended to
-    # $LOADED_FEATURES.
-    #
-    # if the file was required then true is returned, otherwise false 
-    #
-    def require( filename )
-      if $LOADED_FEATURES.include?( filename ) then
-        return false
-      else
-        begin
-          filename = filename.gsub(/\.rb\Z/,'')
-
-          contents = file_contents(filename)
-
-          if contents
-            eval( contents, TOPLEVEL_BINDING, filename )
-            $LOADED_FEATURES << filename
-            return true
-          else
-            return false
-          end
-        rescue => e
-          raise ::LoadError, "Failure loading #{filename} from #{dbfile_name} : #{e}"
-        end
-      end
-    end
-
-    # 
-    # Return the contents of the named file.
-    #
-    def file_contents(filename)
-      rows = db_connection.execute(sql, filename)
-      if rows.size > 0 then
-        row = rows.first
-
-        contents = row[contents_column].to_s
-        if row[compressed_column] then 
-          contents = ::Amalgalite::Packer.gunzip( contents )
-        end
-        
-        return contents
-      else
-        return nil
-      end
-    end
-
-    
-    #
-    # Import an SQL dump into the fake file system.
-    #
-    def import(sql)
-      db_connection.import(sql)
-    end
-
-  end
-end
-require 'amalgalite/core_ext/kernel/require'