amalgalite 1.1.2-x86-mingw32 → 1.4.0-x86-mingw32

data/ext/amalgalite/{amalgalite3_requires_bootstrap.c → c/amalgalite_requires_bootstrap.c}

@@ -5,7 +5,7 @@
  * vim: shiftwidth=4 
  */ 
 
-#include "amalgalite3.h"
+#include "amalgalite.h"
 #include <stdio.h>
 extern VALUE mA;
 VALUE cAR;
@@ -28,57 +28,24 @@ void am_bootstrap_cleanup_and_raise( const char* msg, sqlite3* db, sqlite3_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 )
+void am_bootstrap_from_db( sqlite3* db, VALUE args )
 {
-    sqlite3*        db = NULL;
     sqlite3_stmt* stmt = NULL;
     int             rc;
-    int  last_row_good; 
     char raise_msg[BUFSIZ];
+    int  last_row_good; 
 
-    VALUE     am_db_c  = rb_const_get( cARB, rb_intern("DEFAULT_DB") );
     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*      dbfile = NULL;
     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;
@@ -94,30 +61,13 @@ VALUE am_bootstrap_lift( VALUE self, VALUE args )
     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 ) {
-        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, stmt );
-    }
-
     /* 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 );
@@ -167,24 +117,146 @@ VALUE am_bootstrap_lift( VALUE self, VALUE args )
         am_bootstrap_cleanup_and_raise( raise_msg, db, stmt );
     }
 
-    stmt = NULL;
+}
+
+
+/**
+ * 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,stmt );
+        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_amalgalite3_requires_bootstrap()
+void Init_amalgalite_requires_bootstrap()
 {
 
     mA   = rb_define_module("Amalgalite");
@@ -193,7 +265,8 @@ void Init_amalgalite3_requires_bootstrap()
 
     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, "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" ));

data/ext/amalgalite/{amalgalite3_statement.c → c/amalgalite_statement.c}

@@ -1,4 +1,4 @@
-#include "amalgalite3.h"
+#include "amalgalite.h"
 /**
  * Copyright (c) 2008 Jeremy Hinegardner
  * All rights reserved.  See LICENSE and/or COPYING for details.
@@ -604,7 +604,7 @@ VALUE am_sqlite3_statement_alloc(VALUE klass)
  * Amagalite Database extension
  */
 
