amalgalite 1.6.0-x64-mingw32

data/examples/define_function.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+$: << "../lib"
+$: << "../ext"
+require 'amalgalite'
+
+#--
+# Create a database and a table to put some results from the functions in
+#--
+db = Amalgalite::Database.new( ":memory:" )
+db.execute( "CREATE TABLE ftest( data, md5, sha1, sha2_bits, sha2)" )
+
+#------------------------------------------------------------------------------
+# Create an MD5 method using the block format of defining an sql fuction
+#------------------------------------------------------------------------------
+require 'digest/md5'
+db.define_function( 'md5' ) do |x|
+  Digest::MD5.hexdigest( x.to_s )
+end
+
+#------------------------------------------------------------------------------
+# Create a SHA1 method using the lambda format of defining an sql function
+#------------------------------------------------------------------------------
+require 'digest/sha1'
+sha1 = lambda do |y|
+  Digest::SHA1.hexdigest( y.to_s )
+end
+db.define_function( "sha1", sha1 )
+
+#------------------------------------------------------------------------------
+# Create a SHA2 method using the class format for defining an sql function
+# In this one we will allow any number of parameters, but we will only use the
+# first two.
+#------------------------------------------------------------------------------
+require 'digest/sha2'
+class SQLSha2
+  # track the number of invocations
+  attr_reader :call_count
+
+  def initialize
+    @call_count = 0
+  end
+
+  # the protocol that is used for sql function definition
+  def to_proc() self ; end
+
+  # say we take any number of parameters
+  def arity
+    -1
+  end
+
+  # The method that is called by SQLite, must be named 'call'
+  def call( *args )
+    text = args.shift.to_s
+    bitlength = (args.shift || 256).to_i
+    Digest::SHA2.new( bitlength ).hexdigest( text )
+  end
+end
+db.define_function('sha2', SQLSha2.new)
+
+
+#------------------------------------------------------------------------------
+# Now we have 3 new sql functions, each defined in one of the available methods
+# to define sql functions in amalgalite.  Lets insert some rows and look at the
+# results
+#------------------------------------------------------------------------------
+possible_bits = [ 256, 384, 512 ]
+sql = "INSERT INTO ftest( data, md5, sha1, sha2_bits, sha2 ) VALUES( @word , md5( @word ), sha1( @word ), @bits, sha2(@word,@bits) )" 
+db.prepare( sql ) do |stmt|
+  DATA.each do |word|
+    word.strip!
+    bits = possible_bits[ rand(3) ]
+    puts "Inserting #{word}, #{bits}"
+    stmt.execute( { '@word' => word, '@bits' => bits } )
+  end
+end
+
+#------------------------------------------------------------------------------
+# And show the results
+#------------------------------------------------------------------------------
+puts
+puts "Getting results..."
+puts
+columns = db.schema.tables['ftest'].columns.keys.sort
+i = 0
+db.execute("SELECT #{columns.join(',')} FROM ftest") do |row|
+  i += 1
+  puts "-----[ row #{i} ]-" + "-" * 42
+  columns.each do |col|
+    puts "#{col.ljust(10)} : #{row[col]}"
+  end
+  puts
+end
+
+
+__END__
+some
+random
+words
+with
+which
+to
+play

