extralite 2.7.1 → 2.8

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.
@@ -45,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
@@ -149,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!