-void Init_amalgalite3_statement( )
+void Init_amalgalite_statement( )
 {
 
     VALUE ma  = rb_define_module("Amalgalite");

data/ext/amalgalite/{extconf.rb → c/extconf.rb}

@@ -10,7 +10,8 @@ $CFLAGS += " -DSQLITE_ENABLE_COLUMN_METADATA=1"
 $CFLAGS += " -DSQLITE_ENABLE_RTREE=1"
 $CFLAGS += " -DSQLITE_ENABLE_FTS3=1"
 $CFLAGS += " -DSQLITE_ENABLE_FTS3_PARENTHESIS=1"
-$CFLAGS += " -DSQLITE_ENABLE_STAT2=1"
+$CFLAGS += " -DSQLITE_ENABLE_FTS4=1"
+$CFLAGS += " -DSQLITE_ENABLE_STAT4=1"
 
 # we compile sqlite the same way that the installation of ruby is compiled.
 if RbConfig::MAKEFILE_CONFIG['configure_args'].include?( "--enable-pthread" ) then
@@ -20,17 +21,17 @@ else
 end
 
 # remove the -g flags  if it exists
-%w[ -ggdb -g ].each do |debug|
+%w[ -ggdb\\d* -g\\d* ].each do |debug|
   $CFLAGS = $CFLAGS.gsub(/#{debug}/,'')
-  RbConfig::MAKEFILE_CONFIG['debugflags'] = Config::MAKEFILE_CONFIG['debugflags'].gsub(/#{debug}/,'')   if Config::MAKEFILE_CONFIG['debugflags']
+  RbConfig::MAKEFILE_CONFIG['debugflags'] = RbConfig::MAKEFILE_CONFIG['debugflags'].gsub(/#{debug}/,'')   if RbConfig::MAKEFILE_CONFIG['debugflags']
 end
 
 %w[ shorten-64-to-32 write-strings ].each do |warning|
   $CFLAGS = $CFLAGS.gsub(/-W#{warning}/,'')
-  Config::MAKEFILE_CONFIG['warnflags'] = Config::MAKEFILE_CONFIG['warnflags'].gsub(/-W#{warning}/,'') if Config::MAKEFILE_CONFIG['warnflags'] 
+  RbConfig::MAKEFILE_CONFIG['warnflags'] = RbConfig::MAKEFILE_CONFIG['warnflags'].gsub(/-W#{warning}/,'') if RbConfig::MAKEFILE_CONFIG['warnflags'] 
 end
 
 
 
 subdir = RUBY_VERSION.sub(/\.\d$/,'')
-create_makefile("amalgalite/#{subdir}/amalgalite3")
+create_makefile("amalgalite/#{subdir}/amalgalite")

data/ext/amalgalite/{gen_constants.rb → c/gen_constants.rb}

@@ -135,17 +135,17 @@ CONSTANTS = {
 
 }
 
-fname = File.expand_path(File.join(File.dirname(__FILE__), "amalgalite3_constants.c"))
+fname = File.expand_path(File.join(File.dirname(__FILE__), "amalgalite_constants.c"))
 File.open(fname, "w+") do |f|
   f.puts "/* Generated by gen_constants.rb -- do not edit */"
   f.puts
-  f.puts '#include "amalgalite3.h"'
+  f.puts '#include "amalgalite.h"'
   f.puts '/**'
   f.puts ' * Document-class: Amalgalite::SQLite3::Constants'
   f.puts ' *'
   f.puts ' * class holding constants in the sqlite extension'
   f.puts ' */'
-  f.puts "void Init_amalgalite3_constants( )"
+  f.puts "void Init_amalgalite_constants( )"
   f.puts "{"
   f.puts
   f.puts '    VALUE ma  = rb_define_module("Amalgalite");'

data/ext/amalgalite/c/notes.txt

@@ -0,0 +1,134 @@
+Top level "methods"
+===================
+
+  *done* const char* sqlite3_libversion(void)
+  *done* int sqlite3_libversion_number(void)
+  *done* int sqlite3_threadsave(void)
+  *done* int sqlite3_complete(const char*sql);
+  *done* int sqlite3_complete16(const void *sql);
+ 
+  *done* sqlite3_int64 sqlite3_memory_used(void);
+  *done* sqlite3_int64 sqtlie3_memory_highwater(int resetFlag);
+  *done* void sqlite3_randomness(int N, void *p)
+
+  *future* int sqlite3_enabled_shared_cache(int); # TODO maybe
+  *future* int sqlite3_release_memory(int);   // maybe, hook into gc calls ?
+  *future* void sqlite3_soft_heap_limit(int);
+  *future* char* sqlite3_temp_directory;
+
+UTF-8 vs. UTF-16
+----------------
+
+in cases where there is a xxx16() method in the C api, the ruby methods add a
+flag to the method.
+
+Core 'Objects'
+==============
+
+  sqlite3 (typdef struct sqlite3) -> main database handle
+  -------
+  *done* int   sqlite3_open_v2(*filename, sqlite3**, flags, NULL)
+  *done* int   sqlite3_open16
+  *done* int   sqlite3_extended_result_codes(sqlite3, int onoff) # default to turning this on
+  *skipped* called during rb_raise
+  *skipped* const char *sqlite3_errmsg(sqlite3*);
+  *skipped* const void *sqlite3_errmsg16(sqlite3*);
+  *done* int   sqlite3_close(sqlite3 *)
+  *skipped* int   sqlite3_exec -> don't use, wrap in ruby exec
+  *done* sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*)
+  *done* int   sqlite3_get_autocommit(sqlite3*)
+  *done* int   sqlite3_changes(sqlite3*)
+  *done* int   sqlite3_total_changes(sqlite3*)
+  *skipped* int   sqlite3_errcode(sqlite3 *db)
+  *done* int sqlite3_prepare_v2(sqlite3* db, sql, nbyte, sqlite3_stmt**, const char **tail)
+
+  int sqlite3_prepare16_v2(sqlite3* db, sql, nbyte, sqlite3_stmt**, const char **tail)
+
+  // not yet, but implement if/when a purchase of sqlite3 encryption works
+  TODO: int sqlite3_key(sqlite3* db, const void *pKey, int nKey);
+  TODO: int sqlite3_rekey(sqlite3* db, const void *pKey, int nKey);
+
+
+  
+  TODO: int   sqlite3_busy_timeout(sqlite3*)
+  *done* void  sqlite3_progress_hander(sqlite3*, int, int(*)(void*), void*)
+
+  *done* tracing should be an IO object, if it is true then send it to STDERR
+  *done* tracing should also yield a block like a transaction so that during the block the db has tracing turned on.
+  *done* sqlite3_trace
+
+  TODO: create Table and Column classes
+  TODO: int sqlite3_table_column_metadata();
+
+  for later implementation
+  ________________________
+  sqlite3_enable_load_extensions
+  sqlite3_load_extension
+  sqlite3_interrupt
+  sqlite3_busy_handler(sqlite3*, function pointer, void *)
+
+  *skip - experimental* sqlite3_profile
+  *Skip - experimental* sqlite3_limit(sqlite3*, int id, int newVal) -- maybe implement
+  *skip - experimental* sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
+  *skip - experimental* sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
+  *skip - experimental* sqlite3_update_hook(sqlite3*, function ponter, void*);
+
+
+  sqlite3_stmt (typedef struct sqlite3_stmt) -> handle for statements
+  ------------
+  *done* const char *sqlite3_sql(sqlite3_stmt *pStmt)
+  *done* int sqlite3_bind_parameter_count(sqlite3_stmt*);
+
+  *done* sqlite3_bind_double(sqlite3_stmt*, int, double);
+  *done* sqlite3_bind_int(sqlite3_stmt*, int, int);
+  *done* sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
+  *done* sqlite3_bind_null(sqlite3_stmt*, int);
+  *done* sqlite3_bind_text(sqlite3_stmt*, int, constc char*, int n, void(*)(void*));
+  * skipping *sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
+  *done* const char*  sqlite3_bind_parameter_name(sqlite3_stmt*, int )
+  *done* sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
+  *done* sqlite3_clear_bindings(sqlite3_stmt*);
+  *done* sqlite3_column_count(sqlite3_stmt *pStmt);
+  *done* sqlite3_column_name(sqlite3_stmt*, int N);
+  *skip - used internally* sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
+  *done* sqlite3_column_database_name(sqlite3_stmt*, int);
+  *done* sqlite3_column_table_name(sqlite3_stmt*, int);
+  *done* sqlite3_column_origin_name(sqlite3_stmt*, int);
+  *done* sqlite3_step(sqlite3_stmt*);
+  *done - as 'close' *int sqlite3_finalize(sqlite3_stmt *pStmt);
+  *done* int sqlite3_reset(sqlite3_stmt *pStmt);
+  *done - same as sqlite3_column_count* sqlite3_data_count(sqlite3_stmt *pStmt);
+  *do not use* sqlite3_value* sqlite3_column_value(sqlite3_stmt*, int iCol);
+
+  sqlite3_bind_text16(sqlite3_stmt*, int, constc char*, int, void(*)(void*));
+  * done *sqlite3_column_database_name16(sqlite3_stmt*, int);
+  * done *sqlite3_column_table_name16(sqlite3_stmt*, int);
+  * done *sqlite3_column_origin_name16(sqlite3_stmt*, int);
+  sqlite3_column_name16(sqlite3_stmt*, int N);
+
+  *done* sqlite3_column_decltype(sqlite3_stmt*, int);
+  sqlite3_column_decltype16(sqlite3_stmt*, int);
+
+  // use this to find the type and then call the appropriate method afterwards.
+  *done* sqlite3_column_type(sqlite3_stmt*, int iCol);
+
+  # binding by name or index, if passed in an array to the bind() method then
+  # bind by index, if passed in a hash, bind by name, using hte keys of the hash
+  *done* sqlite3_bind_blob(sqlite3_stmt*, int, const void *, int n, void(*)(void*));
+  *done* sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
+
+
+  sqlite3_blob
+  ------------
+  // BLOB
+  *done* sqlite3_blob_open(sqlite3*, *db, *table, *column, rowid, flags, **blob);
+  *done* sqlite3_blob_close(sqlite3_blob*)
+  *done* sqlite3_blob_bytes(sqlite3_blob*)
+  *done* sqlite3_blob_read(sqlite3_blob*, *to_buffer, bytes_to_read, starting_at_offset); 
+  *done* sqlite3_blob_write(sqlite3_blob*, *from_buffer, bytes_to_write, starting_at_offset);
+
+Result Codes
+============
+
+  *done* Convert to Individual Exceptions and allow the top level module generate them
+  based upon integer value