data/examples/fts5.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'amalgalite'
+require 'benchmark'
+require 'pathname'
+
+begin
+  require 'json'
+rescue LoadError 
+  abort "'gem install json' to run this example"
+end
+
+
+README = <<_
+ This example program assumes that you have available the 'fortune' BSD command dataset.
+
+ execute `fortune -f` to see if you have this command available.
+_
+
+fortune_dir = %x[ fortune -f 2>&1 ].split("\n").first.split.last
+abort README unless fortune_dir and File.directory?( fortune_dir )
+
+fortune_path = Pathname.new(fortune_dir)
+
+#
+# Lets create a database that utilizes FTS5 http://www.sqlite.org/fts5.html
+#
+#
+
+#
+# Create a database, this will create the DB if it doesn't exist
+#
+puts "Opening database (version #{Amalgalite::VERSION})"
+db = Amalgalite::Database.new("fts5.db")
+
+#
+# Create the schema unless it already exists in the table.  The meta information
+# about the database schema is available as the result of the db.schema method
+#
+schema = db.schema
+unless schema.tables['search'] 
+  puts "Create schema"
+  db.execute_batch <<-SQL
+  CREATE VIRTUAL TABLE search USING fts5(
+    filename,
+    content
+  );
+
+  CREATE TABLE plain (
+    filename VARCHAR(128),
+    content  TEXT 
+  );
+  SQL
+  db.reload_schema!
+end
+
+def each_fortune(path,&block)
+  fortune = []
+  path.each_line do |line|
+    line.strip!
+    if line == "%" then
+      yield fortune.join("\n")
+      fortune.clear
+    else 
+      fortune << line
+    end
+  end
+end
+
+#
+# Only load the data if the db is empty
+#
+if db.first_value_from( "SELECT count(*) from search" ) == 0 then
+  before = Time.now
+  idx = 0
+
+  # Inserting bulk rows as a transaction is good practice with SQLite, it is
+  # MUCH faster.  
+  db.transaction do |db_in_transaction|
+    # Iterate over the files in the fortunes dir and split on the fortunes, then 
+
+    fortune_path.each_child do |fortune_file|
+      next if fortune_file.directory?
+      next if fortune_file.extname == ".dat"
+      $stdout.puts "Loading #{fortune_file}"
+
+      each_fortune(fortune_file) do |fortune|
+        insert_data  = {
+          ':fname'   => fortune_file.to_s,
+          ':content' => fortune
+        }
+
+        # insert into the FTS5 table
+        db_in_transaction.prepare("INSERT INTO search( filename, content ) VALUES( :fname, :content );") do |stmt|
+          stmt.execute( insert_data )
+        end
+
+        # insert into the normal table for comparison
+        db_in_transaction.prepare("INSERT INTO plain( filename, content ) VALUES( :fname, :content );") do |stmt|
+          stmt.execute( insert_data )
+        end
+
+        idx += 1
+        print "Processed #{idx}\r"
+        $stdout.flush
+      end
+      puts "\nFinalizing..."
+    end
+  end
+  puts "Took #{Time.now - before} seconds to insert #{idx} fortunes"
+  puts "Done Inserting"
+end
+
+doc_count = db.first_value_from( "SELECT count(*) from search" ) 
+
+#
+# Now lets do some searching for some various words
+#
+
+%w[ president salmon thanks ].each do |word|
+
+  count = 100
+  puts
+  puts "Searching for '#{word}' #{count} times across #{doc_count} fortunes"
+  puts "=" * 60
+
+  Benchmark.bm( 15 ) do |x|
+
+    #
+    # search using the fts search to get the cont of tweets with the given word
+    #
+    x.report('fts5: ') do 
+      db.prepare( "SELECT count(filename) FROM search WHERE search MATCH 'content:#{word}'" ) do |stmt|
+        count.times do
+          stmt.execute
+        end
+      end
+    end
+
+    #
+    # search using basic string matching in sqlite.  
+    #
+    x.report('plain: ') do 
+      db.prepare( "SELECT count(filename) FROM plain WHERE content LIKE '% #{word} %'" ) do |stmt|
+        count.times do
+          stmt.execute
+        end
+      end
+    end
+  end
+end
+

