amalgalite 1.4.1-x86-mingw32 → 1.7.0-x86-mingw32

data/ext/amalgalite/c/amalgalite_database.c

@@ -328,22 +328,59 @@ VALUE am_sqlite3_database_exec(VALUE self, VALUE rSQL)
 }
 
 /**
- * This function is registered with a sqlite3 database using the sqlite3_trace
- * function.  During the registration process a handle on a VALUE is also
- * registered.
+ * This function is registered with a sqlite3 database using the
+ * sqlite3_trace_v2 function. During the registration process a handle on a
+ * VALUE is also registered.
  *
  * When this function is called, it calls the 'trace' method on the tap object,
- * which is the VALUE that was registered during the sqlite3_trace call.
+ * which is the VALUE that was registered during the sqlite3_trace_v2 call.
  *
- * This function corresponds to the SQLite xTrace function specification.
+ * This function corresponds to the SQLite xCallback function specification.
+ *
+ * https://sqlite.org/c3ref/c_trace.html
  *
  */
-void amalgalite_xTrace(void* tap, const char* msg)
+int amalgalite_xTraceCallback(unsigned trace_type, void* tap, void* prepared_statement, void* extra)
 {
     VALUE     trace_obj = (VALUE) tap;
+    char*           msg;
+    sqlite3_uint64 time;
+
+    switch(trace_type) {
+        case SQLITE_TRACE_STMT:
+            msg = (char*)extra;
+
+            /* The callback can compute the same text that would have been returned by the
+             * legacy sqlite3_trace() interface by using the X argument when X begins with
+             * "--" and invoking sqlite3_expanded_sql(P) otherwise.
+             */
+            if (0 != strncmp(msg, "--", 2)) {
+                msg = sqlite3_expanded_sql(prepared_statement);
+            }
+
+            rb_funcall( trace_obj, rb_intern("trace"), 1, rb_str_new2( msg ) );
+            break;
 
-    rb_funcall( trace_obj, rb_intern("trace"), 1, rb_str_new2( msg ) );
-    return;
+        case SQLITE_TRACE_PROFILE:
+            msg = sqlite3_expanded_sql(prepared_statement);
+            time = *(sqlite3_uint64*)extra;
+            rb_funcall( trace_obj, rb_intern("profile"),
+                         2, rb_str_new2( msg ), SQLUINT64_2NUM(time) );
+            break;
+
+        case SQLITE_TRACE_ROW:
+            /* not implemented */
+            break;
+
+        case SQLITE_TRACE_CLOSE:
+            /* not implemented */
+            break;
+
+        default:
+            /* nothing */
+            break;
+    }
+    return 0;
 }
 
 
@@ -351,12 +388,16 @@ void amalgalite_xTrace(void* tap, const char* msg)
  * call-seq:
  *   database.register_trace_tap( tap_obj )
  *
- * This registers an object to be called with every trace event in SQLite.
+ * This registers an object to be called for all the trace objects in the sqlite
+ * system. From an SQLite perspective, the trace object is registered for both
+ * SQLITE_TRACE_STMT and SQLITE_TRACE_PROFILE.
  *
+ * The object must respond to both `trace` and `profile` methods. See
+ * Amalgalite::Trace::
  * This is an experimental api and is subject to change, or removal.
  *
  */
-VALUE am_sqlite3_database_register_trace_tap(VALUE self, VALUE tap)
+VALUE am_sqlite3_database_register_trace_tap(VALUE self, VALUE tap )
 {
     am_sqlite3   *am_db;
 
@@ -367,7 +408,7 @@ VALUE am_sqlite3_database_register_trace_tap(VALUE self, VALUE tap)
      */
     if ( Qnil == tap ) {
 
-        sqlite3_trace( am_db->db, NULL, NULL );
+        sqlite3_trace_v2( am_db->db, 0, NULL, NULL );
         rb_gc_unregister_address( &(am_db->trace_obj) );
         am_db->trace_obj = Qnil;
 
@@ -379,65 +420,12 @@ VALUE am_sqlite3_database_register_trace_tap(VALUE self, VALUE tap)
 
         am_db->trace_obj = tap;
         rb_gc_register_address( &(am_db->trace_obj) );
-        sqlite3_trace( am_db->db, amalgalite_xTrace, (void *)am_db->trace_obj );
+        sqlite3_trace_v2( am_db->db, SQLITE_TRACE_STMT | SQLITE_TRACE_PROFILE, amalgalite_xTraceCallback, (void *)am_db->trace_obj );
     }
 
     return Qnil;
 }
 
