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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0d44f0fbc6657bd70997a3e4dc9f311abda5ad79
-  data.tar.gz: ebb1291022da4094e6d08d624c572c718a28ae89
+SHA256:
+  metadata.gz: 6860e818e8bcbc729061035834f7cd52eb8f29c12cd522705ab9a382102c73bd
+  data.tar.gz: cbbb6ec1498fe7ddadd8aa7d96beb5b86c70686e0745b3ecd05da0e2b53bd3bd
 SHA512:
-  metadata.gz: 3e6989c8f5522cc2f41fa82713a66dbc845d51fa8db4f8f6f767e675637b95542ea6976ef5729ef417883b98ff6c89bac4a506e01043ea1461268f069ea36ef8
-  data.tar.gz: 04f18489a97cf10e5b6f7d18d536e19d88fbd7501f91dee8a23192cf70f8ca837372b3c91bbe4ef60e5e9ed4ded73243ac3fd61584e1ab11e4806cde441089b8
+  metadata.gz: 12b6eedca1401172614802ee99d6306be4eed63767d43e81500c0499a4e6436105be869994beec5c22498613f6cef07fabae265948dc5ca035dd3a1145a9e02e
+  data.tar.gz: eb5b0584dff7e11c3eaea89d61f32e06d09a8eda46dd6d9e2e613ac867b430398104e994fde804063301e631e50fe37674597981b76c3b2f586800224d517a8a

data/CONTRIBUTING.md

@@ -33,6 +33,17 @@ easiest way to contribute.
 * Add yourself to the contributors section below.
 * Submit your [pull request][].
 