data/examples/gem-db.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+#
+# Basic amalgalite example creating a table, inserting rows and doing various
+# selects and prepared statements
+#
+require 'rubygems'
+require 'amalgalite'
+
+#
+# Create a database, this will create the DB if it doesn't exist
+#
+puts "Opening database (version #{Amalgalite::Version})"
+db = Amalgalite::Database.new("gems.db")
+
+#
+# Setup taps into profile and trace information of sqlite, the profile tap will
+# goto the profile_tap.log file and the trace information will go to the
+# trace_tap.log file
+#
+puts "Establishing taps"
+db.trace_tap   = Amalgalite::Taps::IO.new( trace_tap_file = File.open("trace_tap.log", "w+") )
+db.profile_tap = Amalgalite::Taps::IO.new( profile_tap_file = File.open("profile_tap.log", "w+") )
+
+#
+# Create the schema unless it already exists in the table.  The meta information
+# about the database schema is available as the result of the db.schema method
+#
+schema = db.schema
+unless schema.tables['gems'] 
+  puts "Create schema"
+  db.execute <<-SQL
+  CREATE TABLE gems (
+    id      INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    name    VARCHAR(128),
+    version VARCHAR(32),
+    author  VARCHAR(128)
+  );
+  SQL
+  db.reload_schema!
+end
+
+#
+# Get some data from the system to insert into the database.  Since everyone
+# probably has gems installed, that's a ready known piece of information.  We'll
+# just pull in the latest version of each installed gem and dump some meta
+# information into a db for testing.
+#
+latest_specs = Gem.source_index.latest_specs
+
+puts "Inserting #{latest_specs.size} rows of gem information..."
+before = Time.now
+
+# Inserting bulk rows as a transaction is good practice with SQLite, it is
+# MUCH faster.  
+db.transaction do |db_in_transaction|
+  db_in_transaction.prepare("INSERT INTO gems(name, version, author) VALUES( :name, :version, :author );") do |stmt|
+    latest_specs.each do |spec|
+      insert_data = {}
+      insert_data[':name']    = spec.name.to_s
+      insert_data[':version'] = spec.version.to_s
+      insert_data[':author']  = spec.authors.join(' ')
+      #puts "Inserting #{insert_data.inspect}"
+      stmt.execute( insert_data )
+    end
+  end
+end
+puts "Took #{Time.now - before} seconds"
+puts "Done Inserting"
+
+authors_by_number = db.execute("SELECT author, count( name ) as num_gems FROM gems GROUP BY author ORDER BY num_gems DESC")
+favorite_author   = authors_by_number.first
+puts "Your favorite gem author is <#{favorite_author['author']}>, with #{favorite_author['num_gems']} gems installed."
+
+#
+# Now we'll look at the profile sampler and see what information it traced about
+# our behavoir.
+#
+db.profile_tap.samplers.each do |stat_name, stat_values|
+  puts "-" * 20
+  puts stat_values.to_s
+end
+
+#
+# Clear out the taps (not really necessary, just cleaning up)
+#
+db.trace_tap = profile_tap = nil
+
+#
+# close things down
+#
+db.close
+trace_tap_file.close
+profile_tap_file.close

data/examples/require_me.rb

@@ -0,0 +1,11 @@
+CONSTANT = "bad"
+class RequireMe
+  def initialize( msg )
+    @msg = msg
+    puts "RequireMe initialized"
+  end
+
+  def foo
+    puts @msg
+  end
+end

data/examples/requires.rb

@@ -0,0 +1,42 @@
+#!/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'
+
+style = ARGV.shift || "normal"
+
+#
+# create the database 
+#
+dbfile = Amalgalite::Requires::Bootstrap::DEFAULT_DB
+File.unlink( dbfile ) if File.exist?( dbfile )
+require 'amalgalite/packer'
+options = { :verbose => true }
+if style == "compressed" then
+  options[:compressed] = true
+end
+p = Amalgalite::Packer.new( options )
+p.pack( [ "require_me.rb" ] )
+
+require 'amalgalite/requires'
+begin 
+  Amalgalite::Requires.new( :dbfile_name => p.dbfile )
+  FileUtils.mv 'require_me.rb', 'rm.rb', :verbose => true
+  require 'require_me'
+  e = RequireMe.new( "#{style} require style works!" )
+  e.foo
+  require 'require_me'
+  puts 
+
+ensure
+  FileUtils.mv 'rm.rb', 'require_me.rb', :verbose => true
+  File.unlink( dbfile ) if File.exist?( dbfile )
+end

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/amalgalite/c/amalgalite.c