-
-/**
- * the amagliate trace function to be registered with register_trace_tap
- * When it is called, it calls the 'trace' method on the tap object.
- *
- * This function conforms to the sqlite3 xProfile function specification.
- */
-void amalgalite_xProfile(void* tap, const char* msg, sqlite3_uint64 time)
-{
-    VALUE     trace_obj = (VALUE) tap;
-
-    rb_funcall( trace_obj, rb_intern("profile"),
-                2, rb_str_new2( msg ), SQLUINT64_2NUM(time) );
-
-    return;
-}
-
-/**
- * call-seq:
- *   database.register_profile_tap( tap_obj )
- *
- * This registers an object to be called with every profile event in SQLite.
- *
- * This is an experimental api and is subject to change or removal.
- *
- */
-VALUE am_sqlite3_database_register_profile_tap(VALUE self, VALUE tap)
-{
-    am_sqlite3   *am_db;
-
-    Data_Get_Struct(self, am_sqlite3, am_db);
-
-    /* Qnil, unregister the item and tell the garbage collector we are done with
-     * it.
-     */
-
-    if ( tap == Qnil ) {
-        sqlite3_profile( am_db->db, NULL, NULL );
-        rb_gc_unregister_address( &(am_db->profile_obj) );
-        am_db->profile_obj = Qnil;
-
-    /* register the item and store the reference to the object in the am_db
-     * structure.  We also have to tell the Ruby garbage collector that we
-     * point to the Ruby object from C.
-     */
-    } else {
-        am_db->profile_obj = tap;
-        rb_gc_register_address( &(am_db->profile_obj) );
-        sqlite3_profile( am_db->db, amalgalite_xProfile, (void *)am_db->profile_obj );
-    }
-    return Qnil;
-}
-
 /**
  * invoke a ruby function.  This is here to be used by rb_protect.
  */