+## Building Windows Binaries
+
+This is done using https://github.com/rake-compiler/rake-compiler-dock
+
+1. have VirtualBox installed
+2. have Docker Machine installed (https://docs.docker.com/engine/installation/)
+3. `gem install rake-compiler-dock`
+4. `rake-compiler-dock` (this could take a while)
+5. `bundle`
+6. `rake cross native gem`
+
 # Contributors
 
 * [Jeremy Hinegardner](https://github.com/copiousfreetime)

data/HISTORY.md

@@ -1,5 +1,50 @@
 # Amalgalite Changelog
 
+## Version 1.7.0 - 2021-01-13
+
+* Update to SQLite to 3.34.0
+* enable new compile time options
+  * SQLITE_ENABLE_BYTECODE_VGAB
+  * SQLITE_ENABLE_DESERIALIZE
+  * SQLITE_ENABLE_EXPLAIN_COMMENTS
+  * SQLITE_ENABLE_NULL_TRIM
+  * SQLITE_ENABLE_QPSG
+  * SQLITE_ENABLE_SNAPSHOT
+* resolve ruby deprecations for ruby 2.7.2
+* rework the aggregator interface to handle issue with ruby warnings.
+
+## Version 1.6.3 - 2019-01-19
+
+* Update to SQLite 3.26.0
+* enable new compile time options
+  * SQLITE_ENABLE_GEOPOLY
+
+## Version 1.6.2 - 2018-11-10
+
+* Update to SQLite 3.25.3
+
+## Version 1.6.1 - 2018-01-02
+
+* Fix bug when using the `json` extension
+
+## Version 1.6.0 - 2017-12-13
+
+* Update to SQLite 3.21.0
+* source id access methods
+  * Amalgalite::SQLite3::Version.compiled_source_id
+  * Amalgalite::SQLite3::Version.runtime_source_id
+* enable new compile time options
+  * SQLITE_ENABLE_DBPAGE_VTAB
+  * SQLITE_ENABLE_MEMORY_MANAGEMENT
+  * SQLITE_ENABLE_PREUPDATE_HOOK
+  * SQLITE_ENABLE_SESSION
+  * SQLITE_ENABLE_STMTVTAB
+
+## Version 1.5.0 - 2015-12-06
+
+* Update to SQLite 3.9.2
+* Enable new SQLite features FTS5, JSON1
+
 ## Version 1.4.1 - 2015-09-13
 
 * Update to SQLite 3.8.11.1

data/LICENSE

@@ -1,3 +1,5 @@
+BSD License - https://opensource.org/licenses/BSD-3-Clause
+
 Copyright (c) 2008-2012 Jeremy Hinegardner
 
 All rights reserved.

data/Manifest.txt

@@ -11,7 +11,7 @@ examples/blob.rb
 examples/bootstrap.rb
 examples/define_aggregate.rb
 examples/define_function.rb
-examples/fts3.rb
+examples/fts5.rb
 examples/gem-db.rb
 examples/require_me.rb
 examples/requires.rb
@@ -80,6 +80,7 @@ spec/default_map_spec.rb
 spec/function_spec.rb
 spec/integeration_spec.rb
 spec/iso_3166_database.rb
+spec/json_spec.rb
 spec/packer_spec.rb
 spec/paths_spec.rb
 spec/progress_handler_spec.rb

data/README.md

@@ -16,8 +16,8 @@
 
 ## DESCRIPTION
 
-Amalgalite embeds the SQLite database engine in a ruby extension.  There is no
-need to install SQLite separately.  
+Amalgalite embeds the SQLite database engine in a ruby extension. There is no
+need to install SQLite separately.
 
 Look in the examples/ directory to see
 
@@ -35,18 +35,14 @@ overview of the API.
 Amalgalite adds in the following additional non-default SQLite extensions:
 
 * [R*Tree index extension](http://sqlite.org/rtree.html)
-* [Full Text Search](http://sqlite.org/fts3.html)
-
-## BUILDING FOR WINDOWS
-
-This is done using https://github.com/rake-compiler/rake-compiler-dock
-
-1. have VirtualBox installed
-2. Install boot2docker `brew install boot2docker`
-3. `gem install rake-compiler-dock`
-4. `rake-compiler-dock`
-5. `bundle`
-6 `rake cross native gem`
+* [Full Text Search](http://sqlite.org/fts5.html) - both fts3 and fts5
+* [Geopoly Interface to R*Tree](https://www.sqlite.org/geopoly.html)
+* [JSON Extension](https://www.sqlite.org/json1.html)
+
+Other extensions are add that might not be usable/visible by users of the gem.
+The full list of extensions added is in
+[extconf.rb](ext/amalgalite/c/extconf.rb). And those may be cross referenced
+against the [compile options from SQLite](https://www.sqlite.org/compile.html)
 
 ## CREDITS
 

data/Rakefile

@@ -10,11 +10,11 @@ This.ruby_gemspec do |spec|
   spec.add_dependency( 'arrayfields', '~> 4.9' )
 
   spec.add_development_dependency( 'rspec'        , '~> 3.0' )
-  spec.add_development_dependency( 'rake'         , '~> 10.0')
-  spec.add_development_dependency( 'rake-compiler', '~> 0.9' )
-  spec.add_development_dependency( 'rake-compiler-dock', '~> 0.4' )
-  spec.add_development_dependency( 'rdoc'         , '~> 4.0' )
-  spec.add_development_dependency( 'simplecov'    , '~> 0.9' )
+  spec.add_development_dependency( 'rake'         , '~> 13.0')
+  spec.add_development_dependency( 'rake-compiler', '~> 1.0' )
+  spec.add_development_dependency( 'rake-compiler-dock', '~> 0.6' )
+  spec.add_development_dependency( 'rdoc'         , '~> 6.0' )
+  spec.add_development_dependency( 'simplecov'    , '~> 0.14' )
   spec.add_development_dependency( 'zip'          , '~> 2.0' )
 
   spec.extensions.concat This.extension_conf_files

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

@@ -234,6 +234,18 @@ 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
@@ -259,6 +271,18 @@ 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
  *
@@ -306,6 +330,8 @@ void Init_amalgalite()
     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

data/ext/amalgalite/c/amalgalite_constants.c

@@ -16,11 +16,46 @@ void Init_amalgalite_constants( )
      * module encapsulating all the SQLite C extension constants 
      */
     VALUE mC = rb_define_module_under( mas, "Constants");
+    /**
+     * module encapsulating the SQLite3 C extension constants for Access
+     */
+    VALUE mC_Access = rb_define_module_under(mC, "Access");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Authorizer
+     */
+    VALUE mC_Authorizer = rb_define_module_under(mC, "Authorizer");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Changeset
+     */
+    VALUE mC_Changeset = rb_define_module_under(mC, "Changeset");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for ChangesetApply
+     */
+    VALUE mC_ChangesetApply = rb_define_module_under(mC, "ChangesetApply");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for ChangesetStart
+     */
+    VALUE mC_ChangesetStart = rb_define_module_under(mC, "ChangesetStart");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Checkpoint
+     */
+    VALUE mC_Checkpoint = rb_define_module_under(mC, "Checkpoint");
+
     /**
      * module encapsulating the SQLite3 C extension constants for Config
      */
     VALUE mC_Config = rb_define_module_under(mC, "Config");
 
+    /**
+     * module encapsulating the SQLite3 C extension constants for DBConfig
+     */
+    VALUE mC_DBConfig = rb_define_module_under(mC, "DBConfig");
+
     /**
      * module encapsulating the SQLite3 C extension constants for DBStatus
      */
@@ -31,189 +66,1010 @@ void Init_amalgalite_constants( )
      */
     VALUE mC_DataType = rb_define_module_under(mC, "DataType");
 
+    /**
+     * module encapsulating the SQLite3 C extension constants for Deserialize
+     */
+    VALUE mC_Deserialize = rb_define_module_under(mC, "Deserialize");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for FTS5
+     */
+    VALUE mC_FTS5 = rb_define_module_under(mC, "FTS5");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Fcntl
+     */
+    VALUE mC_Fcntl = rb_define_module_under(mC, "Fcntl");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for IOCap
+     */
+    VALUE mC_IOCap = rb_define_module_under(mC, "IOCap");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Index
+     */
+    VALUE mC_Index = rb_define_module_under(mC, "Index");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Limit
+     */
+    VALUE mC_Limit = rb_define_module_under(mC, "Limit");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Lock
+     */
+    VALUE mC_Lock = rb_define_module_under(mC, "Lock");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Mutex
+     */
+    VALUE mC_Mutex = rb_define_module_under(mC, "Mutex");
+
     /**
      * module encapsulating the SQLite3 C extension constants for Open
      */
     VALUE mC_Open = rb_define_module_under(mC, "Open");
 
+    /**
+     * module encapsulating the SQLite3 C extension constants for Prepare
+     */
+    VALUE mC_Prepare = rb_define_module_under(mC, "Prepare");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for RTree
+     */
+    VALUE mC_RTree = rb_define_module_under(mC, "RTree");
+
     /**
      * module encapsulating the SQLite3 C extension constants for ResultCode
      */
     VALUE mC_ResultCode = rb_define_module_under(mC, "ResultCode");
 
-    /**
-     * module encapsulating the SQLite3 C extension constants for StatementStatus
-     */
-    VALUE mC_StatementStatus = rb_define_module_under(mC, "StatementStatus");
+    /**
+     * module encapsulating the SQLite3 C extension constants for SHM
+     */
+    VALUE mC_SHM = rb_define_module_under(mC, "SHM");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for ScanStat
+     */
+    VALUE mC_ScanStat = rb_define_module_under(mC, "ScanStat");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Serialize
+     */
+    VALUE mC_Serialize = rb_define_module_under(mC, "Serialize");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Session
+     */
+    VALUE mC_Session = rb_define_module_under(mC, "Session");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for StatementStatus
+     */
+    VALUE mC_StatementStatus = rb_define_module_under(mC, "StatementStatus");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Status
+     */
+    VALUE mC_Status = rb_define_module_under(mC, "Status");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Sync
+     */
+    VALUE mC_Sync = rb_define_module_under(mC, "Sync");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for TextEncoding
+     */
+    VALUE mC_TextEncoding = rb_define_module_under(mC, "TextEncoding");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Trace
+     */
+    VALUE mC_Trace = rb_define_module_under(mC, "Trace");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Transaction
+     */
+    VALUE mC_Transaction = rb_define_module_under(mC, "Transaction");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for Win32
+     */
+    VALUE mC_Win32 = rb_define_module_under(mC, "Win32");
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Access, "EXISTS", INT2FIX(SQLITE_ACCESS_EXISTS));
+
+    /*  2 -- Unused */
+    rb_define_const(mC_Access, "READ", INT2FIX(SQLITE_ACCESS_READ));
+
+    /*  1 -- Used by PRAGMA temp_store_directory */
+    rb_define_const(mC_Access, "READWRITE", INT2FIX(SQLITE_ACCESS_READWRITE));
+
+    /*  26 -- Database Name   Table Name */
+    rb_define_const(mC_Authorizer, "ALTER_TABLE", INT2FIX(SQLITE_ALTER_TABLE));
+
+    /*  28 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "ANALYZE", INT2FIX(SQLITE_ANALYZE));
+
+    /*  24 -- Filename        NULL */
+    rb_define_const(mC_Authorizer, "ATTACH", INT2FIX(SQLITE_ATTACH));
+
+    /*  0 -- No longer used */
+    rb_define_const(mC_Authorizer, "COPY", INT2FIX(SQLITE_COPY));
+
+    /*  1 -- Index Name      Table Name */
+    rb_define_const(mC_Authorizer, "CREATE_INDEX", INT2FIX(SQLITE_CREATE_INDEX));
+
+    /*  2 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "CREATE_TABLE", INT2FIX(SQLITE_CREATE_TABLE));
+
+    /*  3 -- Index Name      Table Name */
+    rb_define_const(mC_Authorizer, "CREATE_TEMP_INDEX", INT2FIX(SQLITE_CREATE_TEMP_INDEX));
+
+    /*  4 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "CREATE_TEMP_TABLE", INT2FIX(SQLITE_CREATE_TEMP_TABLE));
+
+    /*  5 -- Trigger Name    Table Name */
+    rb_define_const(mC_Authorizer, "CREATE_TEMP_TRIGGER", INT2FIX(SQLITE_CREATE_TEMP_TRIGGER));
+
+    /*  6 -- View Name       NULL */
+    rb_define_const(mC_Authorizer, "CREATE_TEMP_VIEW", INT2FIX(SQLITE_CREATE_TEMP_VIEW));
+
+    /*  7 -- Trigger Name    Table Name */
+    rb_define_const(mC_Authorizer, "CREATE_TRIGGER", INT2FIX(SQLITE_CREATE_TRIGGER));
+
+    /*  8 -- View Name       NULL */
+    rb_define_const(mC_Authorizer, "CREATE_VIEW", INT2FIX(SQLITE_CREATE_VIEW));
+
+    /*  29 -- Table Name      Module Name */
+    rb_define_const(mC_Authorizer, "CREATE_VTABLE", INT2FIX(SQLITE_CREATE_VTABLE));
+
+    /*  9 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "DELETE", INT2FIX(SQLITE_DELETE));
+
+    /*  1 -- Abort the SQL statement with an error */
+    rb_define_const(mC_Authorizer, "DENY", INT2FIX(SQLITE_DENY));
+
+    /*  25 -- Database Name   NULL */
+    rb_define_const(mC_Authorizer, "DETACH", INT2FIX(SQLITE_DETACH));
+
+    /*  10 -- Index Name      Table Name */
+    rb_define_const(mC_Authorizer, "DROP_INDEX", INT2FIX(SQLITE_DROP_INDEX));
+
+    /*  11 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "DROP_TABLE", INT2FIX(SQLITE_DROP_TABLE));
+
+    /*  12 -- Index Name      Table Name */
+    rb_define_const(mC_Authorizer, "DROP_TEMP_INDEX", INT2FIX(SQLITE_DROP_TEMP_INDEX));
+
+    /*  13 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "DROP_TEMP_TABLE", INT2FIX(SQLITE_DROP_TEMP_TABLE));
+
+    /*  14 -- Trigger Name    Table Name */
+    rb_define_const(mC_Authorizer, "DROP_TEMP_TRIGGER", INT2FIX(SQLITE_DROP_TEMP_TRIGGER));
+
+    /*  15 -- View Name       NULL */
+    rb_define_const(mC_Authorizer, "DROP_TEMP_VIEW", INT2FIX(SQLITE_DROP_TEMP_VIEW));
+
+    /*  16 -- Trigger Name    Table Name */
+    rb_define_const(mC_Authorizer, "DROP_TRIGGER", INT2FIX(SQLITE_DROP_TRIGGER));
+
+    /*  17 -- View Name       NULL */
+    rb_define_const(mC_Authorizer, "DROP_VIEW", INT2FIX(SQLITE_DROP_VIEW));
+
+    /*  30 -- Table Name      Module Name */
+    rb_define_const(mC_Authorizer, "DROP_VTABLE", INT2FIX(SQLITE_DROP_VTABLE));
+
+    /*  31 -- NULL            Function Name */
+    rb_define_const(mC_Authorizer, "FUNCTION", INT2FIX(SQLITE_FUNCTION));
+
+    /*  2 -- Don't allow access, but don't generate an error */
+    rb_define_const(mC_Authorizer, "IGNORE", INT2FIX(SQLITE_IGNORE));
+
+    /*  18 -- Table Name      NULL */
+    rb_define_const(mC_Authorizer, "INSERT", INT2FIX(SQLITE_INSERT));
+
+    /*  19 -- Pragma Name     1st arg or NULL */
+    rb_define_const(mC_Authorizer, "PRAGMA", INT2FIX(SQLITE_PRAGMA));
+
+    /*  20 -- Table Name      Column Name */
+    rb_define_const(mC_Authorizer, "READ", INT2FIX(SQLITE_READ));
+
+    /*  33 -- NULL            NULL */
+    rb_define_const(mC_Authorizer, "RECURSIVE", INT2FIX(SQLITE_RECURSIVE));
+
+    /*  27 -- Index Name      NULL */
+    rb_define_const(mC_Authorizer, "REINDEX", INT2FIX(SQLITE_REINDEX));
+
+    /*  32 -- Operation       Savepoint Name */
+    rb_define_const(mC_Authorizer, "SAVEPOINT", INT2FIX(SQLITE_SAVEPOINT));
+
+    /*  21 -- NULL            NULL */
+    rb_define_const(mC_Authorizer, "SELECT", INT2FIX(SQLITE_SELECT));
+
+    /*  22 -- Operation       NULL */
+    rb_define_const(mC_Authorizer, "TRANSACTION", INT2FIX(SQLITE_TRANSACTION));
+
+    /*  23 -- Table Name      Column Name */
+    rb_define_const(mC_Authorizer, "UPDATE", INT2FIX(SQLITE_UPDATE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "ABORT", INT2FIX(SQLITE_CHANGESET_ABORT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "CONFLICT", INT2FIX(SQLITE_CHANGESET_CONFLICT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "CONSTRAINT", INT2FIX(SQLITE_CHANGESET_CONSTRAINT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "DATA", INT2FIX(SQLITE_CHANGESET_DATA));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "FOREIGN_KEY", INT2FIX(SQLITE_CHANGESET_FOREIGN_KEY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "NOTFOUND", INT2FIX(SQLITE_CHANGESET_NOTFOUND));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "OMIT", INT2FIX(SQLITE_CHANGESET_OMIT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Changeset, "REPLACE", INT2FIX(SQLITE_CHANGESET_REPLACE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ChangesetApply, "INVERT", INT2FIX(SQLITE_CHANGESETAPPLY_INVERT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ChangesetApply, "NOSAVEPOINT", INT2FIX(SQLITE_CHANGESETAPPLY_NOSAVEPOINT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ChangesetStart, "INVERT", INT2FIX(SQLITE_CHANGESETSTART_INVERT));
+
+    /*  1 -- Wait for writers, then checkpoint */
+    rb_define_const(mC_Checkpoint, "FULL", INT2FIX(SQLITE_CHECKPOINT_FULL));
+
+    /*  0 -- Do as much as possible w/o blocking */
+    rb_define_const(mC_Checkpoint, "PASSIVE", INT2FIX(SQLITE_CHECKPOINT_PASSIVE));
+
+    /*  2 -- Like FULL but wait for for readers */
+    rb_define_const(mC_Checkpoint, "RESTART", INT2FIX(SQLITE_CHECKPOINT_RESTART));
+
+    /*  3 -- Like RESTART but also truncate WAL */
+    rb_define_const(mC_Checkpoint, "TRUNCATE", INT2FIX(SQLITE_CHECKPOINT_TRUNCATE));
+
+    /*  20 -- int */
+    rb_define_const(mC_Config, "COVERING_INDEX_SCAN", INT2FIX(SQLITE_CONFIG_COVERING_INDEX_SCAN));
+
+    /*  5 -- sqlite3_mem_methods* */
+    rb_define_const(mC_Config, "GETMALLOC", INT2FIX(SQLITE_CONFIG_GETMALLOC));
+
+    /*  11 -- sqlite3_mutex_methods* */
+    rb_define_const(mC_Config, "GETMUTEX", INT2FIX(SQLITE_CONFIG_GETMUTEX));
+
+    /*  15 -- no-op */
+    rb_define_const(mC_Config, "GETPCACHE", INT2FIX(SQLITE_CONFIG_GETPCACHE));
+
+    /*  19 -- sqlite3_pcache_methods2* */
+    rb_define_const(mC_Config, "GETPCACHE2", INT2FIX(SQLITE_CONFIG_GETPCACHE2));
+
+    /*  8 -- void*, int nByte, int min */
+    rb_define_const(mC_Config, "HEAP", INT2FIX(SQLITE_CONFIG_HEAP));
+
+    /*  16 -- xFunc, void* */
+    rb_define_const(mC_Config, "LOG", INT2FIX(SQLITE_CONFIG_LOG));
+
+    /*  13 -- int int */
+    rb_define_const(mC_Config, "LOOKASIDE", INT2FIX(SQLITE_CONFIG_LOOKASIDE));
+
+    /*  4 -- sqlite3_mem_methods* */
+    rb_define_const(mC_Config, "MALLOC", INT2FIX(SQLITE_CONFIG_MALLOC));
+
+    /*  29 -- sqlite3_int64 */
+    rb_define_const(mC_Config, "MEMDB_MAXSIZE", INT2FIX(SQLITE_CONFIG_MEMDB_MAXSIZE));
+
+    /*  9 -- boolean */
+    rb_define_const(mC_Config, "MEMSTATUS", INT2FIX(SQLITE_CONFIG_MEMSTATUS));
+
+    /*  22 -- sqlite3_int64, sqlite3_int64 */
+    rb_define_const(mC_Config, "MMAP_SIZE", INT2FIX(SQLITE_CONFIG_MMAP_SIZE));
+
+    /*  2 -- nil */
+    rb_define_const(mC_Config, "MULTITHREAD", INT2FIX(SQLITE_CONFIG_MULTITHREAD));
+
+    /*  10 -- sqlite3_mutex_methods* */
+    rb_define_const(mC_Config, "MUTEX", INT2FIX(SQLITE_CONFIG_MUTEX));
+
+    /*  7 -- void*, int sz, int N */
+    rb_define_const(mC_Config, "PAGECACHE", INT2FIX(SQLITE_CONFIG_PAGECACHE));
+
+    /*  14 -- no-op */
+    rb_define_const(mC_Config, "PCACHE", INT2FIX(SQLITE_CONFIG_PCACHE));
+
+    /*  18 -- sqlite3_pcache_methods2* */
+    rb_define_const(mC_Config, "PCACHE2", INT2FIX(SQLITE_CONFIG_PCACHE2));
+
+    /*  24 -- int *psz */
+    rb_define_const(mC_Config, "PCACHE_HDRSZ", INT2FIX(SQLITE_CONFIG_PCACHE_HDRSZ));
+
+    /*  25 -- unsigned int szPma */
+    rb_define_const(mC_Config, "PMASZ", INT2FIX(SQLITE_CONFIG_PMASZ));
+
+    /*  6 -- No longer used */
+    rb_define_const(mC_Config, "SCRATCH", INT2FIX(SQLITE_CONFIG_SCRATCH));
+
+    /*  3 -- nil */
+    rb_define_const(mC_Config, "SERIALIZED", INT2FIX(SQLITE_CONFIG_SERIALIZED));
+
+    /*  1 -- nil */
+    rb_define_const(mC_Config, "SINGLETHREAD", INT2FIX(SQLITE_CONFIG_SINGLETHREAD));
+
+    /*  27 -- boolean */
+    rb_define_const(mC_Config, "SMALL_MALLOC", INT2FIX(SQLITE_CONFIG_SMALL_MALLOC));
+
+    /*  28 -- int nByte */
+    rb_define_const(mC_Config, "SORTERREF_SIZE", INT2FIX(SQLITE_CONFIG_SORTERREF_SIZE));
+
+    /*  21 -- xSqllog, void* */
+    rb_define_const(mC_Config, "SQLLOG", INT2FIX(SQLITE_CONFIG_SQLLOG));
+
+    /*  26 -- int nByte */
+    rb_define_const(mC_Config, "STMTJRNL_SPILL", INT2FIX(SQLITE_CONFIG_STMTJRNL_SPILL));
+
+    /*  17 -- int */
+    rb_define_const(mC_Config, "URI", INT2FIX(SQLITE_CONFIG_URI));
+
+    /*  23 -- int nByte */
+    rb_define_const(mC_Config, "WIN32_HEAPSIZE", INT2FIX(SQLITE_CONFIG_WIN32_HEAPSIZE));
+
+    /*  1010 -- int int* */
+    rb_define_const(mC_DBConfig, "DEFENSIVE", INT2FIX(SQLITE_DBCONFIG_DEFENSIVE));
+
+    /*  1014 -- int int* */
+    rb_define_const(mC_DBConfig, "DQS_DDL", INT2FIX(SQLITE_DBCONFIG_DQS_DDL));
+
+    /*  1013 -- int int* */
+    rb_define_const(mC_DBConfig, "DQS_DML", INT2FIX(SQLITE_DBCONFIG_DQS_DML));
+
+    /*  1002 -- int int* */
+    rb_define_const(mC_DBConfig, "ENABLE_FKEY", INT2FIX(SQLITE_DBCONFIG_ENABLE_FKEY));
+
+    /*  1004 -- int int* */
+    rb_define_const(mC_DBConfig, "ENABLE_FTS3_TOKENIZER", INT2FIX(SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER));
+
+    /*  1005 -- int int* */
+    rb_define_const(mC_DBConfig, "ENABLE_LOAD_EXTENSION", INT2FIX(SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION));
+
+    /*  1007 -- int int* */
+    rb_define_const(mC_DBConfig, "ENABLE_QPSG", INT2FIX(SQLITE_DBCONFIG_ENABLE_QPSG));
+
+    /*  1003 -- int int* */
+    rb_define_const(mC_DBConfig, "ENABLE_TRIGGER", INT2FIX(SQLITE_DBCONFIG_ENABLE_TRIGGER));
+
+    /*  1015 -- int int* */
+    rb_define_const(mC_DBConfig, "ENABLE_VIEW", INT2FIX(SQLITE_DBCONFIG_ENABLE_VIEW));
+
+    /*  1012 -- int int* */
+    rb_define_const(mC_DBConfig, "LEGACY_ALTER_TABLE", INT2FIX(SQLITE_DBCONFIG_LEGACY_ALTER_TABLE));
+
+    /*  1016 -- int int* */
+    rb_define_const(mC_DBConfig, "LEGACY_FILE_FORMAT", INT2FIX(SQLITE_DBCONFIG_LEGACY_FILE_FORMAT));
+
+    /*  1001 -- void* int int */
+    rb_define_const(mC_DBConfig, "LOOKASIDE", INT2FIX(SQLITE_DBCONFIG_LOOKASIDE));
+
+    /*  1000 -- const char* */
+    rb_define_const(mC_DBConfig, "MAINDBNAME", INT2FIX(SQLITE_DBCONFIG_MAINDBNAME));
+
+    /*  1017 -- Largest DBCONFIG */
+    rb_define_const(mC_DBConfig, "MAX", INT2FIX(SQLITE_DBCONFIG_MAX));
+
+    /*  1006 -- int int* */
+    rb_define_const(mC_DBConfig, "NO_CKPT_ON_CLOSE", INT2FIX(SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE));
+
+    /*  1009 -- int int* */
+    rb_define_const(mC_DBConfig, "RESET_DATABASE", INT2FIX(SQLITE_DBCONFIG_RESET_DATABASE));
+
+    /*  1008 -- int int* */
+    rb_define_const(mC_DBConfig, "TRIGGER_EQP", INT2FIX(SQLITE_DBCONFIG_TRIGGER_EQP));
+
+    /*  1017 -- int int* */
+    rb_define_const(mC_DBConfig, "TRUSTED_SCHEMA", INT2FIX(SQLITE_DBCONFIG_TRUSTED_SCHEMA));
+
+    /*  1011 -- int int* */
+    rb_define_const(mC_DBConfig, "WRITABLE_SCHEMA", INT2FIX(SQLITE_DBCONFIG_WRITABLE_SCHEMA));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "CACHE_HIT", INT2FIX(SQLITE_DBSTATUS_CACHE_HIT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "CACHE_MISS", INT2FIX(SQLITE_DBSTATUS_CACHE_MISS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "CACHE_SPILL", INT2FIX(SQLITE_DBSTATUS_CACHE_SPILL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "CACHE_USED", INT2FIX(SQLITE_DBSTATUS_CACHE_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "CACHE_USED_SHARED", INT2FIX(SQLITE_DBSTATUS_CACHE_USED_SHARED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "CACHE_WRITE", INT2FIX(SQLITE_DBSTATUS_CACHE_WRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "DEFERRED_FKS", INT2FIX(SQLITE_DBSTATUS_DEFERRED_FKS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "LOOKASIDE_HIT", INT2FIX(SQLITE_DBSTATUS_LOOKASIDE_HIT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "LOOKASIDE_MISS_FULL", INT2FIX(SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "LOOKASIDE_MISS_SIZE", INT2FIX(SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "LOOKASIDE_USED", INT2FIX(SQLITE_DBSTATUS_LOOKASIDE_USED));
+
+    /*  12 -- Largest defined DBSTATUS */
+    rb_define_const(mC_DBStatus, "MAX", INT2FIX(SQLITE_DBSTATUS_MAX));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "SCHEMA_USED", INT2FIX(SQLITE_DBSTATUS_SCHEMA_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DBStatus, "STMT_USED", INT2FIX(SQLITE_DBSTATUS_STMT_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "TEXT", INT2FIX(SQLITE3_TEXT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "BLOB", INT2FIX(SQLITE_BLOB));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "FLOAT", INT2FIX(SQLITE_FLOAT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "INTEGER", INT2FIX(SQLITE_INTEGER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_DataType, "NULL", INT2FIX(SQLITE_NULL));
+
+    /*  1 -- Call sqlite3_free() on close */
+    rb_define_const(mC_Deserialize, "FREEONCLOSE", INT2FIX(SQLITE_DESERIALIZE_FREEONCLOSE));
+
+    /*  4 -- Database is read-only */
+    rb_define_const(mC_Deserialize, "READONLY", INT2FIX(SQLITE_DESERIALIZE_READONLY));
+
+    /*  2 -- Resize using sqlite3_realloc64() */
+    rb_define_const(mC_Deserialize, "RESIZEABLE", INT2FIX(SQLITE_DESERIALIZE_RESIZEABLE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_FTS5, "TOKENIZE_AUX", INT2FIX(FTS5_TOKENIZE_AUX));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_FTS5, "TOKENIZE_DOCUMENT", INT2FIX(FTS5_TOKENIZE_DOCUMENT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_FTS5, "TOKENIZE_PREFIX", INT2FIX(FTS5_TOKENIZE_PREFIX));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_FTS5, "TOKENIZE_QUERY", INT2FIX(FTS5_TOKENIZE_QUERY));
+
+    /*  0x0001 -- Same position as prev. token */
+    rb_define_const(mC_FTS5, "TOKEN_COLOCATED", INT2FIX(FTS5_TOKEN_COLOCATED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "BEGIN_ATOMIC_WRITE", INT2FIX(SQLITE_FCNTL_BEGIN_ATOMIC_WRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "BUSYHANDLER", INT2FIX(SQLITE_FCNTL_BUSYHANDLER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "CHUNK_SIZE", INT2FIX(SQLITE_FCNTL_CHUNK_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "CKPT_DONE", INT2FIX(SQLITE_FCNTL_CKPT_DONE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "CKPT_START", INT2FIX(SQLITE_FCNTL_CKPT_START));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "COMMIT_ATOMIC_WRITE", INT2FIX(SQLITE_FCNTL_COMMIT_ATOMIC_WRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "COMMIT_PHASETWO", INT2FIX(SQLITE_FCNTL_COMMIT_PHASETWO));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "DATA_VERSION", INT2FIX(SQLITE_FCNTL_DATA_VERSION));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "FILE_POINTER", INT2FIX(SQLITE_FCNTL_FILE_POINTER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "GET_LOCKPROXYFILE", INT2FIX(SQLITE_FCNTL_GET_LOCKPROXYFILE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "HAS_MOVED", INT2FIX(SQLITE_FCNTL_HAS_MOVED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "JOURNAL_POINTER", INT2FIX(SQLITE_FCNTL_JOURNAL_POINTER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "LAST_ERRNO", INT2FIX(SQLITE_FCNTL_LAST_ERRNO));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "LOCKSTATE", INT2FIX(SQLITE_FCNTL_LOCKSTATE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "LOCK_TIMEOUT", INT2FIX(SQLITE_FCNTL_LOCK_TIMEOUT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "MMAP_SIZE", INT2FIX(SQLITE_FCNTL_MMAP_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "OVERWRITE", INT2FIX(SQLITE_FCNTL_OVERWRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "PDB", INT2FIX(SQLITE_FCNTL_PDB));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "PERSIST_WAL", INT2FIX(SQLITE_FCNTL_PERSIST_WAL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "POWERSAFE_OVERWRITE", INT2FIX(SQLITE_FCNTL_POWERSAFE_OVERWRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "PRAGMA", INT2FIX(SQLITE_FCNTL_PRAGMA));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "RBU", INT2FIX(SQLITE_FCNTL_RBU));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "RESERVE_BYTES", INT2FIX(SQLITE_FCNTL_RESERVE_BYTES));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "ROLLBACK_ATOMIC_WRITE", INT2FIX(SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "SET_LOCKPROXYFILE", INT2FIX(SQLITE_FCNTL_SET_LOCKPROXYFILE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "SIZE_HINT", INT2FIX(SQLITE_FCNTL_SIZE_HINT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "SIZE_LIMIT", INT2FIX(SQLITE_FCNTL_SIZE_LIMIT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "SYNC", INT2FIX(SQLITE_FCNTL_SYNC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "SYNC_OMITTED", INT2FIX(SQLITE_FCNTL_SYNC_OMITTED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "TEMPFILENAME", INT2FIX(SQLITE_FCNTL_TEMPFILENAME));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "TRACE", INT2FIX(SQLITE_FCNTL_TRACE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "VFSNAME", INT2FIX(SQLITE_FCNTL_VFSNAME));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "VFS_POINTER", INT2FIX(SQLITE_FCNTL_VFS_POINTER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "WAL_BLOCK", INT2FIX(SQLITE_FCNTL_WAL_BLOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "WIN32_AV_RETRY", INT2FIX(SQLITE_FCNTL_WIN32_AV_RETRY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "WIN32_GET_HANDLE", INT2FIX(SQLITE_FCNTL_WIN32_GET_HANDLE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "WIN32_SET_HANDLE", INT2FIX(SQLITE_FCNTL_WIN32_SET_HANDLE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Fcntl, "ZIPVFS", INT2FIX(SQLITE_FCNTL_ZIPVFS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC", INT2FIX(SQLITE_IOCAP_ATOMIC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC16K", INT2FIX(SQLITE_IOCAP_ATOMIC16K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC1K", INT2FIX(SQLITE_IOCAP_ATOMIC1K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC2K", INT2FIX(SQLITE_IOCAP_ATOMIC2K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC32K", INT2FIX(SQLITE_IOCAP_ATOMIC32K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC4K", INT2FIX(SQLITE_IOCAP_ATOMIC4K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC512", INT2FIX(SQLITE_IOCAP_ATOMIC512));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC64K", INT2FIX(SQLITE_IOCAP_ATOMIC64K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "ATOMIC8K", INT2FIX(SQLITE_IOCAP_ATOMIC8K));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "BATCH_ATOMIC", INT2FIX(SQLITE_IOCAP_BATCH_ATOMIC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "IMMUTABLE", INT2FIX(SQLITE_IOCAP_IMMUTABLE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "POWERSAFE_OVERWRITE", INT2FIX(SQLITE_IOCAP_POWERSAFE_OVERWRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "SAFE_APPEND", INT2FIX(SQLITE_IOCAP_SAFE_APPEND));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "SEQUENTIAL", INT2FIX(SQLITE_IOCAP_SEQUENTIAL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_IOCap, "UNDELETABLE_WHEN_OPEN", INT2FIX(SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_EQ", INT2FIX(SQLITE_INDEX_CONSTRAINT_EQ));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_FUNCTION", INT2FIX(SQLITE_INDEX_CONSTRAINT_FUNCTION));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_GE", INT2FIX(SQLITE_INDEX_CONSTRAINT_GE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_GLOB", INT2FIX(SQLITE_INDEX_CONSTRAINT_GLOB));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_GT", INT2FIX(SQLITE_INDEX_CONSTRAINT_GT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_IS", INT2FIX(SQLITE_INDEX_CONSTRAINT_IS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_ISNOT", INT2FIX(SQLITE_INDEX_CONSTRAINT_ISNOT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_ISNOTNULL", INT2FIX(SQLITE_INDEX_CONSTRAINT_ISNOTNULL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_ISNULL", INT2FIX(SQLITE_INDEX_CONSTRAINT_ISNULL));
 
-    /**
-     * module encapsulating the SQLite3 C extension constants for Status
-     */
-    VALUE mC_Status = rb_define_module_under(mC, "Status");
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_LE", INT2FIX(SQLITE_INDEX_CONSTRAINT_LE));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "GETMALLOC", INT2FIX(SQLITE_CONFIG_GETMALLOC));
+    rb_define_const(mC_Index, "CONSTRAINT_LIKE", INT2FIX(SQLITE_INDEX_CONSTRAINT_LIKE));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "GETMUTEX", INT2FIX(SQLITE_CONFIG_GETMUTEX));
+    rb_define_const(mC_Index, "CONSTRAINT_LT", INT2FIX(SQLITE_INDEX_CONSTRAINT_LT));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "GETPCACHE", INT2FIX(SQLITE_CONFIG_GETPCACHE));
+    rb_define_const(mC_Index, "CONSTRAINT_MATCH", INT2FIX(SQLITE_INDEX_CONSTRAINT_MATCH));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "HEAP", INT2FIX(SQLITE_CONFIG_HEAP));
+    rb_define_const(mC_Index, "CONSTRAINT_NE", INT2FIX(SQLITE_INDEX_CONSTRAINT_NE));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "LOG", INT2FIX(SQLITE_CONFIG_LOG));
+    rb_define_const(mC_Index, "CONSTRAINT_REGEXP", INT2FIX(SQLITE_INDEX_CONSTRAINT_REGEXP));
+
+    /*  1 -- Scan visits at most 1 row */
+    rb_define_const(mC_Index, "SCAN_UNIQUE", INT2FIX(SQLITE_INDEX_SCAN_UNIQUE));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "LOOKASIDE", INT2FIX(SQLITE_CONFIG_LOOKASIDE));
+    rb_define_const(mC_Limit, "ATTACHED", INT2FIX(SQLITE_LIMIT_ATTACHED));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "MALLOC", INT2FIX(SQLITE_CONFIG_MALLOC));
+    rb_define_const(mC_Limit, "COLUMN", INT2FIX(SQLITE_LIMIT_COLUMN));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "MEMSTATUS", INT2FIX(SQLITE_CONFIG_MEMSTATUS));
+    rb_define_const(mC_Limit, "COMPOUND_SELECT", INT2FIX(SQLITE_LIMIT_COMPOUND_SELECT));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "MULTITHREAD", INT2FIX(SQLITE_CONFIG_MULTITHREAD));
+    rb_define_const(mC_Limit, "EXPR_DEPTH", INT2FIX(SQLITE_LIMIT_EXPR_DEPTH));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "MUTEX", INT2FIX(SQLITE_CONFIG_MUTEX));
+    rb_define_const(mC_Limit, "FUNCTION_ARG", INT2FIX(SQLITE_LIMIT_FUNCTION_ARG));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "PAGECACHE", INT2FIX(SQLITE_CONFIG_PAGECACHE));
+    rb_define_const(mC_Limit, "LENGTH", INT2FIX(SQLITE_LIMIT_LENGTH));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "PCACHE", INT2FIX(SQLITE_CONFIG_PCACHE));
+    rb_define_const(mC_Limit, "LIKE_PATTERN_LENGTH", INT2FIX(SQLITE_LIMIT_LIKE_PATTERN_LENGTH));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "SCRATCH", INT2FIX(SQLITE_CONFIG_SCRATCH));
+    rb_define_const(mC_Limit, "SQL_LENGTH", INT2FIX(SQLITE_LIMIT_SQL_LENGTH));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "SERIALIZED", INT2FIX(SQLITE_CONFIG_SERIALIZED));
+    rb_define_const(mC_Limit, "TRIGGER_DEPTH", INT2FIX(SQLITE_LIMIT_TRIGGER_DEPTH));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_Config, "SINGLETHREAD", INT2FIX(SQLITE_CONFIG_SINGLETHREAD));
+    rb_define_const(mC_Limit, "VARIABLE_NUMBER", INT2FIX(SQLITE_LIMIT_VARIABLE_NUMBER));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DBStatus, "CACHE_USED", INT2FIX(SQLITE_DBSTATUS_CACHE_USED));
+    rb_define_const(mC_Limit, "VDBE_OP", INT2FIX(SQLITE_LIMIT_VDBE_OP));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DBStatus, "LOOKASIDE_USED", INT2FIX(SQLITE_DBSTATUS_LOOKASIDE_USED));
+    rb_define_const(mC_Limit, "WORKER_THREADS", INT2FIX(SQLITE_LIMIT_WORKER_THREADS));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DBStatus, "MAX", INT2FIX(SQLITE_DBSTATUS_MAX));
+    rb_define_const(mC_Lock, "EXCLUSIVE", INT2FIX(SQLITE_LOCK_EXCLUSIVE));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DBStatus, "SCHEMA_USED", INT2FIX(SQLITE_DBSTATUS_SCHEMA_USED));
+    rb_define_const(mC_Lock, "NONE", INT2FIX(SQLITE_LOCK_NONE));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DBStatus, "STMT_USED", INT2FIX(SQLITE_DBSTATUS_STMT_USED));
+    rb_define_const(mC_Lock, "PENDING", INT2FIX(SQLITE_LOCK_PENDING));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DataType, "BLOB", INT2FIX(SQLITE_BLOB));
+    rb_define_const(mC_Lock, "RESERVED", INT2FIX(SQLITE_LOCK_RESERVED));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DataType, "FLOAT", INT2FIX(SQLITE_FLOAT));
+    rb_define_const(mC_Lock, "SHARED", INT2FIX(SQLITE_LOCK_SHARED));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DataType, "INTEGER", INT2FIX(SQLITE_INTEGER));
+    rb_define_const(mC_Mutex, "FAST", INT2FIX(SQLITE_MUTEX_FAST));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DataType, "NULL", INT2FIX(SQLITE_NULL));
+    rb_define_const(mC_Mutex, "RECURSIVE", INT2FIX(SQLITE_MUTEX_RECURSIVE));
+
+    /*  8 -- For use by application */
+    rb_define_const(mC_Mutex, "STATIC_APP1", INT2FIX(SQLITE_MUTEX_STATIC_APP1));
+
+    /*  9 -- For use by application */
+    rb_define_const(mC_Mutex, "STATIC_APP2", INT2FIX(SQLITE_MUTEX_STATIC_APP2));
+
+    /*  10 -- For use by application */
+    rb_define_const(mC_Mutex, "STATIC_APP3", INT2FIX(SQLITE_MUTEX_STATIC_APP3));
+
+    /*  6 -- lru page list */
+    rb_define_const(mC_Mutex, "STATIC_LRU", INT2FIX(SQLITE_MUTEX_STATIC_LRU));
+
+    /*  7 -- NOT USED */
+    rb_define_const(mC_Mutex, "STATIC_LRU2", INT2FIX(SQLITE_MUTEX_STATIC_LRU2));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
-    rb_define_const(mC_DataType, "TEXT", INT2FIX(SQLITE_TEXT));
+    rb_define_const(mC_Mutex, "STATIC_MAIN", INT2FIX(SQLITE_MUTEX_STATIC_MAIN));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Mutex, "STATIC_MASTER", INT2FIX(SQLITE_MUTEX_STATIC_MASTER));
+
+    /*  3 -- sqlite3_malloc() */
+    rb_define_const(mC_Mutex, "STATIC_MEM", INT2FIX(SQLITE_MUTEX_STATIC_MEM));
+
+    /*  4 -- NOT USED */
+    rb_define_const(mC_Mutex, "STATIC_MEM2", INT2FIX(SQLITE_MUTEX_STATIC_MEM2));
+
+    /*  4 -- sqlite3BtreeOpen() */
+    rb_define_const(mC_Mutex, "STATIC_OPEN", INT2FIX(SQLITE_MUTEX_STATIC_OPEN));
+
+    /*  7 -- sqlite3PageMalloc() */
+    rb_define_const(mC_Mutex, "STATIC_PMEM", INT2FIX(SQLITE_MUTEX_STATIC_PMEM));
+
+    /*  5 -- sqlite3_randomness() */
+    rb_define_const(mC_Mutex, "STATIC_PRNG", INT2FIX(SQLITE_MUTEX_STATIC_PRNG));
+
+    /*  11 -- For use by built-in VFS */
+    rb_define_const(mC_Mutex, "STATIC_VFS1", INT2FIX(SQLITE_MUTEX_STATIC_VFS1));
+
+    /*  12 -- For use by extension VFS */
+    rb_define_const(mC_Mutex, "STATIC_VFS2", INT2FIX(SQLITE_MUTEX_STATIC_VFS2));
+
+    /*  13 -- For use by application VFS */
+    rb_define_const(mC_Mutex, "STATIC_VFS3", INT2FIX(SQLITE_MUTEX_STATIC_VFS3));
+
+    /*  0x00000020 -- VFS only */
     rb_define_const(mC_Open, "AUTOPROXY", INT2FIX(SQLITE_OPEN_AUTOPROXY));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000004 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "CREATE", INT2FIX(SQLITE_OPEN_CREATE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000008 -- VFS only */
     rb_define_const(mC_Open, "DELETEONCLOSE", INT2FIX(SQLITE_OPEN_DELETEONCLOSE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000010 -- VFS only */
     rb_define_const(mC_Open, "EXCLUSIVE", INT2FIX(SQLITE_OPEN_EXCLUSIVE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00010000 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "FULLMUTEX", INT2FIX(SQLITE_OPEN_FULLMUTEX));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000100 -- VFS only */
     rb_define_const(mC_Open, "MAIN_DB", INT2FIX(SQLITE_OPEN_MAIN_DB));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000800 -- VFS only */
     rb_define_const(mC_Open, "MAIN_JOURNAL", INT2FIX(SQLITE_OPEN_MAIN_JOURNAL));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00004000 -- VFS only */
     rb_define_const(mC_Open, "MASTER_JOURNAL", INT2FIX(SQLITE_OPEN_MASTER_JOURNAL));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000080 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "MEMORY", INT2FIX(SQLITE_OPEN_MEMORY));
+
+    /*  0x01000000 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "NOFOLLOW", INT2FIX(SQLITE_OPEN_NOFOLLOW));
+
+    /*  0x00008000 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "NOMUTEX", INT2FIX(SQLITE_OPEN_NOMUTEX));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00040000 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "PRIVATECACHE", INT2FIX(SQLITE_OPEN_PRIVATECACHE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000001 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "READONLY", INT2FIX(SQLITE_OPEN_READONLY));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000002 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "READWRITE", INT2FIX(SQLITE_OPEN_READWRITE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00020000 -- Ok for sqlite3_open_v2() */
     rb_define_const(mC_Open, "SHAREDCACHE", INT2FIX(SQLITE_OPEN_SHAREDCACHE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00002000 -- VFS only */
     rb_define_const(mC_Open, "SUBJOURNAL", INT2FIX(SQLITE_OPEN_SUBJOURNAL));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00004000 -- VFS only */
+    rb_define_const(mC_Open, "SUPER_JOURNAL", INT2FIX(SQLITE_OPEN_SUPER_JOURNAL));
+
+    /*  0x00000200 -- VFS only */
     rb_define_const(mC_Open, "TEMP_DB", INT2FIX(SQLITE_OPEN_TEMP_DB));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00001000 -- VFS only */
     rb_define_const(mC_Open, "TEMP_JOURNAL", INT2FIX(SQLITE_OPEN_TEMP_JOURNAL));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000400 -- VFS only */
     rb_define_const(mC_Open, "TRANSIENT_DB", INT2FIX(SQLITE_OPEN_TRANSIENT_DB));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  0x00000040 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "URI", INT2FIX(SQLITE_OPEN_URI));
+
+    /*  0x00080000 -- VFS only */
     rb_define_const(mC_Open, "WAL", INT2FIX(SQLITE_OPEN_WAL));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Prepare, "NORMALIZE", INT2FIX(SQLITE_PREPARE_NORMALIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Prepare, "NO_VTAB", INT2FIX(SQLITE_PREPARE_NO_VTAB));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Prepare, "PERSISTENT", INT2FIX(SQLITE_PREPARE_PERSISTENT));
+
+    /*  2 -- Object fully contained within query region */
+    rb_define_const(mC_RTree, "FULLY_WITHIN", INT2FIX(FULLY_WITHIN));
+
+    /*  0 -- Object completely outside of query region */
+    rb_define_const(mC_RTree, "NOT_WITHIN", INT2FIX(NOT_WITHIN));
+
+    /*  1 -- Object partially overlaps query region */
+    rb_define_const(mC_RTree, "PARTLY_WITHIN", INT2FIX(PARTLY_WITHIN));
+
     /*  4 -- Callback routine requested an abort */
     rb_define_const(mC_ResultCode, "ABORT", INT2FIX(SQLITE_ABORT));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "ABORT_ROLLBACK", INT2FIX(SQLITE_ABORT_ROLLBACK));
+
     /*  23 -- Authorization denied */
     rb_define_const(mC_ResultCode, "AUTH", INT2FIX(SQLITE_AUTH));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "AUTH_USER", INT2FIX(SQLITE_AUTH_USER));
+
     /*  5 -- The database file is locked */
     rb_define_const(mC_ResultCode, "BUSY", INT2FIX(SQLITE_BUSY));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "BUSY_RECOVERY", INT2FIX(SQLITE_BUSY_RECOVERY));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "BUSY_SNAPSHOT", INT2FIX(SQLITE_BUSY_SNAPSHOT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "BUSY_TIMEOUT", INT2FIX(SQLITE_BUSY_TIMEOUT));
+
     /*  14 -- Unable to open the database file */
     rb_define_const(mC_ResultCode, "CANTOPEN", INT2FIX(SQLITE_CANTOPEN));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CANTOPEN_CONVPATH", INT2FIX(SQLITE_CANTOPEN_CONVPATH));
+
+    /*  (SQLITE_CANTOPEN | (5<<8)) -- Not Used */
+    rb_define_const(mC_ResultCode, "CANTOPEN_DIRTYWAL", INT2FIX(SQLITE_CANTOPEN_DIRTYWAL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CANTOPEN_FULLPATH", INT2FIX(SQLITE_CANTOPEN_FULLPATH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CANTOPEN_ISDIR", INT2FIX(SQLITE_CANTOPEN_ISDIR));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "CANTOPEN_NOTEMPDIR", INT2FIX(SQLITE_CANTOPEN_NOTEMPDIR));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CANTOPEN_SYMLINK", INT2FIX(SQLITE_CANTOPEN_SYMLINK));
+
     /*  19 -- Abort due to constraint violation */
     rb_define_const(mC_ResultCode, "CONSTRAINT", INT2FIX(SQLITE_CONSTRAINT));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_CHECK", INT2FIX(SQLITE_CONSTRAINT_CHECK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_COMMITHOOK", INT2FIX(SQLITE_CONSTRAINT_COMMITHOOK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_FOREIGNKEY", INT2FIX(SQLITE_CONSTRAINT_FOREIGNKEY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_FUNCTION", INT2FIX(SQLITE_CONSTRAINT_FUNCTION));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_NOTNULL", INT2FIX(SQLITE_CONSTRAINT_NOTNULL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_PINNED", INT2FIX(SQLITE_CONSTRAINT_PINNED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_PRIMARYKEY", INT2FIX(SQLITE_CONSTRAINT_PRIMARYKEY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_ROWID", INT2FIX(SQLITE_CONSTRAINT_ROWID));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_TRIGGER", INT2FIX(SQLITE_CONSTRAINT_TRIGGER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_UNIQUE", INT2FIX(SQLITE_CONSTRAINT_UNIQUE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CONSTRAINT_VTAB", INT2FIX(SQLITE_CONSTRAINT_VTAB));
+
     /*  11 -- The database disk image is malformed */
     rb_define_const(mC_ResultCode, "CORRUPT", INT2FIX(SQLITE_CORRUPT));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CORRUPT_INDEX", INT2FIX(SQLITE_CORRUPT_INDEX));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CORRUPT_SEQUENCE", INT2FIX(SQLITE_CORRUPT_SEQUENCE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "CORRUPT_VTAB", INT2FIX(SQLITE_CORRUPT_VTAB));
+
     /*  101 -- sqlite3_step() has finished executing */
     rb_define_const(mC_ResultCode, "DONE", INT2FIX(SQLITE_DONE));
 
-    /*  16 -- Database is empty */
+    /*  16 -- Internal use only */
     rb_define_const(mC_ResultCode, "EMPTY", INT2FIX(SQLITE_EMPTY));
 
-    /*  1 -- SQL error or missing database */
+    /*  1 -- Generic error */
     rb_define_const(mC_ResultCode, "ERROR", INT2FIX(SQLITE_ERROR));
 
-    /*  24 -- Auxiliary database format error */
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "ERROR_MISSING_COLLSEQ", INT2FIX(SQLITE_ERROR_MISSING_COLLSEQ));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "ERROR_RETRY", INT2FIX(SQLITE_ERROR_RETRY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "ERROR_SNAPSHOT", INT2FIX(SQLITE_ERROR_SNAPSHOT));
+
+    /*  24 -- Not used */
     rb_define_const(mC_ResultCode, "FORMAT", INT2FIX(SQLITE_FORMAT));
 
     /*  13 -- Insertion failed because database is full */
@@ -231,6 +1087,12 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_ACCESS", INT2FIX(SQLITE_IOERR_ACCESS));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_AUTH", INT2FIX(SQLITE_IOERR_AUTH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_BEGIN_ATOMIC", INT2FIX(SQLITE_IOERR_BEGIN_ATOMIC));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_BLOCKED", INT2FIX(SQLITE_IOERR_BLOCKED));
 
@@ -240,9 +1102,24 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_CLOSE", INT2FIX(SQLITE_IOERR_CLOSE));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_COMMIT_ATOMIC", INT2FIX(SQLITE_IOERR_COMMIT_ATOMIC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_CONVPATH", INT2FIX(SQLITE_IOERR_CONVPATH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_CORRUPTFS", INT2FIX(SQLITE_IOERR_CORRUPTFS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_DATA", INT2FIX(SQLITE_IOERR_DATA));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_DELETE", INT2FIX(SQLITE_IOERR_DELETE));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_DELETE_NOENT", INT2FIX(SQLITE_IOERR_DELETE_NOENT));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_DIR_CLOSE", INT2FIX(SQLITE_IOERR_DIR_CLOSE));
 
@@ -255,9 +1132,15 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_FSYNC", INT2FIX(SQLITE_IOERR_FSYNC));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_GETTEMPPATH", INT2FIX(SQLITE_IOERR_GETTEMPPATH));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_LOCK", INT2FIX(SQLITE_IOERR_LOCK));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_MMAP", INT2FIX(SQLITE_IOERR_MMAP));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_NOMEM", INT2FIX(SQLITE_IOERR_NOMEM));
 
@@ -267,9 +1150,18 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_READ", INT2FIX(SQLITE_IOERR_READ));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_ROLLBACK_ATOMIC", INT2FIX(SQLITE_IOERR_ROLLBACK_ATOMIC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_SEEK", INT2FIX(SQLITE_IOERR_SEEK));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_SHMLOCK", INT2FIX(SQLITE_IOERR_SHMLOCK));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_SHMMAP", INT2FIX(SQLITE_IOERR_SHMMAP));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_SHMOPEN", INT2FIX(SQLITE_IOERR_SHMOPEN));
 
@@ -285,6 +1177,9 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_UNLOCK", INT2FIX(SQLITE_IOERR_UNLOCK));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_VNODE", INT2FIX(SQLITE_IOERR_VNODE));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "IOERR_WRITE", INT2FIX(SQLITE_IOERR_WRITE));
 
@@ -294,6 +1189,9 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_ResultCode, "LOCKED_SHAREDCACHE", INT2FIX(SQLITE_LOCKED_SHAREDCACHE));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "LOCKED_VTAB", INT2FIX(SQLITE_LOCKED_VTAB));
+
     /*  20 -- Data type mismatch */
     rb_define_const(mC_ResultCode, "MISMATCH", INT2FIX(SQLITE_MISMATCH));
 
@@ -312,9 +1210,24 @@ void Init_amalgalite_constants( )
     /*  12 -- Unknown opcode in sqlite3_file_control() */
     rb_define_const(mC_ResultCode, "NOTFOUND", INT2FIX(SQLITE_NOTFOUND));
 
+    /*  27 -- Notifications from sqlite3_log() */
+    rb_define_const(mC_ResultCode, "NOTICE", INT2FIX(SQLITE_NOTICE));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "NOTICE_RECOVER_ROLLBACK", INT2FIX(SQLITE_NOTICE_RECOVER_ROLLBACK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "NOTICE_RECOVER_WAL", INT2FIX(SQLITE_NOTICE_RECOVER_WAL));
+
+    /*  0 -- Successful result */
     rb_define_const(mC_ResultCode, "OK", INT2FIX(SQLITE_OK));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "OK_LOAD_PERMANENTLY", INT2FIX(SQLITE_OK_LOAD_PERMANENTLY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "OK_SYMLINK", INT2FIX(SQLITE_OK_SYMLINK));
+
     /*  3 -- Access permission denied */
     rb_define_const(mC_ResultCode, "PERM", INT2FIX(SQLITE_PERM));
 
@@ -327,6 +1240,24 @@ void Init_amalgalite_constants( )
     /*  8 -- Attempt to write a readonly database */
     rb_define_const(mC_ResultCode, "READONLY", INT2FIX(SQLITE_READONLY));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "READONLY_CANTINIT", INT2FIX(SQLITE_READONLY_CANTINIT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "READONLY_CANTLOCK", INT2FIX(SQLITE_READONLY_CANTLOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "READONLY_DBMOVED", INT2FIX(SQLITE_READONLY_DBMOVED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "READONLY_DIRECTORY", INT2FIX(SQLITE_READONLY_DIRECTORY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "READONLY_RECOVERY", INT2FIX(SQLITE_READONLY_RECOVERY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "READONLY_ROLLBACK", INT2FIX(SQLITE_READONLY_ROLLBACK));
+
     /*  100 -- sqlite3_step() has another row ready */
     rb_define_const(mC_ResultCode, "ROW", INT2FIX(SQLITE_ROW));
 
@@ -336,15 +1267,72 @@ void Init_amalgalite_constants( )
     /*  18 -- String or BLOB exceeds size limit */
     rb_define_const(mC_ResultCode, "TOOBIG", INT2FIX(SQLITE_TOOBIG));
 
+    /*  28 -- Warnings from sqlite3_log() */
+    rb_define_const(mC_ResultCode, "WARNING", INT2FIX(SQLITE_WARNING));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "WARNING_AUTOINDEX", INT2FIX(SQLITE_WARNING_AUTOINDEX));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_SHM, "EXCLUSIVE", INT2FIX(SQLITE_SHM_EXCLUSIVE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_SHM, "LOCK", INT2FIX(SQLITE_SHM_LOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_SHM, "NLOCK", INT2FIX(SQLITE_SHM_NLOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_SHM, "SHARED", INT2FIX(SQLITE_SHM_SHARED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_SHM, "UNLOCK", INT2FIX(SQLITE_SHM_UNLOCK));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ScanStat, "EST", INT2FIX(SQLITE_SCANSTAT_EST));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ScanStat, "EXPLAIN", INT2FIX(SQLITE_SCANSTAT_EXPLAIN));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ScanStat, "NAME", INT2FIX(SQLITE_SCANSTAT_NAME));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ScanStat, "NLOOP", INT2FIX(SQLITE_SCANSTAT_NLOOP));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ScanStat, "NVISIT", INT2FIX(SQLITE_SCANSTAT_NVISIT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ScanStat, "SELECTID", INT2FIX(SQLITE_SCANSTAT_SELECTID));
+
+    /*  0x001 -- Do no memory allocations */
+    rb_define_const(mC_Serialize, "NOCOPY", INT2FIX(SQLITE_SERIALIZE_NOCOPY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Session, "CONFIG_STRMSIZE", INT2FIX(SQLITE_SESSION_CONFIG_STRMSIZE));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_StatementStatus, "AUTOINDEX", INT2FIX(SQLITE_STMTSTATUS_AUTOINDEX));
 
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_StatementStatus, "FULLSCAN_STEP", INT2FIX(SQLITE_STMTSTATUS_FULLSCAN_STEP));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_StatementStatus, "MEMUSED", INT2FIX(SQLITE_STMTSTATUS_MEMUSED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_StatementStatus, "REPREPARE", INT2FIX(SQLITE_STMTSTATUS_REPREPARE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_StatementStatus, "RUN", INT2FIX(SQLITE_STMTSTATUS_RUN));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_StatementStatus, "SORT", INT2FIX(SQLITE_STMTSTATUS_SORT));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_StatementStatus, "VM_STEP", INT2FIX(SQLITE_STMTSTATUS_VM_STEP));
+
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_Status, "MALLOC_COUNT", INT2FIX(SQLITE_STATUS_MALLOC_COUNT));
 
@@ -366,13 +1354,79 @@ void Init_amalgalite_constants( )
     /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
     rb_define_const(mC_Status, "PARSER_STACK", INT2FIX(SQLITE_STATUS_PARSER_STACK));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  4 -- NOT USED */
     rb_define_const(mC_Status, "SCRATCH_OVERFLOW", INT2FIX(SQLITE_STATUS_SCRATCH_OVERFLOW));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  8 -- NOT USED */
     rb_define_const(mC_Status, "SCRATCH_SIZE", INT2FIX(SQLITE_STATUS_SCRATCH_SIZE));
 
-    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    /*  3 -- NOT USED */
     rb_define_const(mC_Status, "SCRATCH_USED", INT2FIX(SQLITE_STATUS_SCRATCH_USED));
 
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Sync, "DATAONLY", INT2FIX(SQLITE_SYNC_DATAONLY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Sync, "FULL", INT2FIX(SQLITE_SYNC_FULL));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Sync, "NORMAL", INT2FIX(SQLITE_SYNC_NORMAL));
+
+    /*  5 -- Deprecated */
+    rb_define_const(mC_TextEncoding, "ANY", INT2FIX(SQLITE_ANY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_TextEncoding, "DETERMINISTIC", INT2FIX(SQLITE_DETERMINISTIC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_TextEncoding, "DIRECTONLY", INT2FIX(SQLITE_DIRECTONLY));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_TextEncoding, "INNOCUOUS", INT2FIX(SQLITE_INNOCUOUS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_TextEncoding, "SUBTYPE", INT2FIX(SQLITE_SUBTYPE));
+
+    /*  4 -- Use native byte order */
+    rb_define_const(mC_TextEncoding, "UTF16", INT2FIX(SQLITE_UTF16));
+
+    /*  3 -- IMP: R-51971-34154 */
+    rb_define_const(mC_TextEncoding, "UTF16BE", INT2FIX(SQLITE_UTF16BE));
+
+    /*  2 -- IMP: R-03371-37637 */
+    rb_define_const(mC_TextEncoding, "UTF16LE", INT2FIX(SQLITE_UTF16LE));
+
+    /*  8 -- sqlite3_create_collation only */
+    rb_define_const(mC_TextEncoding, "UTF16_ALIGNED", INT2FIX(SQLITE_UTF16_ALIGNED));
+
+    /*  1 -- IMP: R-37514-35566 */
+    rb_define_const(mC_TextEncoding, "UTF8", INT2FIX(SQLITE_UTF8));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Trace, "CLOSE", INT2FIX(SQLITE_TRACE_CLOSE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Trace, "PROFILE", INT2FIX(SQLITE_TRACE_PROFILE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Trace, "ROW", INT2FIX(SQLITE_TRACE_ROW));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Trace, "STMT", INT2FIX(SQLITE_TRACE_STMT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Transaction, "NONE", INT2FIX(SQLITE_TXN_NONE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Transaction, "READ", INT2FIX(SQLITE_TXN_READ));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Transaction, "WRITE", INT2FIX(SQLITE_TXN_WRITE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Win32, "DATA_DIRECTORY_TYPE", INT2FIX(SQLITE_WIN32_DATA_DIRECTORY_TYPE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Win32, "TEMP_DIRECTORY_TYPE", INT2FIX(SQLITE_WIN32_TEMP_DIRECTORY_TYPE));
+
 }