@@ -0,0 +1,355 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+:*/ 
+
+#include "amalgalite.h"
+
+/* Module and Classes */
+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
+ *---------------------------------------------------------------------*/
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3.threadsafe? -> true or false
+ *
+ * Has the SQLite3 extension been compiled "threadsafe".  If threadsafe? is
+ * true then the internal SQLite mutexes are enabled and SQLite is threadsafe.
+ * That is threadsafe within the context of 'C' threads.
+ *
+ */
+VALUE am_sqlite3_threadsafe(VALUE self)
+{
+    if (sqlite3_threadsafe()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/*
+ * call-seq:
+ *  Amalgalite::SQLite.temp_directory -> String or nil
+ *
+ * Return the directory name that all that all the temporary files created by
+ * SQLite creates will be placed.  If _nil_ is returned, then SQLite will search
+ * for an appropriate directory.
+ */
+VALUE am_sqlite3_get_temp_directory( VALUE self )
+{
+    if (NULL == sqlite3_temp_directory) {
+        return Qnil;
+    } else {
+        return rb_str_new2( sqlite3_temp_directory );
+    }
+}
+
+/*
+ * call-seq:
+ *  Amalgalite::SQLite.temp_directory = "/tmp/location"
+ *
+ * Set the temporary directory used by sqlite to store temporary directories.
+ * It is not safe to set this value after a Database has been opened.
+ *
+ */
+VALUE am_sqlite3_set_temp_directory( VALUE self, VALUE new_dir )
+{
+    char *p   = NULL ;
+
+    if ( NULL != sqlite3_temp_directory ) {
+        free( sqlite3_temp_directory );
+    }
+
+    if ( Qnil != new_dir ) {
+        VALUE str = StringValue( new_dir );
+
+        p = calloc( RSTRING_LEN(str) + 1, sizeof(char) );
+        strncpy( p, RSTRING_PTR(str), RSTRING_LEN(str) );
+    }
+
+    sqlite3_temp_directory = p;
+
+    return Qnil;
+}
+
+VALUE amalgalite_format_string( const char* pattern, VALUE string )
+{
+    VALUE to_s= rb_funcall( string, rb_intern("to_s"), 0 );
+    VALUE str = StringValue( to_s );
+    char *p   = sqlite3_mprintf(pattern, RSTRING_PTR(str));
+    VALUE rv  = Qnil;
+    if ( NULL != p ) {
+        rv  = rb_str_new2( p );
+        sqlite3_free( p );
+    } else {
+        rb_raise( rb_eNoMemError, "Unable to quote string" );
+    } 
+
+    return rv;
+}
+/*
+ * call-seq:
+ *  Amalgalite::SQLite.escape( string ) => escaped_string
+ *
+ * Takes the input string and escapes each ' (single quote) character by
+ * doubling it.
+ */
+VALUE am_sqlite3_escape( VALUE self, VALUE string )
+{ 
+    return ( Qnil == string ) ? Qnil : amalgalite_format_string( "%q", string );
+}
+
+/*
+ * call-seq:
+ *  Amalgalite::SQLite.quote( string ) => quoted-escaped string
+ *
+ * Takes the input string and surrounds it with single quotes, it also escapes
+ * each embedded single quote with double quotes.
+ */
+VALUE am_sqlite3_quote( VALUE self, VALUE string )
+{
+    return ( Qnil == string ) ? Qnil : amalgalite_format_string( "%Q", string );
+}
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3.complete?( ... , opts = { :utf16 => false }) -> True, False
+ *
+ * Is the text passed in as a parameter a complete SQL statement?  Or is
+ * additional input required before sending the SQL to the extension.  If the
+ * extra 'opts' parameter is used, you can send in a UTF-16 encoded string as
+ * the SQL.
+ *
+ * A complete statement must end with a semicolon.
+ *
+ */
+VALUE am_sqlite3_complete(VALUE self, VALUE args)
+{
+    VALUE sql      = rb_ary_shift( args );
+    VALUE opts     = rb_ary_shift( args );
+    VALUE utf16    = Qnil;
+    int   result = 0;
+
+    if ( ( Qnil != opts ) && ( T_HASH == TYPE(opts) ) ){
+        utf16 = rb_hash_aref( opts, rb_intern("utf16") );
+    }
+
+    if ( (Qfalse == utf16) || (Qnil == utf16) ) {
+        result = sqlite3_complete( StringValuePtr( sql ) );
+    } else {
+        result = sqlite3_complete16( (void*) StringValuePtr( sql ) );
+    }
+
+    return ( result > 0 ) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3::Stat.update!( reset = false ) -> nil
+ *
+ * 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_stat_update_bang( int argc, VALUE *argv, VALUE self )
+{
+    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 ;
+    }
+
+    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;
+}
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3.randomness( N ) -> String of length N
+ *
+ * Generate N bytes of random data.
+ *
+ */
+VALUE am_sqlite3_randomness(VALUE self, VALUE num_bytes)
+{
+    int n     = NUM2INT(num_bytes);
+    char *buf = ALLOCA_N(char, n);
+
+    sqlite3_randomness( n, buf );
+    return rb_str_new( buf, n );
+}
+
+/*----------------------------------------------------------------------
+ * module methods for Amalgalite::SQLite3::Version
+ *---------------------------------------------------------------------*/
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3::Version.to_s -> String
+ *
+ * Return the SQLite C library version number as a string
+ *
+ */
+VALUE am_sqlite3_runtime_version(VALUE self)
+{
+    return rb_str_new2(sqlite3_libversion());
+}
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3.Version.to_i -> Fixnum
+ *
+ * Return the SQLite C library version number as an integer
+ *
+ */
+VALUE am_sqlite3_runtime_version_number(VALUE self)
+{
+    return INT2FIX(sqlite3_libversion_number());
+}
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3::Version.runtime_source_id -> String
+ *
+ * Return the SQLite C library source id as a string
+ *
+ */
+VALUE am_sqlite3_runtime_source_id(VALUE self)
+{
+    return rb_str_new2(sqlite3_sourceid());
+}
+
+/*
+ * call-seq:
+ *   Amalgalite::SQLite::Version.compiled_version -> String
+ *
+ * Return the compiletime version number as a string.
+ *
+ */
+VALUE am_sqlite3_compiled_version(VALUE self)
+{
+    return rb_str_new2( SQLITE_VERSION );
+}
+
+/*
+ * call-seql:
+ *   Amalgalite::SQLite::Version.compiled_version_number -> Fixnum
+ *
+ * Return the compiletime library version from the 
+ * embedded version of sqlite3.
+ *
+ */
+VALUE am_sqlite3_compiled_version_number( VALUE self )
+{
+    return INT2FIX( SQLITE_VERSION_NUMBER );
+}
+
+/*
+ * call-seq:
+ *    Amalgalite::SQLite3::Version.compiled_source_id -> String
+ *
+ * Return the compiled SQLite C library source id as a string
+ *
+ */
+VALUE am_sqlite3_compiled_source_id(VALUE self)
+{
+    return rb_str_new2( SQLITE_SOURCE_ID );
+}
+
+/**
+ * Document-class: Amalgalite::SQLite3
+ *
+ * The SQLite ruby extension inside Amalgalite.
+ *
+ */
+
+void Init_amalgalite()
+{
+    int rc = 0;
+
+    /*
+     * top level module encapsulating the entire Amalgalite library
+     */
+    mA   = rb_define_module("Amalgalite");
+
+    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, "randomness", am_sqlite3_randomness,1);
+    rb_define_module_function(mAS, "temp_directory", am_sqlite3_get_temp_directory, 0);
+    rb_define_module_function(mAS, "temp_directory=", am_sqlite3_set_temp_directory, 1);
+
+    rb_define_module_function(mAS, "escape", am_sqlite3_escape, 1);
+    rb_define_module_function(mAS, "quote", am_sqlite3_quote, 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
+     */
+    eAS_Error = rb_define_class_under(mAS, "Error", rb_eStandardError); /* in amalgalite.c */
+
+    /**
+     * Encapsulation of the SQLite C library version
+     */
+    mASV = rb_define_module_under(mAS, "Version");
+    rb_define_module_function(mASV, "to_s", am_sqlite3_runtime_version, 0); /* in amalgalite.c */
+    rb_define_module_function(mASV, "runtime_version", am_sqlite3_runtime_version, 0); /* in amalgalite.c */
+    rb_define_module_function(mASV, "to_i", am_sqlite3_runtime_version_number, 0); /* in amalgalite.c */
+    rb_define_module_function(mASV, "runtime_version_number", am_sqlite3_runtime_version_number, 0); /* in amalgalite.c */
+    rb_define_module_function(mASV, "compiled_version", am_sqlite3_compiled_version, 0 ); /* in amalgalite.c */
+    rb_define_module_function(mASV, "compiled_version_number", am_sqlite3_compiled_version_number, 0 ); /* in amalgalite.c */
+    rb_define_module_function(mASV, "runtime_source_id", am_sqlite3_runtime_source_id, 0); /* in amalgalite.c */
+    rb_define_module_function(mASV, "compiled_source_id", am_sqlite3_compiled_source_id, 0); /* in amalgalite.c */
+
+    /*
+     * Initialize the rest of the module
+     */
+    Init_amalgalite_constants( );
+    Init_amalgalite_database( );
+    Init_amalgalite_statement( );
+    Init_amalgalite_blob( );
+    Init_amalgalite_requires_bootstrap( );
+
+    /*
+     * initialize sqlite itself
+     */
+    rc = sqlite3_initialize();
+    if ( SQLITE_OK != rc ) {
+        rb_raise(eAS_Error, "Failure to initialize the sqlite3 library : [SQLITE_ERROR %d]\n", rc);
+    }
+
+ }
+
+