@@ -794,8 +782,11 @@ void amalgalite_xStep( sqlite3_context* context, int argc, sqlite3_value** argv
         VALUE klass = (VALUE) sqlite3_user_data( context );
         result = rb_protect( amalgalite_wrap_new_aggregate, klass, &state );
 
+        /* exception was raised during initialization */
         if ( state ) {
-            VALUE msg = ERROR_INFO_MESSAGE();
+            *aggregate_context = rb_gv_get("$!");
+            rb_gc_register_address( aggregate_context );
+            VALUE msg = rb_obj_as_string( *aggregate_context );
             sqlite3_result_error( context, RSTRING_PTR(msg), (int)RSTRING_LEN(msg));
             return;
         } else {
@@ -844,8 +835,30 @@ void amalgalite_xFinal( sqlite3_context* context )
     VALUE          result;
     int            state;
     am_protected_t protected;
+    VALUE          exception = Qnil;
     VALUE         *aggregate_context = (VALUE*)sqlite3_aggregate_context( context, sizeof( VALUE ) );
-    VALUE          exception = rb_iv_get( *aggregate_context, "@_exception" );
+
+    /**
+     * check and see if an exception had been throw at some point during the
+     * initialization of hte aggregate or during the step function call
+     *
+     */
+    if (TYPE(*aggregate_context) == T_OBJECT) {
+        /* if there is a @_exception value and it has a value then there was an
+         * exception during step function execution
+         */
+        if (rb_ivar_defined( *aggregate_context, rb_intern("@_exception") )) {
+            exception = rb_iv_get( *aggregate_context, "@_exception" );
+        } else {
+
+            /* if the aggregate context itself is an exception, then there was
+             * an error during teh initialization of the aggregate context
+             */
+            if (rb_obj_is_kind_of( *aggregate_context, rb_eException )) {
+                exception = *aggregate_context;
+            }
+        }
+    }
 
     if ( Qnil == exception ) {
         /* gather all the data to make the protected call */
@@ -868,8 +881,6 @@ void amalgalite_xFinal( sqlite3_context* context )
         sqlite3_result_error( context, RSTRING_PTR(msg), (int)RSTRING_LEN(msg) );
     }
 
-
-
     /* release the aggregate instance from garbage collector protection */
     rb_gc_unregister_address( aggregate_context );
 
@@ -1151,7 +1162,6 @@ void Init_amalgalite_database( )
     rb_define_method(cAS_Database, "last_insert_rowid", am_sqlite3_database_last_insert_rowid, 0); /* in amalgalite_database.c */
     rb_define_method(cAS_Database, "autocommit?", am_sqlite3_database_is_autocommit, 0); /* in amalgalite_database.c */
     rb_define_method(cAS_Database, "register_trace_tap", am_sqlite3_database_register_trace_tap, 1); /* in amalgalite_database.c */
-    rb_define_method(cAS_Database, "register_profile_tap", am_sqlite3_database_register_profile_tap, 1); /* in amalgalite_database.c */
     rb_define_method(cAS_Database, "table_column_metadata", am_sqlite3_database_table_column_metadata, 3); /* in amalgalite_database.c */
     rb_define_method(cAS_Database, "row_changes", am_sqlite3_database_row_changes, 0); /* in amalgalite_database.c */
     rb_define_method(cAS_Database, "total_changes", am_sqlite3_database_total_changes, 0); /* in amalgalite_database.c */

data/ext/amalgalite/c/extconf.rb

@@ -6,13 +6,31 @@ require 'rbconfig'
 $ruby = ARGV.shift if ARGV[0]
 
 # make available table and column meta data api
+$CFLAGS += " -DSQLITE_ENABLE_BYTECODE_VTAB=1"
 $CFLAGS += " -DSQLITE_ENABLE_COLUMN_METADATA=1"
 $CFLAGS += " -DSQLITE_ENABLE_DBSTAT_VTAB=1"
-$CFLAGS += " -DSQLITE_ENABLE_RTREE=1"
+$CFLAGS += " -DSQLITE_ENABLE_DBPAGE_VTAB=1"
+$CFLAGS += " -DSQLITE_ENABLE_DESERIALIZE=1"
+$CFLAGS += " -DSQLITE_ENABLE_EXPLAIN_COMMENTS=1"
 $CFLAGS += " -DSQLITE_ENABLE_FTS3=1"
 $CFLAGS += " -DSQLITE_ENABLE_FTS3_PARENTHESIS=1"
 $CFLAGS += " -DSQLITE_ENABLE_FTS4=1"
+$CFLAGS += " -DSQLITE_ENABLE_FTS5=1"
+$CFLAGS += " -DSQLITE_ENABLE_GEOPOLY=1"
+$CFLAGS += " -DSQLITE_ENABLE_JSON1=1"
+$CFLAGS += " -DSQLITE_ENABLE_MEMORY_MANAGEMENT=1"
+$CFLAGS += " -DSQLITE_ENABLE_NULL_TRIM=1"
+$CFLAGS += " -DSQLITE_ENABLE_PREUPDATE_HOOK=1"
+$CFLAGS ++ " -DSQLITE_EANBLE_QPSG=1"
+$CFLAGS += " -DSQLITE_ENABLE_RBU=1"
+$CFLAGS += " -DSQLITE_ENABLE_RTREE=1"
+$CFLAGS += " -DSQLITE_ENABLE_SESSION=1"
+$CFLAGS += " -DSQLITE_ENABLE_SNAPSHOT=1"
+$CFLAGS += " -DSQLITE_ENABLE_STMTVTAB=1"
 $CFLAGS += " -DSQLITE_ENABLE_STAT4=1"
+$CFLAGS += " -DSQLITE_ENABLE_UNLOCK_NOTIFY=1"
+
+$CFLAGS += " -DSQLITE_OMIT_DEPRECATED=1"
 
 # we compile sqlite the same way that the installation of ruby is compiled.
 if RbConfig::MAKEFILE_CONFIG['configure_args'].include?( "--enable-pthread" ) then
@@ -23,12 +41,21 @@ end
 
 # remove the -g flags  if it exists
 %w[ -ggdb\\d* -g\\d* ].each do |debug|
-  $CFLAGS = $CFLAGS.gsub(/#{debug}/,'')
-  RbConfig::MAKEFILE_CONFIG['debugflags'] = RbConfig::MAKEFILE_CONFIG['debugflags'].gsub(/#{debug}/,'')   if RbConfig::MAKEFILE_CONFIG['debugflags']
+  $CFLAGS = $CFLAGS.gsub(/\s#{debug}\b/,'')
+  RbConfig::MAKEFILE_CONFIG['debugflags'] = RbConfig::MAKEFILE_CONFIG['debugflags'].gsub(/\s#{debug}\b/,'')   if RbConfig::MAKEFILE_CONFIG['debugflags']
 end
 
 ignoreable_warnings = %w[ write-strings ]
-ignore_by_compiler = { "clang" => %w[ unused-const-variable shorten-64-to-32 incompatible-pointer-types-discards-qualifiers] }
+ignore_by_compiler = {
+  "clang" => %w[
+                  empty-body
+                  incompatible-pointer-types-discards-qualifiers
+                  shorten-64-to-32
+                  sign-compare
+                  unused-const-variable
+                  unused-variable
+                ]
+}
 
 if extras = ignore_by_compiler[RbConfig::MAKEFILE_CONFIG["CC"]] then
   ignoreable_warnings.concat(extras)

data/ext/amalgalite/c/gen_constants.rb

@@ -1,141 +1,311 @@
 #!/usr/bin/env ruby
 
-CONSTANTS = {
-  "ResultCode" => {
-    "OK"          => "SQLITE_OK",
-    "ERROR"       => "SQLITE_ERROR",
-    "INTERNAL"    => "SQLITE_INTERNAL",
-    "PERM"        => "SQLITE_PERM",
-    "ABORT"       => "SQLITE_ABORT",
-    "BUSY"        => "SQLITE_BUSY",
-    "LOCKED"      => "SQLITE_LOCKED",
-    "NOMEM"       => "SQLITE_NOMEM",
-    "READONLY"    => "SQLITE_READONLY",
-    "INTERRUPT"   => "SQLITE_INTERRUPT",
-    "IOERR"       => "SQLITE_IOERR",
-    "CORRUPT"     => "SQLITE_CORRUPT",
-    "NOTFOUND"    => "SQLITE_NOTFOUND",
-    "FULL"        => "SQLITE_FULL",
-    "CANTOPEN"    => "SQLITE_CANTOPEN",
-    "PROTOCOL"    => "SQLITE_PROTOCOL",
-    "EMPTY"       => "SQLITE_EMPTY",
-    "SCHEMA"      => "SQLITE_SCHEMA",
-    "TOOBIG"      => "SQLITE_TOOBIG",
-    "CONSTRAINT"  => "SQLITE_CONSTRAINT",
-    "MISMATCH"    => "SQLITE_MISMATCH",
-    "MISUSE"      => "SQLITE_MISUSE",
-    "NOLFS"       => "SQLITE_NOLFS",
-    "AUTH"        => "SQLITE_AUTH",
-    "FORMAT"      => "SQLITE_FORMAT",
-    "RANGE"       => "SQLITE_RANGE",
-    "NOTADB"      => "SQLITE_NOTADB",
-    "ROW"         => "SQLITE_ROW",
-    "DONE"        => "SQLITE_DONE",
-
-    "IOERR_READ"                => "SQLITE_IOERR_READ",
-    "IOERR_SHORT_READ"          => "SQLITE_IOERR_SHORT_READ",
-    "IOERR_WRITE"               => "SQLITE_IOERR_WRITE",
-    "IOERR_FSYNC"               => "SQLITE_IOERR_FSYNC",
-    "IOERR_DIR_FSYNC"           => "SQLITE_IOERR_DIR_FSYNC",
-    "IOERR_TRUNCATE"            => "SQLITE_IOERR_TRUNCATE",
-    "IOERR_FSTAT"               => "SQLITE_IOERR_FSTAT",
-    "IOERR_UNLOCK"              => "SQLITE_IOERR_UNLOCK",
-    "IOERR_RDLOCK"              => "SQLITE_IOERR_RDLOCK",
-    "IOERR_DELETE"              => "SQLITE_IOERR_DELETE",
-    "IOERR_BLOCKED"             => "SQLITE_IOERR_BLOCKED",
-    "IOERR_NOMEM"               => "SQLITE_IOERR_NOMEM",
-    "IOERR_ACCESS"              => "SQLITE_IOERR_ACCESS",
-    "IOERR_CHECKRESERVEDLOCK"   => "SQLITE_IOERR_CHECKRESERVEDLOCK",
-    "IOERR_LOCK"                => "SQLITE_IOERR_LOCK",
-    "IOERR_CLOSE"               => "SQLITE_IOERR_CLOSE",
-    "IOERR_DIR_CLOSE"           => "SQLITE_IOERR_DIR_CLOSE",
-    "IOERR_SHMOPEN"             => "SQLITE_IOERR_SHMOPEN",
-    "IOERR_SHMSIZE"             => "SQLITE_IOERR_SHMSIZE",
-    "IOERR_SHMLOCK"             => "SQLITE_IOERR_SHMLOCK",
-
-    "LOCKED_SHAREDCACHE"  => "SQLITE_LOCKED_SHAREDCACHE",
-    "BUSY_RECOVERY"       => "SQLITE_BUSY_RECOVERY",
-    "CANTOPEN_NOTEMPDIR"  => "SQLITE_CANTOPEN_NOTEMPDIR",
-  },
-
-
-  "DataType" => {
-    "INTEGER"   => "SQLITE_INTEGER",
-    "FLOAT"     => "SQLITE_FLOAT",
-    "BLOB"      => "SQLITE_BLOB",
-    "NULL"      => "SQLITE_NULL",
-    "TEXT"      => "SQLITE_TEXT",
-  },
-
-  "Config" => {
-    "SINGLETHREAD"  => "SQLITE_CONFIG_SINGLETHREAD",
-    "MULTITHREAD"   => "SQLITE_CONFIG_MULTITHREAD",
-    "SERIALIZED"    => "SQLITE_CONFIG_SERIALIZED",
-    "MALLOC"        => "SQLITE_CONFIG_MALLOC",
-    "GETMALLOC"     => "SQLITE_CONFIG_GETMALLOC",
-    "SCRATCH"       => "SQLITE_CONFIG_SCRATCH",
-    "PAGECACHE"     => "SQLITE_CONFIG_PAGECACHE",
-    "HEAP"          => "SQLITE_CONFIG_HEAP",
-    "MEMSTATUS"     => "SQLITE_CONFIG_MEMSTATUS",
-    "MUTEX"         => "SQLITE_CONFIG_MUTEX",
-    "GETMUTEX"      => "SQLITE_CONFIG_GETMUTEX",
-    "LOOKASIDE"     => "SQLITE_CONFIG_LOOKASIDE",
-    "PCACHE"        => "SQLITE_CONFIG_PCACHE",
-    "GETPCACHE"     => "SQLITE_CONFIG_GETPCACHE",
-    "LOG"           => "SQLITE_CONFIG_LOG",
-  },
-
-  "Open" => {
-    "READONLY"        => "SQLITE_OPEN_READONLY",
-    "READWRITE"       => "SQLITE_OPEN_READWRITE",
-    "CREATE"          => "SQLITE_OPEN_CREATE",
-    "DELETEONCLOSE"   => "SQLITE_OPEN_DELETEONCLOSE",
-    "EXCLUSIVE"       => "SQLITE_OPEN_EXCLUSIVE",
-    "AUTOPROXY"       => "SQLITE_OPEN_AUTOPROXY",
-    "MAIN_DB"         => "SQLITE_OPEN_MAIN_DB",
-    "TEMP_DB"         => "SQLITE_OPEN_TEMP_DB",
-    "TRANSIENT_DB"    => "SQLITE_OPEN_TRANSIENT_DB",
-    "MAIN_JOURNAL"    => "SQLITE_OPEN_MAIN_JOURNAL",
-    "TEMP_JOURNAL"    => "SQLITE_OPEN_TEMP_JOURNAL",
-    "SUBJOURNAL"      => "SQLITE_OPEN_SUBJOURNAL",
-    "MASTER_JOURNAL"  => "SQLITE_OPEN_MASTER_JOURNAL",
-    "NOMUTEX"         => "SQLITE_OPEN_NOMUTEX",
-    "FULLMUTEX"       => "SQLITE_OPEN_FULLMUTEX",
-    "SHAREDCACHE"     => "SQLITE_OPEN_SHAREDCACHE",
-    "PRIVATECACHE"    => "SQLITE_OPEN_PRIVATECACHE",
-    "WAL"             => "SQLITE_OPEN_WAL",
-  },
-
-  "Status" => {
-    "MEMORY_USED"         => "SQLITE_STATUS_MEMORY_USED",
-    "PAGECACHE_USED"      => "SQLITE_STATUS_PAGECACHE_USED",
-    "PAGECACHE_OVERFLOW"  => "SQLITE_STATUS_PAGECACHE_OVERFLOW",
-    "SCRATCH_USED"        => "SQLITE_STATUS_SCRATCH_USED",
-    "SCRATCH_OVERFLOW"    => "SQLITE_STATUS_SCRATCH_OVERFLOW",
-    "MALLOC_SIZE"         => "SQLITE_STATUS_MALLOC_SIZE",
-    "PARSER_STACK"        => "SQLITE_STATUS_PARSER_STACK",
-    "PAGECACHE_SIZE"      => "SQLITE_STATUS_PAGECACHE_SIZE",
-    "SCRATCH_SIZE"        => "SQLITE_STATUS_SCRATCH_SIZE",
-    "MALLOC_COUNT"        => "SQLITE_STATUS_MALLOC_COUNT",
-  },
-
-  "DBStatus" => { 
-    "LOOKASIDE_USED" => "SQLITE_DBSTATUS_LOOKASIDE_USED",
-    "CACHE_USED"     => "SQLITE_DBSTATUS_CACHE_USED",
-    "SCHEMA_USED"    => "SQLITE_DBSTATUS_SCHEMA_USED",
-    "STMT_USED"      => "SQLITE_DBSTATUS_STMT_USED",
-    "MAX"            => "SQLITE_DBSTATUS_MAX",
-  },
-
-  "StatementStatus" => {
-    "FULLSCAN_STEP"   => "SQLITE_STMTSTATUS_FULLSCAN_STEP",
-    "SORT"            => "SQLITE_STMTSTATUS_SORT",
-    "AUTOINDEX"       => "SQLITE_STMTSTATUS_AUTOINDEX",
-  }
+require 'pp'
+
+# readin in the sqlite3.h file and parse out all the #define lines
+sqlite3_h_fname = File.expand_path(File.join(File.dirname(__FILE__), "sqlite3.h"))
+
+# special handling for those that are function result codes
+result_codes = %w[
+  SQLITE_OK
+  SQLITE_ERROR
+  SQLITE_INTERNAL
+  SQLITE_PERM
+  SQLITE_ABORT
+  SQLITE_BUSY
+  SQLITE_LOCKED
+  SQLITE_NOMEM
+  SQLITE_READONLY
+  SQLITE_INTERRUPT
+  SQLITE_IOERR
+  SQLITE_CORRUPT
+  SQLITE_NOTFOUND
+  SQLITE_FULL
+  SQLITE_CANTOPEN
+  SQLITE_PROTOCOL
+  SQLITE_EMPTY
+  SQLITE_SCHEMA
+  SQLITE_TOOBIG
+  SQLITE_CONSTRAINT
+  SQLITE_MISMATCH
+  SQLITE_MISUSE
+  SQLITE_NOLFS
+  SQLITE_AUTH
+  SQLITE_FORMAT
+  SQLITE_RANGE
+  SQLITE_NOTADB
+  SQLITE_NOTICE
+  SQLITE_WARNING
+  SQLITE_ROW
+  SQLITE_DONE
+  SQLITE_ERROR_MISSING_COLLSEQ
+  SQLITE_ERROR_RETRY
+  SQLITE_ERROR_SNAPSHOT
+  SQLITE_IOERR_READ
+  SQLITE_IOERR_SHORT_READ
+  SQLITE_IOERR_WRITE
+  SQLITE_IOERR_FSYNC
+  SQLITE_IOERR_DIR_FSYNC
+  SQLITE_IOERR_TRUNCATE
+  SQLITE_IOERR_FSTAT
+  SQLITE_IOERR_UNLOCK
+  SQLITE_IOERR_RDLOCK
+  SQLITE_IOERR_DELETE
+  SQLITE_IOERR_BLOCKED
+  SQLITE_IOERR_NOMEM
+  SQLITE_IOERR_ACCESS
+  SQLITE_IOERR_CHECKRESERVEDLOCK
+  SQLITE_IOERR_LOCK
+  SQLITE_IOERR_CLOSE
+  SQLITE_IOERR_DIR_CLOSE
+  SQLITE_IOERR_SHMOPEN
+  SQLITE_IOERR_SHMSIZE
+  SQLITE_IOERR_SHMLOCK
+  SQLITE_IOERR_SHMMAP
+  SQLITE_IOERR_SEEK
+  SQLITE_IOERR_DELETE_NOENT
+  SQLITE_IOERR_MMAP
+  SQLITE_IOERR_GETTEMPPATH
+  SQLITE_IOERR_CONVPATH
+  SQLITE_IOERR_VNODE
+  SQLITE_IOERR_AUTH
+  SQLITE_IOERR_BEGIN_ATOMIC
+  SQLITE_IOERR_COMMIT_ATOMIC
+  SQLITE_IOERR_ROLLBACK_ATOMIC
+  SQLITE_IOERR_DATA
+  SQLITE_IOERR_CORRUPTFS
+  SQLITE_LOCKED_SHAREDCACHE
+  SQLITE_LOCKED_VTAB
+  SQLITE_BUSY_RECOVERY
+  SQLITE_BUSY_SNAPSHOT
+  SQLITE_BUSY_TIMEOUT
+  SQLITE_CANTOPEN_NOTEMPDIR
+  SQLITE_CANTOPEN_ISDIR
+  SQLITE_CANTOPEN_FULLPATH
+  SQLITE_CANTOPEN_CONVPATH
+  SQLITE_CANTOPEN_DIRTYWAL
+  SQLITE_CANTOPEN_SYMLINK
+  SQLITE_CORRUPT_VTAB
+  SQLITE_CORRUPT_SEQUENCE
+  SQLITE_CORRUPT_INDEX
+  SQLITE_READONLY_RECOVERY
+  SQLITE_READONLY_CANTLOCK
+  SQLITE_READONLY_ROLLBACK
+  SQLITE_READONLY_DBMOVED
+  SQLITE_READONLY_CANTINIT
+  SQLITE_READONLY_DIRECTORY
+  SQLITE_ABORT_ROLLBACK
+  SQLITE_CONSTRAINT_CHECK
+  SQLITE_CONSTRAINT_COMMITHOOK
+  SQLITE_CONSTRAINT_FOREIGNKEY
+  SQLITE_CONSTRAINT_FUNCTION
+  SQLITE_CONSTRAINT_NOTNULL
+  SQLITE_CONSTRAINT_PRIMARYKEY
+  SQLITE_CONSTRAINT_TRIGGER
+  SQLITE_CONSTRAINT_UNIQUE
+  SQLITE_CONSTRAINT_VTAB
+  SQLITE_CONSTRAINT_ROWID
+  SQLITE_CONSTRAINT_PINNED
+  SQLITE_NOTICE_RECOVER_WAL
+  SQLITE_NOTICE_RECOVER_ROLLBACK
+  SQLITE_WARNING_AUTOINDEX
+  SQLITE_AUTH_USER
+  SQLITE_OK_LOAD_PERMANENTLY
+  SQLITE_OK_SYMLINK
+]
+
+deprecated_codes = %w[ SQLITE_GET_LOCKPROXYFILE SQLITE_SET_LOCKPROXYFILE SQLITE_LAST_ERRNO ]
+version_codes    = %w[ SQLITE_VERSION SQLITE_VERSION_NUMBER SQLITE_SOURCE_ID ]
+rtree_codes      = %w[ NOT_WITHIN PARTLY_WITHIN FULLY_WITHIN ]
+
+authorizer_codes = %w[
+  SQLITE_DENY
+  SQLITE_IGNORE
+  SQLITE_CREATE_INDEX
+  SQLITE_CREATE_TABLE
+  SQLITE_CREATE_TEMP_INDEX
+  SQLITE_CREATE_TEMP_TABLE
+  SQLITE_CREATE_TEMP_TRIGGER
+  SQLITE_CREATE_TEMP_VIEW
+  SQLITE_CREATE_TRIGGER
+  SQLITE_CREATE_VIEW
+  SQLITE_DELETE
+  SQLITE_DROP_INDEX
+  SQLITE_DROP_TABLE
+  SQLITE_DROP_TEMP_INDEX
+  SQLITE_DROP_TEMP_TABLE
+  SQLITE_DROP_TEMP_TRIGGER
+  SQLITE_DROP_TEMP_VIEW
+  SQLITE_DROP_TRIGGER
+  SQLITE_DROP_VIEW
+  SQLITE_INSERT
+  SQLITE_PRAGMA
+  SQLITE_READ
+  SQLITE_SELECT
+  SQLITE_TRANSACTION
+  SQLITE_UPDATE
+  SQLITE_ATTACH
+  SQLITE_DETACH
+  SQLITE_ALTER_TABLE
+  SQLITE_REINDEX
+  SQLITE_ANALYZE
+  SQLITE_CREATE_VTABLE
+  SQLITE_DROP_VTABLE
+  SQLITE_FUNCTION
+  SQLITE_SAVEPOINT
+  SQLITE_COPY
+  SQLITE_RECURSIVE
+]
+
+text_encoding_codes = %w[
+  SQLITE_UTF8
+  SQLITE_UTF16LE
+  SQLITE_UTF16BE
+  SQLITE_UTF16
+  SQLITE_ANY
+  SQLITE_UTF16_ALIGNED
+  SQLITE_DETERMINISTIC
+  SQLITE_DIRECTONLY
+  SQLITE_SUBTYPE
+  SQLITE_INNOCUOUS
+]
+
+data_type_codes = %w[
+  SQLITE_INTEGER
+  SQLITE_FLOAT
+  SQLITE_BLOB
+  SQLITE_NULL
+  SQLITE3_TEXT
+]
+
+fts5_codes = %w[
+  FTS5_TOKENIZE_QUERY
+  FTS5_TOKENIZE_PREFIX
+  FTS5_TOKENIZE_DOCUMENT
+  FTS5_TOKENIZE_AUX
+  FTS5_TOKEN_COLOCATED
+]
+
+ignore_codes = [
+  # vtab related
+  "SQLITE_ROLLBACK",
+  "SQLITE_FAIL",
+  "SQLITE_REPLACE",
+  "SQLITE_VTAB_CONSTRAINT_SUPPORT",
+  "SQLITE_VTAB_INNOCUOUS",
+  "SQLITE_VTAB_DIRECTONLY",
+
+  # sqlite destructor callback codes
+  "SQLITE_STATIC",
+  "SQLITE_TRANSIENT",
+]
+
+# oddball name
+module_name_mapping  = {
 
+  "DBCONFIG"   => "DBConfig",
+  "DBSTATUS"   => "DBStatus",
+  "IOCAP"      => "IOCap",
+  "SHM"        => "SHM",
+  "SCANSTAT"   => "ScanStat",
+  "STMTSTATUS" => "StatementStatus",
+  "CHANGESETAPPLY" => "ChangesetApply",
+  "CHANGESETSTART" => "ChangesetStart",
+  "TXN" => "Transaction",
 }
 
+defines = []
+IO.readlines(sqlite3_h_fname).each do |l|
+  result = {
+    "c_define"  => nil,
+    "c_value"   => nil,
+    "docstring" => nil,
+
+    "is_error_code" => false,
+
+    "r_module"   => nil,
+    "r_constant" => nil,
+  }
+
+  if l =~ /beginning-of-error-codes/ .. l =~ /end-of-error-codes/ then
+    result["is_error_code"] = true
+  end
+
+  l.strip!
+  md = l.match(/\A#define\s+(\w+)\s+([^\/]+)\s*(\/\*(.*)\*\/)?\Z/)
+  next unless md
+
+  # Name munging
+  c_define = md[1]
+
+  c_parts    = c_define.gsub(/^SQLITE_/,'').split("_")
+  r_module   = c_parts.shift
+  r_constant = c_parts.join("_")
+
+
+  # custom module naming so they are human readable
+  r_module = module_name_mapping.fetch(r_module) { |m| r_module.capitalize }
+
+  case c_define
+  when *version_codes
+    next
+
+  when *deprecated_codes
+    next
+
+  when *rtree_codes
+    r_module = "RTree"
+    r_constant = c_define
+
+  when *result_codes
+    r_module   = "ResultCode"
+    r_constant = c_define.gsub(/^SQLITE_/,'')
+
+  when *authorizer_codes
+    r_module   = "Authorizer"
+    r_constant = c_define.gsub(/^SQLITE_/,'')
+
+  when *text_encoding_codes
+    r_module   = "TextEncoding"
+    r_constant = c_define.gsub(/^SQLITE_/,'')
+
+  when *data_type_codes
+    r_module = "DataType"
+    r_constant = c_define.gsub(/^SQLITE(3)?_/,'')
+
+  when *fts5_codes
+    r_module = "FTS5"
+    r_constant = c_define.gsub(/^FTS5_/,'')
+
+  when *ignore_codes
+    next
+
+  when /TESTCTRL/ # sqlite3 codes used in testing
+    next
+
+  when /^__/ # sqlite3 internal items
+    next
+  end
+
+  result["c_define"]   = c_define
+  result["c_value"]    = md[2].strip
+  if !md[4].nil? && (md[4].strip.length > 0) then
+    result["docstring"]  = md[4].strip
+  end
+  result["r_module"]   = r_module
+  result["r_constant"] = r_constant
+
+  defines << result
+end
+
+#
+# rework defines into constants
+#
+CONSTANTS = defines.group_by{ |d| d["r_module"] }
+
 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
@@ -157,35 +327,25 @@ File.open(fname, "w+") do |f|
   f.puts '    VALUE mC = rb_define_module_under( mas, "Constants");'
 
 
-  error_code_lines = {}
-  IO.readlines("sqlite3.h").each do |l|
-    if l =~ /beginning-of-error-codes/ .. l =~ /end-of-error-codes/ then
-      next if l =~ /of-error-codes/
-      l.strip!
-      md = l.match(/\A#define\s+(\w+)\s+(\d+)\s+\/\*(.*)\*\/\Z/)
-      error_code_lines[md[1]] = { 'value' => md[2].strip, 'meaning' => md[3].strip } 
-    end
-  end
-
-  CONSTANTS.keys.sort.each do |klass|
-    const_set = CONSTANTS[klass]
+  CONSTANTS.keys.sort.each do |mod|
     f.puts "    /**"
-    f.puts "     * module encapsulating the SQLite3 C extension constants for #{klass}"
+    f.puts "     * module encapsulating the SQLite3 C extension constants for #{mod}"
     f.puts "     */"
-    f.puts "    VALUE mC_#{klass} = rb_define_module_under(mC, \"#{klass}\");"
+    f.puts "    VALUE mC_#{mod} = rb_define_module_under(mC, \"#{mod}\");"
     f.puts 
   end
 
-  CONSTANTS.keys.sort.each do |klass|
-    const_set = CONSTANTS[klass]
-    const_set.keys.sort.each do |k|
-      sql_const = const_set[k]
+  CONSTANTS.keys.sort.each do |mod|
+    const_set = CONSTANTS[mod]
+    const_set.sort_by { |c| c["c_define"] }.each do |result|
+      sql_const = result["c_define"]
       const_doc = "    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/" 
-      if ecl = error_code_lines[sql_const] then
-        const_doc = "    /*  #{ecl['value']} -- #{ecl['meaning']} */"
+      if !result["docstring"].nil? then
+        const_doc = "    /*  #{result['c_value']} -- #{result['docstring']} */"
       end
+      ruby_constant = result['r_constant']
       f.puts const_doc
-      f.puts "    rb_define_const(mC_#{klass}, \"#{k}\", INT2FIX(#{sql_const}));"
+      f.puts "    rb_define_const(mC_#{mod}, \"#{ruby_constant}\", INT2FIX(#{sql_const}));"
       f.puts  
     end
   end