extralite 2.7 → 2.8

data/ext/extralite/query.c

@@ -15,8 +15,8 @@ ID ID_inspect;
 ID ID_slice;
 
 VALUE SYM_hash;
-VALUE SYM_argv;
-VALUE SYM_ary;
+VALUE SYM_splat;
+VALUE SYM_array;
 
 #define DB_GVL_MODE(query) Database_prepare_gvl_mode(query->db_struct)
 
@@ -68,8 +68,8 @@ static inline Query_t *self_to_query(VALUE obj) {
 
 static inline enum query_mode symbol_to_query_mode(VALUE sym) {
   if (sym == SYM_hash)          return QUERY_HASH;
-  if (sym == SYM_argv)          return QUERY_ARGV;
-  if (sym == SYM_ary)           return QUERY_ARY;
+  if (sym == SYM_splat)         return QUERY_SPLAT;
+  if (sym == SYM_array)         return QUERY_ARRAY;
 
   rb_raise(cError, "Invalid query mode");
 }
@@ -78,10 +78,10 @@ static inline VALUE query_mode_to_symbol(enum query_mode query_mode) {
   switch (query_mode) {
     case QUERY_HASH:
       return SYM_hash;
-    case QUERY_ARGV:
-      return SYM_argv;
-    case QUERY_ARY:
-      return SYM_ary;
+    case QUERY_SPLAT:
+      return SYM_splat;
+    case QUERY_ARRAY:
+      return SYM_array;
     default:
       rb_raise(cError, "Invalid mode");
   }
@@ -232,10 +232,10 @@ inline safe_query_impl query_impl(enum query_mode query_mode) {
   switch (query_mode) {
     case QUERY_HASH:
       return safe_query_hash;
-    case QUERY_ARGV:
-      return safe_query_argv;
-    case QUERY_ARY:
-      return safe_query_ary;
+    case QUERY_SPLAT:
+      return safe_query_splat;
+    case QUERY_ARRAY:
+      return safe_query_array;
     default:
       rb_raise(cError, "Invalid query mode (query_impl)");
   }
@@ -593,9 +593,12 @@ VALUE Query_mode_get(VALUE self) {
   return query_mode_to_symbol(query->query_mode);
 }
 
-/* Sets the query mode. This can be one of `:hash`, `:argv`, `:ary`.
+/* call-seq:
+ *   query.mode = mode
+ * 
+ * Sets the query mode. This can be one of `:hash`, `:splat`, `:array`.
  *
- * @param [Symbol] query mode
+ * @param mode [Symbol] query mode
  * @return [Symbol] query mode
  */
 VALUE Query_mode_set(VALUE self, VALUE mode) {
@@ -610,41 +613,39 @@ void Init_ExtraliteQuery(void) {
   cQuery = rb_define_class_under(mExtralite, "Query", rb_cObject);
   rb_define_alloc_func(cQuery, Query_allocate);
 
-  #define DEF(s, f, a) rb_define_method(cQuery, s, f, a)
-
-  DEF("bind",           Query_bind, -1);
-  DEF("close",          Query_close, 0);
-  DEF("closed?",        Query_closed_p, 0);
-  DEF("columns",        Query_columns, 0);
-  DEF("clone",          Query_clone, 0);
-  DEF("database",       Query_database, 0);
-  DEF("db",             Query_database, 0);
-  DEF("dup",            Query_clone, 0);
-  DEF("each",           Query_each, 0);
-  DEF("eof?",           Query_eof_p, 0);
-  DEF("execute",        Query_execute, -1);
-  DEF("<<",             Query_execute_chevrons, 1);
-  DEF("batch_execute",  Query_batch_execute, 1);
-  DEF("batch_query",    Query_batch_query, 1);
-  DEF("initialize",     Query_initialize, 3);
-  DEF("inspect",        Query_inspect, 0);
-  DEF("mode",           Query_mode_get, 0);
-  DEF("mode=",          Query_mode_set, 1);
-  DEF("next",           Query_next, -1);
-  DEF("reset",          Query_reset, 0);
-  DEF("sql",            Query_sql, 0);
-  DEF("status",         Query_status, -1);
-  DEF("to_a",           Query_to_a, 0);
-  DEF("transform",      Query_transform, 0);
+  rb_define_method(cQuery, "bind",           Query_bind, -1);
+  rb_define_method(cQuery, "close",          Query_close, 0);
+  rb_define_method(cQuery, "closed?",        Query_closed_p, 0);
+  rb_define_method(cQuery, "columns",        Query_columns, 0);
+  rb_define_method(cQuery, "clone",          Query_clone, 0);
+  rb_define_method(cQuery, "database",       Query_database, 0);
+  rb_define_method(cQuery, "db",             Query_database, 0);
+  rb_define_method(cQuery, "dup",            Query_clone, 0);
+  rb_define_method(cQuery, "each",           Query_each, 0);
+  rb_define_method(cQuery, "eof?",           Query_eof_p, 0);
+  rb_define_method(cQuery, "execute",        Query_execute, -1);
+  rb_define_method(cQuery, "<<",             Query_execute_chevrons, 1);
+  rb_define_method(cQuery, "batch_execute",  Query_batch_execute, 1);
+  rb_define_method(cQuery, "batch_query",    Query_batch_query, 1);
+  rb_define_method(cQuery, "initialize",     Query_initialize, 3);
+  rb_define_method(cQuery, "inspect",        Query_inspect, 0);
+  rb_define_method(cQuery, "mode",           Query_mode_get, 0);
+  rb_define_method(cQuery, "mode=",          Query_mode_set, 1);
+  rb_define_method(cQuery, "next",           Query_next, -1);
+  rb_define_method(cQuery, "reset",          Query_reset, 0);
+  rb_define_method(cQuery, "sql",            Query_sql, 0);
+  rb_define_method(cQuery, "status",         Query_status, -1);
+  rb_define_method(cQuery, "to_a",           Query_to_a, 0);
+  rb_define_method(cQuery, "transform",      Query_transform, 0);
 
   ID_inspect  = rb_intern("inspect");
   ID_slice    = rb_intern("slice");
 
   SYM_hash          = ID2SYM(rb_intern("hash"));
-  SYM_argv          = ID2SYM(rb_intern("argv"));
-  SYM_ary           = ID2SYM(rb_intern("ary"));
+  SYM_splat          = ID2SYM(rb_intern("splat"));
+  SYM_array           = ID2SYM(rb_intern("array"));
 
   rb_gc_register_mark_object(SYM_hash);
-  rb_gc_register_mark_object(SYM_argv);
-  rb_gc_register_mark_object(SYM_ary);
+  rb_gc_register_mark_object(SYM_splat);
+  rb_gc_register_mark_object(SYM_array);
 }

data/gemspec.rb

@@ -18,7 +18,7 @@ def common_spec(s)
   s.required_ruby_version = '>= 3.0'
 
   s.add_development_dependency  'rake-compiler',        '1.2.7'
-  s.add_development_dependency  'minitest',             '5.21.2'
+  s.add_development_dependency  'minitest',             '5.22.2'
   s.add_development_dependency  'simplecov',            '0.17.1'
   s.add_development_dependency  'yard',                 '0.9.34'
   s.add_development_dependency  'sequel',               '5.77.0'

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.7'
+  VERSION = '2.8'
 end

data/lib/extralite.rb

@@ -1,8 +1,163 @@
 require_relative './extralite_ext'
-require_relative './extralite/sqlite3_constants'
 
 # Extralite is a Ruby gem for working with SQLite databases
 module Extralite
+  SQLITE_STATUS_MEMORY_USED           =  0
+  SQLITE_STATUS_PAGECACHE_USED        =  1
+  SQLITE_STATUS_PAGECACHE_OVERFLOW    =  2
+  SQLITE_STATUS_SCRATCH_USED          =  3
+  SQLITE_STATUS_SCRATCH_OVERFLOW      =  4
+  SQLITE_STATUS_MALLOC_SIZE           =  5
+  SQLITE_STATUS_PARSER_STACK          =  6
+  SQLITE_STATUS_PAGECACHE_SIZE        =  7
+  SQLITE_STATUS_SCRATCH_SIZE          =  8
+  SQLITE_STATUS_MALLOC_COUNT          =  9
+
+  SQLITE_DBSTATUS_LOOKASIDE_USED      =  0
+  SQLITE_DBSTATUS_CACHE_USED          =  1
+  SQLITE_DBSTATUS_SCHEMA_USED         =  2
+  SQLITE_DBSTATUS_STMT_USED           =  3
+  SQLITE_DBSTATUS_LOOKASIDE_HIT       =  4
+  SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE =  5
+  SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL =  6
+  SQLITE_DBSTATUS_CACHE_HIT           =  7
+  SQLITE_DBSTATUS_CACHE_MISS          =  8
+  SQLITE_DBSTATUS_CACHE_WRITE         =  9
+  SQLITE_DBSTATUS_DEFERRED_FKS        = 10
+  SQLITE_DBSTATUS_CACHE_USED_SHARED   = 11
+  SQLITE_DBSTATUS_CACHE_SPILL         = 12
+
+  SQLITE_STMTSTATUS_FULLSCAN_STEP     =  1
+  SQLITE_STMTSTATUS_SORT              =  2
+  SQLITE_STMTSTATUS_AUTOINDEX         =  3
+  SQLITE_STMTSTATUS_VM_STEP           =  4
+  SQLITE_STMTSTATUS_REPREPARE         =  5
+  SQLITE_STMTSTATUS_RUN               =  6
+  SQLITE_STMTSTATUS_FILTER_MISS       =  7
+  SQLITE_STMTSTATUS_FILTER_HIT        =  8
+  SQLITE_STMTSTATUS_MEMUSED           = 99
+
+  SQLITE_LIMIT_LENGTH                 =  0
+  SQLITE_LIMIT_SQL_LENGTH             =  1
+  SQLITE_LIMIT_COLUMN                 =  2
+  SQLITE_LIMIT_EXPR_DEPTH             =  3
+  SQLITE_LIMIT_COMPOUND_SELECT        =  4
+  SQLITE_LIMIT_VDBE_OP                =  5
+  SQLITE_LIMIT_FUNCTION_ARG           =  6
+  SQLITE_LIMIT_ATTACHED               =  7
+  SQLITE_LIMIT_LIKE_PATTERN_LENGTH    =  8
+  SQLITE_LIMIT_VARIABLE_NUMBER        =  9
+  SQLITE_LIMIT_TRIGGER_DEPTH          = 10
+  SQLITE_LIMIT_WORKER_THREADS         = 11
+
+  SQLITE_OK                           =   0
+  SQLITE_ERROR                        =   1
+  SQLITE_INTERNAL                     =   2
+  SQLITE_PERM                         =   3
+  SQLITE_ABORT                        =   4
+  SQLITE_BUSY                         =   5
+  SQLITE_LOCKED                       =   6
+  SQLITE_NOMEM                        =   7
+  SQLITE_READONLY                     =   8
+  SQLITE_INTERRUPT                    =   9
+  SQLITE_IOERR                        =  10
+  SQLITE_CORRUPT                      =  11
+  SQLITE_NOTFOUND                     =  12
+  SQLITE_FULL                         =  13
+  SQLITE_CANTOPEN                     =  14
+  SQLITE_PROTOCOL                     =  15
+  SQLITE_EMPTY                        =  16
+  SQLITE_SCHEMA                       =  17
+  SQLITE_TOOBIG                       =  18
+  SQLITE_CONSTRAINT                   =  19
+  SQLITE_MISMATCH                     =  20
+  SQLITE_MISUSE                       =  21
+  SQLITE_NOLFS                        =  22
+  SQLITE_AUTH                         =  23
+  SQLITE_FORMAT                       =  24
+  SQLITE_RANGE                        =  25
+  SQLITE_NOTADB                       =  26
+  SQLITE_NOTICE                       =  27
+  SQLITE_WARNING                      =  28
+  SQLITE_ROW                          = 100
+  SQLITE_DONE                         = 101
+
+  SQLITE_ERROR_MISSING_COLLSEQ        = (SQLITE_ERROR | (1<<8))
+  SQLITE_ERROR_RETRY                  = (SQLITE_ERROR | (2<<8))
+  SQLITE_ERROR_SNAPSHOT               = (SQLITE_ERROR | (3<<8))
+  SQLITE_IOERR_READ                   = (SQLITE_IOERR | (1<<8))
+  SQLITE_IOERR_SHORT_READ             = (SQLITE_IOERR | (2<<8))
+  SQLITE_IOERR_WRITE                  = (SQLITE_IOERR | (3<<8))
+  SQLITE_IOERR_FSYNC                  = (SQLITE_IOERR | (4<<8))
+  SQLITE_IOERR_DIR_FSYNC              = (SQLITE_IOERR | (5<<8))
+  SQLITE_IOERR_TRUNCATE               = (SQLITE_IOERR | (6<<8))
+  SQLITE_IOERR_FSTAT                  = (SQLITE_IOERR | (7<<8))
+  SQLITE_IOERR_UNLOCK                 = (SQLITE_IOERR | (8<<8))
+  SQLITE_IOERR_RDLOCK                 = (SQLITE_IOERR | (9<<8))
+  SQLITE_IOERR_DELETE                 = (SQLITE_IOERR | (10<<8))
+  SQLITE_IOERR_BLOCKED                = (SQLITE_IOERR | (11<<8))
+  SQLITE_IOERR_NOMEM                  = (SQLITE_IOERR | (12<<8))
+  SQLITE_IOERR_ACCESS                 = (SQLITE_IOERR | (13<<8))
+  SQLITE_IOERR_CHECKRESERVEDLOCK      = (SQLITE_IOERR | (14<<8))
+  SQLITE_IOERR_LOCK                   = (SQLITE_IOERR | (15<<8))
+  SQLITE_IOERR_CLOSE                  = (SQLITE_IOERR | (16<<8))
+  SQLITE_IOERR_DIR_CLOSE              = (SQLITE_IOERR | (17<<8))
+  SQLITE_IOERR_SHMOPEN                = (SQLITE_IOERR | (18<<8))
+  SQLITE_IOERR_SHMSIZE                = (SQLITE_IOERR | (19<<8))
+  SQLITE_IOERR_SHMLOCK                = (SQLITE_IOERR | (20<<8))
+  SQLITE_IOERR_SHMMAP                 = (SQLITE_IOERR | (21<<8))
+  SQLITE_IOERR_SEEK                   = (SQLITE_IOERR | (22<<8))
+  SQLITE_IOERR_DELETE_NOENT           = (SQLITE_IOERR | (23<<8))
+  SQLITE_IOERR_MMAP                   = (SQLITE_IOERR | (24<<8))
+  SQLITE_IOERR_GETTEMPPATH            = (SQLITE_IOERR | (25<<8))
+  SQLITE_IOERR_CONVPATH               = (SQLITE_IOERR | (26<<8))
+  SQLITE_IOERR_VNODE                  = (SQLITE_IOERR | (27<<8))
+  SQLITE_IOERR_AUTH                   = (SQLITE_IOERR | (28<<8))
+  SQLITE_IOERR_BEGIN_ATOMIC           = (SQLITE_IOERR | (29<<8))
+  SQLITE_IOERR_COMMIT_ATOMIC          = (SQLITE_IOERR | (30<<8))
+  SQLITE_IOERR_ROLLBACK_ATOMIC        = (SQLITE_IOERR | (31<<8))
+  SQLITE_IOERR_DATA                   = (SQLITE_IOERR | (32<<8))
+  SQLITE_IOERR_CORRUPTFS              = (SQLITE_IOERR | (33<<8))
+  SQLITE_LOCKED_SHAREDCACHE           = (SQLITE_LOCKED |  (1<<8))
+  SQLITE_LOCKED_VTAB                  = (SQLITE_LOCKED |  (2<<8))
+  SQLITE_BUSY_RECOVERY                = (SQLITE_BUSY   |  (1<<8))
+  SQLITE_BUSY_SNAPSHOT                = (SQLITE_BUSY   |  (2<<8))
+  SQLITE_BUSY_TIMEOUT                 = (SQLITE_BUSY   |  (3<<8))
+  SQLITE_CANTOPEN_NOTEMPDIR           = (SQLITE_CANTOPEN | (1<<8))
+  SQLITE_CANTOPEN_ISDIR               = (SQLITE_CANTOPEN | (2<<8))
+  SQLITE_CANTOPEN_FULLPATH            = (SQLITE_CANTOPEN | (3<<8))
+  SQLITE_CANTOPEN_CONVPATH            = (SQLITE_CANTOPEN | (4<<8))
+  SQLITE_CANTOPEN_DIRTYWAL            = (SQLITE_CANTOPEN | (5<<8))
+  SQLITE_CANTOPEN_SYMLINK             = (SQLITE_CANTOPEN | (6<<8))
+  SQLITE_CORRUPT_VTAB                 = (SQLITE_CORRUPT | (1<<8))
+  SQLITE_CORRUPT_SEQUENCE             = (SQLITE_CORRUPT | (2<<8))
+  SQLITE_CORRUPT_INDEX                = (SQLITE_CORRUPT | (3<<8))
+  SQLITE_READONLY_RECOVERY            = (SQLITE_READONLY | (1<<8))
+  SQLITE_READONLY_CANTLOCK            = (SQLITE_READONLY | (2<<8))
+  SQLITE_READONLY_ROLLBACK            = (SQLITE_READONLY | (3<<8))
+  SQLITE_READONLY_DBMOVED             = (SQLITE_READONLY | (4<<8))
+  SQLITE_READONLY_CANTINIT            = (SQLITE_READONLY | (5<<8))
+  SQLITE_READONLY_DIRECTORY           = (SQLITE_READONLY | (6<<8))
+  SQLITE_ABORT_ROLLBACK               = (SQLITE_ABORT | (2<<8))
+  SQLITE_CONSTRAINT_CHECK             = (SQLITE_CONSTRAINT | (1<<8))
+  SQLITE_CONSTRAINT_COMMITHOOK        = (SQLITE_CONSTRAINT | (2<<8))
+  SQLITE_CONSTRAINT_FOREIGNKEY        = (SQLITE_CONSTRAINT | (3<<8))
+  SQLITE_CONSTRAINT_FUNCTION          = (SQLITE_CONSTRAINT | (4<<8))
+  SQLITE_CONSTRAINT_NOTNULL           = (SQLITE_CONSTRAINT | (5<<8))
+  SQLITE_CONSTRAINT_PRIMARYKEY        = (SQLITE_CONSTRAINT | (6<<8))
+  SQLITE_CONSTRAINT_TRIGGER           = (SQLITE_CONSTRAINT | (7<<8))
+  SQLITE_CONSTRAINT_UNIQUE            = (SQLITE_CONSTRAINT | (8<<8))
+  SQLITE_CONSTRAINT_VTAB              = (SQLITE_CONSTRAINT | (9<<8))
+  SQLITE_CONSTRAINT_ROWID             = (SQLITE_CONSTRAINT |(10<<8))
+  SQLITE_CONSTRAINT_PINNED            = (SQLITE_CONSTRAINT |(11<<8))
+  SQLITE_CONSTRAINT_DATATYPE          = (SQLITE_CONSTRAINT |(12<<8))
+  SQLITE_NOTICE_RECOVER_WAL           = (SQLITE_NOTICE | (1<<8))
+  SQLITE_NOTICE_RECOVER_ROLLBACK      = (SQLITE_NOTICE | (2<<8))
+  SQLITE_WARNING_AUTOINDEX            = (SQLITE_WARNING | (1<<8))
+  SQLITE_AUTH_USER                    = (SQLITE_AUTH | (1<<8))
+  SQLITE_OK_LOAD_PERMANENTLY          = (SQLITE_OK | (1<<8))
+  SQLITE_OK_SYMLINK                   = (SQLITE_OK | (2<<8))
+
 
   # The following error classes are already defined in the C extension. We put
   # them here for the sake of generating docs.
@@ -29,7 +184,6 @@ module Extralite
   class ParameterError < Error
   end
 
-  # This class encapsulates an SQLite database connection.
   class Database
     # @!visibility private
     TABLES_SQL = (<<~SQL).freeze
@@ -46,7 +200,7 @@ module Extralite
     # @param db [String] name of attached database
     # @return [Array] list of tables
     def tables(db = 'main')
-      query_argv(format(TABLES_SQL, db: db))
+      query_splat(format(TABLES_SQL, db: db))
     end
 
     # Gets or sets one or more database pragmas. For a list of available pragmas
@@ -150,7 +304,7 @@ module Extralite
     end
 
     def pragma_get(key)
-      query_single_argv("pragma #{key}")
+      query_single_splat("pragma #{key}")
     end
   end
 

data/test/{perf_ary.rb → perf_array.rb}

@@ -33,7 +33,7 @@ def sqlite3_run(count)
 end
 
 def extralite_run(count)
-  results = $extralite_db.query('select * from foo')
+  results = $extralite_db.query_array('select * from foo')
   raise unless results.size == count
 end
 

data/test/perf_splat.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'sqlite3'
+  gem 'extralite', path: '..'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'fileutils'
+
+DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
+puts "DB_PATH = #{DB_PATH.inspect}"
+
+$sqlite3_db = SQLite3::Database.new(DB_PATH)
+$extralite_db = Extralite::Database.new(DB_PATH, gvl_release_threshold: -1)
+
+def prepare_database(count)
+  db = Extralite::Database.new(DB_PATH)
+  $extralite_db.query('create table if not exists foo ( a integer primary key, b text )')
+  $extralite_db.query('delete from foo')
+  $extralite_db.query('begin')
+  count.times { $extralite_db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
+  $extralite_db.query('commit')
+end
+
+def sqlite3_run(expected_count)
+  count = 0
+  $sqlite3_db.execute('select b from foo').each do |row|
+    b = row.first
+    count += 1
+  end
+  raise unless count == expected_count
+end
+
+def extralite_run(expected_count)
+  count = 0
+  $extralite_db.query_splat('select * from foo') do |b|
+    count += 1
+  end
+  raise unless count == expected_count
+end
+
+[10, 1000, 100000].each do |c|
+  puts; puts; puts "Record count: #{c}"
+
+  prepare_database(c)
+
+  bm = Benchmark.ips do |x|
+    x.config(:time => 5, :warmup => 2)
+
+    x.report("sqlite3") { sqlite3_run(c) }
+    x.report("extralite") { extralite_run(c) }
+
+    x.compare!
+  end
+  puts;
+  bm.entries.each { |e| puts "#{e.label}: #{(e.ips * c).round.to_i} rows/s" }
+  puts;
+end

data/test/{perf_argv_transform.rb → perf_splat_transform.rb}

@@ -38,20 +38,20 @@ end
 
 TRANSFORM = ->(b) { { b: b } }
 
-def extralite_run_ary_map(count)
+def extralite_run_array_map(count)
   results = []
-  $extralite_db.query_ary('select * from foo') { |(b)| results << { b: b } }
+  $extralite_db.query_array('select * from foo') { |(b)| results << { b: b } }
   raise unless results.size == count
 end
 
-def extralite_run_argv_map(count)
+def extralite_run_splat_map(count)
   results = []
-  $extralite_db.query_argv('select * from foo') { |b| results << { b: b } }
+  $extralite_db.query_splat('select * from foo') { |b| results << { b: b } }
   raise unless results.size == count
 end
 
 def extralite_run_transform(count)
-  results = $extralite_db.query_argv(TRANSFORM, 'select * from foo')
+  results = $extralite_db.query_splat(TRANSFORM, 'select * from foo')
   raise unless results.size == count
 end
 
@@ -62,8 +62,8 @@ end
   bm = Benchmark.ips do |x|
     x.config(:time => 5, :warmup => 2)
 
-    x.report("ary_map")   { extralite_run_ary_map(c) }
-    x.report("argv_map")  { extralite_run_argv_map(c) }
+    x.report("array_map")   { extralite_run_array_map(c) }
+    x.report("splat_map")  { extralite_run_splat_map(c) }
     x.report("transform") { extralite_run_transform(c) }
 
     x.compare!