amalgalite 1.8.0-x64-mingw-ucrt

data/ext/amalgalite/c/gen_constants.rb

@@ -0,0 +1,353 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+
+# readin in the sqlite3.h file and parse out all the #define lines
+sqlite3_h_fname = File.expand_path(File.join(File.dirname(__FILE__), "sqlite3.h"))
+
+# special handling for those that are function result codes
+result_codes = %w[
+  SQLITE_OK
+  SQLITE_ERROR
+  SQLITE_INTERNAL
+  SQLITE_PERM
+  SQLITE_ABORT
+  SQLITE_BUSY
+  SQLITE_LOCKED
+  SQLITE_NOMEM
+  SQLITE_READONLY
+  SQLITE_INTERRUPT
+  SQLITE_IOERR
+  SQLITE_CORRUPT
+  SQLITE_NOTFOUND
+  SQLITE_FULL
+  SQLITE_CANTOPEN
+  SQLITE_PROTOCOL
+  SQLITE_EMPTY
+  SQLITE_SCHEMA
+  SQLITE_TOOBIG
+  SQLITE_CONSTRAINT
+  SQLITE_MISMATCH
+  SQLITE_MISUSE
+  SQLITE_NOLFS
+  SQLITE_AUTH
+  SQLITE_FORMAT
+  SQLITE_RANGE
+  SQLITE_NOTADB
+  SQLITE_NOTICE
+  SQLITE_WARNING
+  SQLITE_ROW
+  SQLITE_DONE
+  SQLITE_ERROR_MISSING_COLLSEQ
+  SQLITE_ERROR_RETRY
+  SQLITE_ERROR_SNAPSHOT
+  SQLITE_IOERR_READ
+  SQLITE_IOERR_SHORT_READ
+  SQLITE_IOERR_WRITE
+  SQLITE_IOERR_FSYNC
+  SQLITE_IOERR_DIR_FSYNC
+  SQLITE_IOERR_TRUNCATE
+  SQLITE_IOERR_FSTAT
+  SQLITE_IOERR_UNLOCK
+  SQLITE_IOERR_RDLOCK
+  SQLITE_IOERR_DELETE
+  SQLITE_IOERR_BLOCKED
+  SQLITE_IOERR_NOMEM
+  SQLITE_IOERR_ACCESS
+  SQLITE_IOERR_CHECKRESERVEDLOCK
+  SQLITE_IOERR_LOCK
+  SQLITE_IOERR_CLOSE
+  SQLITE_IOERR_DIR_CLOSE
+  SQLITE_IOERR_SHMOPEN
+  SQLITE_IOERR_SHMSIZE
+  SQLITE_IOERR_SHMLOCK
+  SQLITE_IOERR_SHMMAP
+  SQLITE_IOERR_SEEK
+  SQLITE_IOERR_DELETE_NOENT
+  SQLITE_IOERR_MMAP
+  SQLITE_IOERR_GETTEMPPATH
+  SQLITE_IOERR_CONVPATH
+  SQLITE_IOERR_VNODE
+  SQLITE_IOERR_AUTH
+  SQLITE_IOERR_BEGIN_ATOMIC
+  SQLITE_IOERR_COMMIT_ATOMIC
+  SQLITE_IOERR_ROLLBACK_ATOMIC
+  SQLITE_IOERR_DATA
+  SQLITE_IOERR_CORRUPTFS
+  SQLITE_LOCKED_SHAREDCACHE
+  SQLITE_LOCKED_VTAB
+  SQLITE_BUSY_RECOVERY
+  SQLITE_BUSY_SNAPSHOT
+  SQLITE_BUSY_TIMEOUT
+  SQLITE_CANTOPEN_NOTEMPDIR
+  SQLITE_CANTOPEN_ISDIR
+  SQLITE_CANTOPEN_FULLPATH
+  SQLITE_CANTOPEN_CONVPATH
+  SQLITE_CANTOPEN_DIRTYWAL
+  SQLITE_CANTOPEN_SYMLINK
+  SQLITE_CORRUPT_VTAB
+  SQLITE_CORRUPT_SEQUENCE
+  SQLITE_CORRUPT_INDEX
+  SQLITE_READONLY_RECOVERY
+  SQLITE_READONLY_CANTLOCK
+  SQLITE_READONLY_ROLLBACK
+  SQLITE_READONLY_DBMOVED
+  SQLITE_READONLY_CANTINIT
+  SQLITE_READONLY_DIRECTORY
+  SQLITE_ABORT_ROLLBACK
+  SQLITE_CONSTRAINT_CHECK
+  SQLITE_CONSTRAINT_COMMITHOOK
+  SQLITE_CONSTRAINT_FOREIGNKEY
+  SQLITE_CONSTRAINT_FUNCTION
+  SQLITE_CONSTRAINT_NOTNULL
+  SQLITE_CONSTRAINT_PRIMARYKEY
+  SQLITE_CONSTRAINT_TRIGGER
+  SQLITE_CONSTRAINT_UNIQUE
+  SQLITE_CONSTRAINT_VTAB
+  SQLITE_CONSTRAINT_ROWID
+  SQLITE_CONSTRAINT_PINNED
+  SQLITE_NOTICE_RECOVER_WAL
+  SQLITE_NOTICE_RECOVER_ROLLBACK
+  SQLITE_WARNING_AUTOINDEX
+  SQLITE_AUTH_USER
+  SQLITE_OK_LOAD_PERMANENTLY
+  SQLITE_OK_SYMLINK
+]
+
+deprecated_codes = %w[ SQLITE_GET_LOCKPROXYFILE SQLITE_SET_LOCKPROXYFILE SQLITE_LAST_ERRNO ]
+version_codes    = %w[ SQLITE_VERSION SQLITE_VERSION_NUMBER SQLITE_SOURCE_ID ]
+rtree_codes      = %w[ NOT_WITHIN PARTLY_WITHIN FULLY_WITHIN ]
+
+authorizer_codes = %w[
+  SQLITE_DENY
+  SQLITE_IGNORE
+  SQLITE_CREATE_INDEX
+  SQLITE_CREATE_TABLE
+  SQLITE_CREATE_TEMP_INDEX
+  SQLITE_CREATE_TEMP_TABLE
+  SQLITE_CREATE_TEMP_TRIGGER
+  SQLITE_CREATE_TEMP_VIEW
+  SQLITE_CREATE_TRIGGER
+  SQLITE_CREATE_VIEW
+  SQLITE_DELETE
+  SQLITE_DROP_INDEX
+  SQLITE_DROP_TABLE
+  SQLITE_DROP_TEMP_INDEX
+  SQLITE_DROP_TEMP_TABLE
+  SQLITE_DROP_TEMP_TRIGGER
+  SQLITE_DROP_TEMP_VIEW
+  SQLITE_DROP_TRIGGER
+  SQLITE_DROP_VIEW
+  SQLITE_INSERT
+  SQLITE_PRAGMA
+  SQLITE_READ
+  SQLITE_SELECT
+  SQLITE_TRANSACTION
+  SQLITE_UPDATE
+  SQLITE_ATTACH
+  SQLITE_DETACH
+  SQLITE_ALTER_TABLE
+  SQLITE_REINDEX
+  SQLITE_ANALYZE
+  SQLITE_CREATE_VTABLE
+  SQLITE_DROP_VTABLE
+  SQLITE_FUNCTION
+  SQLITE_SAVEPOINT
+  SQLITE_COPY
+  SQLITE_RECURSIVE
+]
+
+text_encoding_codes = %w[
+  SQLITE_UTF8
+  SQLITE_UTF16LE
+  SQLITE_UTF16BE
+  SQLITE_UTF16
+  SQLITE_ANY
+  SQLITE_UTF16_ALIGNED
+  SQLITE_DETERMINISTIC
+  SQLITE_DIRECTONLY
+  SQLITE_SUBTYPE
+  SQLITE_INNOCUOUS
+]
+
+data_type_codes = %w[
+  SQLITE_INTEGER
+  SQLITE_FLOAT
+  SQLITE_BLOB
+  SQLITE_NULL
+  SQLITE3_TEXT
+]
+
+fts5_codes = %w[
+  FTS5_TOKENIZE_QUERY
+  FTS5_TOKENIZE_PREFIX
+  FTS5_TOKENIZE_DOCUMENT
+  FTS5_TOKENIZE_AUX
+  FTS5_TOKEN_COLOCATED
+]
+
+ignore_codes = [
+  # vtab related
+  "SQLITE_ROLLBACK",
+  "SQLITE_FAIL",
+  "SQLITE_REPLACE",
+  "SQLITE_VTAB_CONSTRAINT_SUPPORT",
+  "SQLITE_VTAB_INNOCUOUS",
+  "SQLITE_VTAB_DIRECTONLY",
+
+  # sqlite destructor callback codes
+  "SQLITE_STATIC",
+  "SQLITE_TRANSIENT",
+]
+
+# oddball name
+module_name_mapping  = {
+
+  "DBCONFIG"   => "DBConfig",
+  "DBSTATUS"   => "DBStatus",
+  "IOCAP"      => "IOCap",
+  "SHM"        => "SHM",
+  "SCANSTAT"   => "ScanStat",
+  "STMTSTATUS" => "StatementStatus",
+  "CHANGESETAPPLY" => "ChangesetApply",
+  "CHANGESETSTART" => "ChangesetStart",
+  "TXN" => "Transaction",
+}
+
+defines = []
+IO.readlines(sqlite3_h_fname).each do |l|
+  result = {
+    "c_define"  => nil,
+    "c_value"   => nil,
+    "docstring" => nil,
+
+    "is_error_code" => false,
+
+    "r_module"   => nil,
+    "r_constant" => nil,
+  }
+
+  if l =~ /beginning-of-error-codes/ .. l =~ /end-of-error-codes/ then
+    result["is_error_code"] = true
+  end
+
+  l.strip!
+  md = l.match(/\A#define\s+(\w+)\s+([^\/]+)\s*(\/\*(.*)\*\/)?\Z/)
+  next unless md
+
+  # Name munging
+  c_define = md[1]
+
+  c_parts    = c_define.gsub(/^SQLITE_/,'').split("_")
+  r_module   = c_parts.shift
+  r_constant = c_parts.join("_")
+
+
+  # custom module naming so they are human readable
+  r_module = module_name_mapping.fetch(r_module) { |m| r_module.capitalize }
+
+  case c_define
+  when *version_codes
+    next
+
+  when *deprecated_codes
+    next
+
+  when *rtree_codes
+    r_module = "RTree"
+    r_constant = c_define
+
+  when *result_codes
+    r_module   = "ResultCode"
+    r_constant = c_define.gsub(/^SQLITE_/,'')
+
+  when *authorizer_codes
+    r_module   = "Authorizer"
+    r_constant = c_define.gsub(/^SQLITE_/,'')
+
+  when *text_encoding_codes
+    r_module   = "TextEncoding"
+    r_constant = c_define.gsub(/^SQLITE_/,'')
+
+  when *data_type_codes
+    r_module = "DataType"
+    r_constant = c_define.gsub(/^SQLITE(3)?_/,'')
+
+  when *fts5_codes
+    r_module = "FTS5"
+    r_constant = c_define.gsub(/^FTS5_/,'')
+
+  when *ignore_codes
+    next
+
+  when /TESTCTRL/ # sqlite3 codes used in testing
+    next
+
+  when /^__/ # sqlite3 internal items
+    next
+  end
+
+  result["c_define"]   = c_define
+  result["c_value"]    = md[2].strip
+  if !md[4].nil? && (md[4].strip.length > 0) then
+    result["docstring"]  = md[4].strip
+  end
+  result["r_module"]   = r_module
+  result["r_constant"] = r_constant
+
+  defines << result
+end
+
+#
+# rework defines into constants
+#
+CONSTANTS = defines.group_by{ |d| d["r_module"] }
+
+fname = File.expand_path(File.join(File.dirname(__FILE__), "amalgalite_constants.c"))
+
+
+File.open(fname, "w+") do |f|
+  f.puts "/* Generated by gen_constants.rb -- do not edit */"
+  f.puts
+  f.puts '#include "amalgalite.h"'
+  f.puts '/**'
+  f.puts ' * Document-class: Amalgalite::SQLite3::Constants'
+  f.puts ' *'
+  f.puts ' * class holding constants in the sqlite extension'
+  f.puts ' */'
+  f.puts "void Init_amalgalite_constants( )"
+  f.puts "{"
+  f.puts
+  f.puts '    VALUE ma  = rb_define_module("Amalgalite");'
+  f.puts '    VALUE mas = rb_define_module_under(ma, "SQLite3");'
+  f.puts
+  f.puts "    /*"
+  f.puts "     * module encapsulating all the SQLite C extension constants "
+  f.puts "     */"
+  f.puts '    VALUE mC = rb_define_module_under( mas, "Constants");'
+
+
+  CONSTANTS.keys.sort.each do |mod|
+    f.puts "    /**"
+    f.puts "     * module encapsulating the SQLite3 C extension constants for #{mod}"
+    f.puts "     */"
+    f.puts "    VALUE mC_#{mod} = rb_define_module_under(mC, \"#{mod}\");"
+    f.puts 
+  end
+
+  CONSTANTS.keys.sort.each do |mod|
+    const_set = CONSTANTS[mod]
+    const_set.sort_by { |c| c["c_define"] }.each do |result|
+      sql_const = result["c_define"]
+      const_doc = "    /* no meaningful autogenerated documentation -- constant is self explanatory ?*/" 
+      if !result["docstring"].nil? then
+        const_doc = "    /*  #{result['c_value']} -- #{result['docstring']} */"
+      end
+      ruby_constant = result['r_constant']
+      f.puts const_doc
+      f.puts "    rb_define_const(mC_#{mod}, \"#{ruby_constant}\", INT2FIX(#{sql_const}));"
+      f.puts  
+    end
+  end
+  f.puts "}"
+end

data/ext/amalgalite/c/notes.txt

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