amalgalite 1.6.0-x64-mingw32

data/ext/amalgalite/c/amalgalite.h

@@ -0,0 +1,151 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#ifndef __AMALGALITE_H__
+#define __AMALGALITE_H__
+
+#include "ruby.h"
+#include "sqlite3.h"
+#include <string.h>
+
+/* wrapper struct around the sqlite3 opaque pointer */
+typedef struct am_sqlite3 {
+  sqlite3 *db;
+  VALUE    trace_obj;
+  VALUE    profile_obj;
+  VALUE    busy_handler_obj;
+  VALUE    progress_handler_obj;
+} am_sqlite3;
+
+/* wrapper struct around the sqlite3_statement opaque pointer */
+typedef struct am_sqlite3_stmt {
+  sqlite3_stmt *stmt;
+  VALUE         remaining_sql;
+} am_sqlite3_stmt;
+
+/* wrapper struct around the sqlite3_blob opaque ponter */
+typedef struct am_sqlite3_blob {
+  sqlite3_blob *blob;
+  sqlite3      *db;
+  int           length;
+  int           current_offset;
+} am_sqlite3_blob;
+
+/* wrapper struct around the information needed to call rb_apply
+ * used to encapsulate data into a call for amalgalite_wrap_apply
+ */
+typedef struct am_protected {
+    VALUE     instance;
+    ID        method;
+    int       argc;
+    VALUE    *argv;
+} am_protected_t;
+
+/** module and classes **/
+extern VALUE mA;              /* module Amalgalite                     */
+extern VALUE mAS;             /* module Amalgalite::SQLite3            */
+extern VALUE mASV;            /* module Amalgalite::SQLite3::Version   */
+extern VALUE eAS_Error;       /* class  Amalgalite::SQLite3::Error     */
+extern VALUE cAR;             /* class  Amalgalite::Requries */
+extern VALUE cARB;            /* class  Amalgalite::Requries::Bootstrap  */
+
+/*----------------------------------------------------------------------
+ * Prototype for Amalgalite::SQLite3::Database
+ *---------------------------------------------------------------------*/
+extern VALUE cAS_Database;    /* class  Amalgalite::SQLite3::Database  */
+
+extern void  am_define_constants_under(VALUE);
+extern VALUE am_sqlite3_database_alloc(VALUE klass);
+extern void  am_sqlite3_database_free(am_sqlite3*);
+extern VALUE am_sqlite3_database_open(int argc, VALUE* argv, VALUE self);
+extern VALUE am_sqlite3_database_close(VALUE self);
+extern VALUE am_sqlite3_database_open16(VALUE self, VALUE rFilename);
+extern VALUE am_sqlite3_database_last_insert_rowid(VALUE self);
+extern VALUE am_sqlite3_database_is_autocommit(VALUE self);
+extern VALUE am_sqlite3_database_row_changes(VALUE self);
+extern VALUE am_sqlite3_database_total_changes(VALUE self);
+extern VALUE am_sqlite3_database_table_column_metadata(VALUE self, VALUE db_name, VALUE tbl_name, VALUE col_name);
+
+extern VALUE am_sqlite3_database_prepare(VALUE self, VALUE rSQL);
+extern VALUE am_sqlite3_database_register_trace_tap(VALUE self, VALUE tap);
+extern VALUE am_sqlite3_database_register_profile_tap(VALUE self, VALUE tap);
+extern VALUE am_sqlite3_database_busy_handler(VALUE self, VALUE handler);
+
+/*----------------------------------------------------------------------
+ * Prototype for Amalgalite::SQLite3::Statement 
+ *---------------------------------------------------------------------*/
+extern VALUE cAS_Statement;   /* class  Amalgalite::SQLite3::Statement */
+
+extern VALUE am_sqlite3_statement_alloc(VALUE klass);
+extern void  am_sqlite3_statement_free(am_sqlite3_stmt* );
+extern VALUE am_sqlite3_statement_sql(VALUE self);
+extern VALUE am_sqlite3_statement_close(VALUE self);
+extern VALUE am_sqlite3_statement_step(VALUE self);
+extern VALUE am_sqlite3_statement_column_count(VALUE self);
+extern VALUE am_sqlite3_statement_column_name(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_decltype(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_type(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_blob(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_text(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_int(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_int64(VALUE self, VALUE index);
+extern VALUE am_sqlite3_statement_column_double(VALUE self, VALUE index);
+
+extern VALUE am_sqlite3_statement_column_database_name(VALUE self, VALUE position);
+extern VALUE am_sqlite3_statement_column_table_name(VALUE self, VALUE position);
+extern VALUE am_sqlite3_statement_column_origin_name(VALUE self, VALUE position);
+
+extern VALUE am_sqlite3_statement_reset(VALUE self);
+extern VALUE am_sqlite3_statement_clear_bindings(VALUE self);
+extern VALUE am_sqlite3_statement_bind_parameter_count(VALUE self);
+extern VALUE am_sqlite3_statement_bind_parameter_index(VALUE self, VALUE parameter_name);
+extern VALUE am_sqlite3_statement_remaining_sql(VALUE self);
+extern VALUE am_sqlite3_statement_bind_text(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_blob(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_zeroblob(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_int(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_int64(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_double(VALUE self, VALUE position, VALUE value);
+extern VALUE am_sqlite3_statement_bind_null(VALUE self, VALUE position);
+
+/*----------------------------------------------------------------------
+ * Prototype for Amalgalite::SQLite3::Blob
+ *---------------------------------------------------------------------*/
+extern VALUE cAS_Blob; /* class Amalgalite::SQLite3::Blob */
+
+extern VALUE am_sqlite3_blob_alloc(VALUE klass);
+extern VALUE am_sqlite3_blob_initialize( VALUE self, VALUE db, VALUE db_name, VALUE table_name, VALUE column_name, VALUE rowid, VALUE flag) ;
+extern void  am_sqlite3_blob_free(am_sqlite3_blob* );
+extern VALUE am_sqlite3_blob_read(VALUE self, VALUE length);
+extern VALUE am_sqlite3_blob_write(VALUE self, VALUE buffer);
+extern VALUE am_sqlite3_blob_close(VALUE self);
+extern VALUE am_sqlite3_blob_length(VALUE self);
+
+/*----------------------------------------------------------------------
+ * more initialization methods
+ *----------------------------------------------------------------------*/
+extern void Init_amalgalite_constants( );
+extern void Init_amalgalite_database( );
+extern void Init_amalgalite_statement( );
+extern void Init_amalgalite_blob( );
+extern void Init_amalgalite_requires_bootstrap( );
+
+ 
+/***********************************************************************
+ * Type conversion macros between sqlite data types and ruby types
+ **********************************************************************/
+
+#define SQLINT64_2NUM(x)      ( LL2NUM( x ) )
+#define SQLUINT64_2NUM(x)     ( ULL2NUM( x ) )
+#define NUM2SQLINT64( obj )   ( NUM2LL( obj ) )
+#define NUM2SQLUINT64( obj )  ( NUM2ULL( obj ) )
+
+/***********************************************************************
+ * return the last exception in ruby's error message
+ */
+#define ERROR_INFO_MESSAGE()  ( rb_obj_as_string( rb_gv_get("$!") ) )
+#endif

data/ext/amalgalite/c/amalgalite_blob.c

@@ -0,0 +1,240 @@
+#include "amalgalite.h"
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+/* class  Amalgliate::SQLite3::Blob */
+VALUE cAS_Blob;   
+
+/**
+ * call-seq:
+ *   Blob.new( database, table_name, column_name, row_id, flag ) -> Blob
+ *
+ * Create a new Blob object and associate it with the approriate, database,
+ * table, column and row.  +flag+ indicates if the Blob is to be opened for
+ * writing "w" or reading "r".
+ *
+ */
+VALUE am_sqlite3_blob_initialize( VALUE self, VALUE db, VALUE db_name, VALUE table_name, VALUE column_name, VALUE rowid, VALUE flag) 
+{
+    am_sqlite3_blob *am_blob;
+    int              rc;
+    am_sqlite3      *am_db;
+    char            *zDb      = StringValuePtr( db_name );
+    char            *zTable   = StringValuePtr( table_name );
+    char            *zColumn  = StringValuePtr( column_name );
+    sqlite3_int64    iRow     = NUM2SQLINT64( rowid )  ;
+    VALUE            flag_str = StringValue( flag );
+    int              flags    = 0;
+
+    /* extract the blob struct */
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+    
+    /* extract the sqlite3 db struct */
+    Data_Get_Struct(db, am_sqlite3, am_db);
+
+    /* make sure that the flags are valid, only 'r' or 'w' are allowed */
+    if ( ( RSTRING_LEN( flag_str ) != 1) || 
+         ( ( 'r' != RSTRING_PTR( flag_str )[0] ) && 
+           ( 'w' != RSTRING_PTR( flag_str )[0] ))) {
+        rb_raise( eAS_Error, "Error opening Blob in db = %s, table = %s, column = %s, rowid = %lu.  Invalid flag '%s'.  Must be either 'w' or 'r'\n",
+                             zDb, zTable, zColumn, (unsigned long)iRow, RSTRING_PTR( flag_str ));
+    }
+
+    /* switch to write mode */
+    if ( 'w' == RSTRING_PTR( flag_str )[0] ) { 
+        flags = 1;
+    }
+
+    /* open the blob and associate the db to it */
+    rc = sqlite3_blob_open( am_db->db, zDb, zTable, zColumn, iRow, flags, &( am_blob->blob ) );
+    if ( SQLITE_OK != rc ) {
+        rb_raise( eAS_Error, "Error opening Blob in db = %s, table = %s, column = %s, rowid = %lu : [SQLITE_ERROR %d] %s\n", zDb, zTable, zColumn, (unsigned long)iRow, rc, sqlite3_errmsg( am_db->db) );  
+    }
+    am_blob->length = sqlite3_blob_bytes( am_blob->blob );
+    am_blob->db = am_db->db;
+
+    /* if a block is given then yield self and close the blob when done */
+    if ( rb_block_given_p() ) {
+        rb_yield( self );
+        am_sqlite3_blob_close( self );
+        return Qnil;
+    } else {
+        return self;
+    }
+}
+
+/**
+ * call-seq:
+ *  blob.close -> nil
+ *
+ * Closes the blob.
+ */
+VALUE am_sqlite3_blob_close( VALUE self )
+{
+    am_sqlite3_blob *am_blob;
+    int              rc;
+    
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+    rc = sqlite3_blob_close( am_blob->blob );
+    if ( SQLITE_OK != rc ) {
+        rb_raise(eAS_Error, "Error closing blob: [SQLITE_ERROR %d] %s\n",
+                rc, sqlite3_errmsg( am_blob->db ));
+    }
+
+
+    return Qnil;
+}
+
+
+/**
+ * call-seq:
+ *  blob.length -> length in bytes of the blob
+ *
+ * Returns the number of bytes in the blob.
+ */
+VALUE am_sqlite3_blob_length( VALUE self )
+{
+    am_sqlite3_blob *am_blob;
+
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+
+    return INT2FIX( am_blob->length );
+}
+
+/**
+ * call-seq:
+ *   blob.read( int ) -> String containting int number of  bytes or nil if eof.
+ *
+ * returns int number of bytes as a String from the database
+ */
+VALUE am_sqlite3_blob_read( VALUE self, VALUE length )
+{
+    am_sqlite3_blob *am_blob;
+    int             rc;
+    int              n = NUM2INT( length );
+    void           *buf = NULL;
+    VALUE          result;
+
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+
+    /* we have to be exact on the number of bytes to read.  n + current_offset
+     * cannot be larger than the blob's length
+     */
+    if ( (n + am_blob->current_offset > am_blob->length)) {
+        n = am_blob->length - am_blob->current_offset;
+    }
+
+    if ( am_blob->current_offset == am_blob->length ) {
+        return Qnil;
+    }
+
+    buf = (void *)malloc( n );
+    rc = sqlite3_blob_read( am_blob->blob, buf, n, am_blob->current_offset); 
+
+    if ( rc != SQLITE_OK ) {
+        rb_raise(eAS_Error, "Error reading %d bytes blob at offset %d: [SQLITE_ERROR %d] %s\n",
+                n, am_blob->current_offset, rc, sqlite3_errmsg( am_blob->db ));
+    }
+
+    am_blob->current_offset += n;
+
+    result = rb_str_new( (char*)buf, n );
+    free( buf );
+    return result;
+
+}
+
+/**
+ * call-seq:
+ *   blob.write( buf ) -> int
+ *
+ * writes the contents of the string buffer to the blob and returns the number
+ * of bytes written.
+ *
+ */
+VALUE am_sqlite3_blob_write( VALUE self, VALUE buf )
+{
+    am_sqlite3_blob *am_blob;
+    int              rc;
+    VALUE            str = StringValue( buf );
+    int              n   = (int)RSTRING_LEN( str );
+    char            *chk_buf = NULL;
+
+    Data_Get_Struct(self, am_sqlite3_blob, am_blob);
+
+    rc = sqlite3_blob_write( am_blob->blob, RSTRING_PTR(str), n, am_blob->current_offset); 
+
+    if ( rc  != SQLITE_OK ) {
+        rb_raise(eAS_Error, "Error writing %d bytes blob at offset %d: [SQLITE_ERROR %d] %s\n",
+                n, am_blob->current_offset, rc, sqlite3_errmsg( am_blob->db ));
+    }
+
+    chk_buf = (char *) malloc( n  + 1);
+    chk_buf[n] = '\0';
+    sqlite3_blob_read( am_blob->blob, chk_buf, n, 0);
+
+    am_blob->current_offset += n;
+
+    return INT2FIX( n );
+
+}
+
+
+/***********************************************************************
+ * Ruby life cycle methods
+ ***********************************************************************/
+
+/*
+ * garbage collector free method for the am_sqlite3_blob structure
+ */
+void am_sqlite3_blob_free(am_sqlite3_blob* wrapper)
+{
+    free(wrapper);
+    return;
+}
+
+/*
+ * allocate the am_blob structure
+ */
+VALUE am_sqlite3_blob_alloc(VALUE klass)
+{
+    am_sqlite3_blob  *wrapper = ALLOC( am_sqlite3_blob );
+    VALUE             obj     ; 
+
+    wrapper->current_offset = 0;
+    wrapper->db             = NULL;
+    obj = Data_Wrap_Struct(klass, NULL, am_sqlite3_blob_free, wrapper);
+    return obj;
+}
+
+
+/**
+ * Document-class: Amalgalite::SQLite3::Blob
+ *
+ * The Blob class enables incremental IO on blob items.  If you do not need
+ * incremental IO on a binary object, then you do not need to use Blob.
+ */
+
+void Init_amalgalite_blob( )
+{
+
+    VALUE ma  = rb_define_module("Amalgalite");
+    VALUE mas = rb_define_module_under(ma, "SQLite3");
+
+    /*
+     * Encapsulate the SQLite3 Statement handle in a class
+     */
+    cAS_Blob = rb_define_class_under( mas, "Blob", rb_cObject ); 
+    rb_define_alloc_func(cAS_Blob, am_sqlite3_blob_alloc); 
+    rb_define_method(cAS_Blob, "initialize", am_sqlite3_blob_initialize, 6); 
+    rb_define_method(cAS_Blob, "close", am_sqlite3_blob_close, 0); 
+    rb_define_method(cAS_Blob, "read", am_sqlite3_blob_read, 1); 
+    rb_define_method(cAS_Blob, "write", am_sqlite3_blob_write, 1); 
+    rb_define_method(cAS_Blob, "length", am_sqlite3_blob_length, 0); 
+}
+
+

data/ext/amalgalite/c/amalgalite_constants.c

@@ -0,0 +1,1226 @@
+/* Generated by gen_constants.rb -- do not edit */
+
+#include "amalgalite.h"
+/**
+ * Document-class: Amalgalite::SQLite3::Constants
+ *
+ * class holding constants in the sqlite extension
+ */
+void Init_amalgalite_constants( )
+{
+
+    VALUE ma  = rb_define_module("Amalgalite");
+    VALUE mas = rb_define_module_under(ma, "SQLite3");
+
+    /*
+     * 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 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
+     */
+    VALUE mC_DBStatus = rb_define_module_under(mC, "DBStatus");
+
+    /**
+     * module encapsulating the SQLite3 C extension constants for DataType
+     */
+    VALUE mC_DataType = rb_define_module_under(mC, "DataType");
+
+    /**
+     * 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 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 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");
+
+    /* 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));
+
+    /*  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));
+
+    /*  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));
+
+    /*  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));
+
+    /*  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));
+
+    /*  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));
+
+    /*  1006 -- int int* */
+    rb_define_const(mC_DBConfig, "NO_CKPT_ON_CLOSE", INT2FIX(SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE));
+
+    /* 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_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));
+
+    /*  11 -- 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));
+
+    /* 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, "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, "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, "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, "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, "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_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));
+
+    /* 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_Index, "CONSTRAINT_LIKE", INT2FIX(SQLITE_INDEX_CONSTRAINT_LIKE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_LT", INT2FIX(SQLITE_INDEX_CONSTRAINT_LT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_MATCH", INT2FIX(SQLITE_INDEX_CONSTRAINT_MATCH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Index, "CONSTRAINT_NE", INT2FIX(SQLITE_INDEX_CONSTRAINT_NE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    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_Limit, "ATTACHED", INT2FIX(SQLITE_LIMIT_ATTACHED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "COLUMN", INT2FIX(SQLITE_LIMIT_COLUMN));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "COMPOUND_SELECT", INT2FIX(SQLITE_LIMIT_COMPOUND_SELECT));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "EXPR_DEPTH", INT2FIX(SQLITE_LIMIT_EXPR_DEPTH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "FUNCTION_ARG", INT2FIX(SQLITE_LIMIT_FUNCTION_ARG));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "LENGTH", INT2FIX(SQLITE_LIMIT_LENGTH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    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_Limit, "SQL_LENGTH", INT2FIX(SQLITE_LIMIT_SQL_LENGTH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "TRIGGER_DEPTH", INT2FIX(SQLITE_LIMIT_TRIGGER_DEPTH));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "VARIABLE_NUMBER", INT2FIX(SQLITE_LIMIT_VARIABLE_NUMBER));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "VDBE_OP", INT2FIX(SQLITE_LIMIT_VDBE_OP));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Limit, "WORKER_THREADS", INT2FIX(SQLITE_LIMIT_WORKER_THREADS));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Lock, "EXCLUSIVE", INT2FIX(SQLITE_LOCK_EXCLUSIVE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Lock, "NONE", INT2FIX(SQLITE_LOCK_NONE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Lock, "PENDING", INT2FIX(SQLITE_LOCK_PENDING));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Lock, "RESERVED", INT2FIX(SQLITE_LOCK_RESERVED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Lock, "SHARED", INT2FIX(SQLITE_LOCK_SHARED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Mutex, "FAST", INT2FIX(SQLITE_MUTEX_FAST));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    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_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));
+
+    /*  0x00000004 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "CREATE", INT2FIX(SQLITE_OPEN_CREATE));
+
+    /*  0x00000008 -- VFS only */
+    rb_define_const(mC_Open, "DELETEONCLOSE", INT2FIX(SQLITE_OPEN_DELETEONCLOSE));
+
+    /*  0x00000010 -- VFS only */
+    rb_define_const(mC_Open, "EXCLUSIVE", INT2FIX(SQLITE_OPEN_EXCLUSIVE));
+
+    /*  0x00010000 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "FULLMUTEX", INT2FIX(SQLITE_OPEN_FULLMUTEX));
+
+    /*  0x00000100 -- VFS only */
+    rb_define_const(mC_Open, "MAIN_DB", INT2FIX(SQLITE_OPEN_MAIN_DB));
+
+    /*  0x00000800 -- VFS only */
+    rb_define_const(mC_Open, "MAIN_JOURNAL", INT2FIX(SQLITE_OPEN_MAIN_JOURNAL));
+
+    /*  0x00004000 -- VFS only */
+    rb_define_const(mC_Open, "MASTER_JOURNAL", INT2FIX(SQLITE_OPEN_MASTER_JOURNAL));
+
+    /*  0x00000080 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "MEMORY", INT2FIX(SQLITE_OPEN_MEMORY));
+
+    /*  0x00008000 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "NOMUTEX", INT2FIX(SQLITE_OPEN_NOMUTEX));
+
+    /*  0x00040000 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "PRIVATECACHE", INT2FIX(SQLITE_OPEN_PRIVATECACHE));
+
+    /*  0x00000001 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "READONLY", INT2FIX(SQLITE_OPEN_READONLY));
+
+    /*  0x00000002 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "READWRITE", INT2FIX(SQLITE_OPEN_READWRITE));
+
+    /*  0x00020000 -- Ok for sqlite3_open_v2() */
+    rb_define_const(mC_Open, "SHAREDCACHE", INT2FIX(SQLITE_OPEN_SHAREDCACHE));
+
+    /*  0x00002000 -- VFS only */
+    rb_define_const(mC_Open, "SUBJOURNAL", INT2FIX(SQLITE_OPEN_SUBJOURNAL));
+
+    /*  0x00000200 -- VFS only */
+    rb_define_const(mC_Open, "TEMP_DB", INT2FIX(SQLITE_OPEN_TEMP_DB));
+
+    /*  0x00001000 -- VFS only */
+    rb_define_const(mC_Open, "TEMP_JOURNAL", INT2FIX(SQLITE_OPEN_TEMP_JOURNAL));
+
+    /*  0x00000400 -- VFS only */
+    rb_define_const(mC_Open, "TRANSIENT_DB", INT2FIX(SQLITE_OPEN_TRANSIENT_DB));
+
+    /*  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, "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));
+
+    /*  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));
+
+    /* 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));
+
+    /*  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_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_VTAB", INT2FIX(SQLITE_CORRUPT_VTAB));
+
+    /*  101 -- sqlite3_step() has finished executing */
+    rb_define_const(mC_ResultCode, "DONE", INT2FIX(SQLITE_DONE));
+
+    /*  16 -- Internal use only */
+    rb_define_const(mC_ResultCode, "EMPTY", INT2FIX(SQLITE_EMPTY));
+
+    /*  1 -- Generic error */
+    rb_define_const(mC_ResultCode, "ERROR", INT2FIX(SQLITE_ERROR));
+
+    /*  24 -- Not used */
+    rb_define_const(mC_ResultCode, "FORMAT", INT2FIX(SQLITE_FORMAT));
+
+    /*  13 -- Insertion failed because database is full */
+    rb_define_const(mC_ResultCode, "FULL", INT2FIX(SQLITE_FULL));
+
+    /*  2 -- Internal logic error in SQLite */
+    rb_define_const(mC_ResultCode, "INTERNAL", INT2FIX(SQLITE_INTERNAL));
+
+    /*  9 -- Operation terminated by sqlite3_interrupt() */
+    rb_define_const(mC_ResultCode, "INTERRUPT", INT2FIX(SQLITE_INTERRUPT));
+
+    /*  10 -- Some kind of disk I/O error occurred */
+    rb_define_const(mC_ResultCode, "IOERR", INT2FIX(SQLITE_IOERR));
+
+    /* 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));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_CHECKRESERVEDLOCK", INT2FIX(SQLITE_IOERR_CHECKRESERVEDLOCK));
+
+    /* 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_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));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_DIR_FSYNC", INT2FIX(SQLITE_IOERR_DIR_FSYNC));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_FSTAT", INT2FIX(SQLITE_IOERR_FSTAT));
+
+    /* 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));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_RDLOCK", INT2FIX(SQLITE_IOERR_RDLOCK));
+
+    /* 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));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_SHMSIZE", INT2FIX(SQLITE_IOERR_SHMSIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_SHORT_READ", INT2FIX(SQLITE_IOERR_SHORT_READ));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "IOERR_TRUNCATE", INT2FIX(SQLITE_IOERR_TRUNCATE));
+
+    /* 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));
+
+    /*  6 -- A table in the database is locked */
+    rb_define_const(mC_ResultCode, "LOCKED", INT2FIX(SQLITE_LOCKED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_ResultCode, "LOCKED_SHAREDCACHE", INT2FIX(SQLITE_LOCKED_SHAREDCACHE));
+
+    /*  20 -- Data type mismatch */
+    rb_define_const(mC_ResultCode, "MISMATCH", INT2FIX(SQLITE_MISMATCH));
+
+    /*  21 -- Library used incorrectly */
+    rb_define_const(mC_ResultCode, "MISUSE", INT2FIX(SQLITE_MISUSE));
+
+    /*  22 -- Uses OS features not supported on host */
+    rb_define_const(mC_ResultCode, "NOLFS", INT2FIX(SQLITE_NOLFS));
+
+    /*  7 -- A malloc() failed */
+    rb_define_const(mC_ResultCode, "NOMEM", INT2FIX(SQLITE_NOMEM));
+
+    /*  26 -- File opened that is not a database file */
+    rb_define_const(mC_ResultCode, "NOTADB", INT2FIX(SQLITE_NOTADB));
+
+    /*  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));
+
+    /*  3 -- Access permission denied */
+    rb_define_const(mC_ResultCode, "PERM", INT2FIX(SQLITE_PERM));
+
+    /*  15 -- Database lock protocol error */
+    rb_define_const(mC_ResultCode, "PROTOCOL", INT2FIX(SQLITE_PROTOCOL));
+
+    /*  25 -- 2nd parameter to sqlite3_bind out of range */
+    rb_define_const(mC_ResultCode, "RANGE", INT2FIX(SQLITE_RANGE));
+
+    /*  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_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_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));
+
+    /*  17 -- The database schema changed */
+    rb_define_const(mC_ResultCode, "SCHEMA", INT2FIX(SQLITE_SCHEMA));
+
+    /*  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));
+
+    /* 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));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "MALLOC_SIZE", INT2FIX(SQLITE_STATUS_MALLOC_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "MEMORY_USED", INT2FIX(SQLITE_STATUS_MEMORY_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PAGECACHE_OVERFLOW", INT2FIX(SQLITE_STATUS_PAGECACHE_OVERFLOW));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PAGECACHE_SIZE", INT2FIX(SQLITE_STATUS_PAGECACHE_SIZE));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PAGECACHE_USED", INT2FIX(SQLITE_STATUS_PAGECACHE_USED));
+
+    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/
+    rb_define_const(mC_Status, "PARSER_STACK", INT2FIX(SQLITE_STATUS_PARSER_STACK));
+
+    /*  4 -- NOT USED */
+    rb_define_const(mC_Status, "SCRATCH_OVERFLOW", INT2FIX(SQLITE_STATUS_SCRATCH_OVERFLOW));
+
+    /*  8 -- NOT USED */
+    rb_define_const(mC_Status, "SCRATCH_SIZE", INT2FIX(SQLITE_STATUS_SCRATCH_SIZE));
+
+    /*  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));
+
+    /*  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));
+
+}