extralite 2.3 → 2.4

data/test/issue-38.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "./lib/extralite"
+require "benchmark"
+
+# Setup
+
+File.delete("benchmark.sqlite3") if File.exist?("benchmark.sqlite3")
+
+POOL_SIZE = 10
+
+EXTRALITE_CONNECTIONS = POOL_SIZE.times.map do
+  db = Extralite::Database.new("benchmark.sqlite3")
+  db.execute("PRAGMA journal_mode = WAL")
+  db.execute("PRAGMA synchronous = NORMAL")
+  db.execute("PRAGMA journal_size_limit = 64000000")
+  db.execute("PRAGMA mmap_size = 128000000")
+  db.execute("PRAGMA cache_size = 2000")
+  db.execute("PRAGMA busy_timeout = 5000")
+  db
+end
+
+SQLITE3_CONNECTIONS = POOL_SIZE.times.map do
+  db = SQLite3::Database.new("benchmark.sqlite3")
+  db.execute("PRAGMA journal_mode = WAL")
+  db.execute("PRAGMA synchronous = NORMAL")
+  db.execute("PRAGMA journal_size_limit = 64000000")
+  db.execute("PRAGMA mmap_size = 128000000")
+  db.execute("PRAGMA cache_size = 2000")
+  db.execute("PRAGMA busy_timeout = 5000")
+  db
+end
+
+EXTRALITE_CONNECTIONS[0].execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, created_at TEXT, updated_at TEXT) STRICT")
+insert_statement = EXTRALITE_CONNECTIONS[0].prepare("INSERT INTO users (name, created_at, updated_at) VALUES (?, ?, ?)")
+1000.times do
+  insert_statement.execute("John Doe", Time.now.iso8601, Time.now.iso8601)
+end
+
+# Benchmark variations
+
+THREAD_COUNTS = [1, 2, 4, 8]
+LIMITS = [10, 100, 1000]
+CLIENTS = %w[extralite sqlite3]
+
+# Benchmark
+
+GC.disable
+Benchmark.bm do |x|
+  LIMITS.each do |limit|
+    THREAD_COUNTS.each do |thread_count|
+      CLIENTS.each do |client|
+        GC.start
+
+        x.report("#{client.rjust('extralite'.length)} - limit: #{limit}, threads: #{thread_count}") do
+          threads = thread_count.times.map do |thread_number|
+            Thread.new do
+              start = Time.now
+              if client == "extralite"
+                1_000.times do
+                  records = EXTRALITE_CONNECTIONS[thread_number].query_ary("SELECT * FROM users LIMIT #{limit}")
+                  raise "Expected #{limit} but got #{length}" unless records.length == limit
+                end
+              else
+                1_000.times do
+                  records = SQLITE3_CONNECTIONS[thread_number].query("SELECT * FROM users LIMIT #{limit}").entries
+                  raise "Expected #{limit} but got #{length}" unless records.length == limit
+                end
+              end
+            end
+          end
+          threads.each(&:join)
+        end
+      end
+      puts
+    end
+  end
+end
+GC.enable

data/test/perf_ary.rb

@@ -12,15 +12,18 @@ end
 require 'benchmark/ips'
 require 'fileutils'
 
-DB_PATH = '/tmp/extralite_sqlite3_perf.db'
+DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
+puts "DB_PATH = #{DB_PATH.inspect}"
+
 
 def prepare_database(count)
-  FileUtils.rm(DB_PATH) rescue nil
   db = Extralite::Database.new(DB_PATH)
-  db.query('create table foo ( a integer primary key, b text )')
+  db.query('create table if not exists foo ( a integer primary key, b text )')
+  db.query('delete from foo')
   db.query('begin')
   count.times { db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
   db.query('commit')
+  db.close
 end
 
 def sqlite3_run(count)

data/test/perf_hash.rb

@@ -12,15 +12,17 @@ end
 require 'benchmark/ips'
 require 'fileutils'
 
-DB_PATH = '/tmp/extralite_sqlite3_perf.db'
+DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
+puts "DB_PATH = #{DB_PATH.inspect}"
 
 def prepare_database(count)
-  FileUtils.rm(DB_PATH) rescue nil
   db = Extralite::Database.new(DB_PATH)
-  db.query('create table foo ( a integer primary key, b text )')
+  db.query('create table if not exists foo ( a integer primary key, b text )')
+  db.query('delete from foo')
   db.query('begin')
   count.times { db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
   db.query('commit')
+  db.close
 end
 
 def sqlite3_run(count)
@@ -36,7 +38,7 @@ def extralite_run(count)
 end
 
 [10, 1000, 100000].each do |c|
-  puts; puts; puts "Record count: #{c}"
+  puts "Record count: #{c}"
 
   prepare_database(c)
 
@@ -48,4 +50,5 @@ end
 
     x.compare!
   end
+  puts; puts; 
 end

data/test/test_database.rb

@@ -2,6 +2,9 @@
 
 require_relative 'helper'
 
+require 'date'
+require 'tempfile'
+
 class DatabaseTest < MiniTest::Test
   def setup
     @db = Extralite::Database.new(':memory:')
@@ -123,6 +126,9 @@ end
 
     r = @db.query('select x, y, z from t where z = ?', 6)
     assert_equal [{ x: 4, y: 5, z: 6 }], r
+
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', Date.today) }
+    assert_equal error.message, 'Cannot bind parameter at position 1 of type Date'
   end
 
   def test_parameter_binding_with_index
@@ -152,6 +158,94 @@ end
     assert_equal [{ x: 4, y: 5, z: 6 }], r
   end
 
+  class Foo; end
+
+  def test_parameter_binding_from_hash
+    assert_equal 42, @db.query_single_value('select :bar', foo: 41, bar: 42)
+    assert_equal 42, @db.query_single_value('select :bar', 'foo' => 41, 'bar' => 42)
+    assert_equal 42, @db.query_single_value('select ?8', 7 => 41, 8 => 42)
+    assert_nil @db.query_single_value('select :bar', foo: 41)
+
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', Foo.new => 42) }
+    assert_equal error.message, 'Cannot bind parameter with a key of type DatabaseTest::Foo'
+
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', %w[a b] => 42) }
+    assert_equal error.message, 'Cannot bind parameter with a key of type Array'
+  end
+
+  def test_parameter_binding_from_struct
+    foo_bar = Struct.new(:":foo", :bar)
+    value = foo_bar.new(41, 42)
+    assert_equal 41, @db.query_single_value('select :foo', value)
+    assert_equal 42, @db.query_single_value('select :bar', value)
+    assert_nil @db.query_single_value('select :baz', value)
+  end
+
+  def test_parameter_binding_from_data_class
+    skip "Data isn't supported in Ruby < 3.2" if RUBY_VERSION < '3.2'
+
+    foo_bar = Data.define(:":foo", :bar)
+    value = foo_bar.new(":foo": 41, bar: 42)
+    assert_equal 42, @db.query_single_value('select :bar', value)
+    assert_nil @db.query_single_value('select :baz', value)
+  end
+
+  def test_parameter_binding_for_blobs
+    sql = 'SELECT typeof(data) AS type, data FROM blobs WHERE ROWID = ?'
+    blob_path = File.expand_path('fixtures/image.png', __dir__)
+    @db.execute('CREATE TABLE blobs (data BLOB)')
+
+    # it's a string, not a blob
+    @db.execute('INSERT INTO blobs VALUES (?)', 'Hello, 世界!')
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'text', result[:type]
+    assert_equal Encoding::UTF_8, result[:data].encoding
+
+    data = File.binread(blob_path)
+    @db.execute('INSERT INTO blobs VALUES (?)', data)
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'blob', result[:type]
+    assert_equal data, result[:data]
+
+    data = (+'Hello, 世界!').force_encoding(Encoding::ASCII_8BIT)
+    @db.execute('INSERT INTO blobs VALUES (?)', data)
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'blob', result[:type]
+    assert_equal Encoding::ASCII_8BIT, result[:data].encoding
+    assert_equal 'Hello, 世界!', result[:data].force_encoding(Encoding::UTF_8)
+
+    data = Extralite::Blob.new('Hello, 世界!')
+    @db.execute('INSERT INTO blobs VALUES (?)', data)
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'blob', result[:type]
+    assert_equal Encoding::ASCII_8BIT, result[:data].encoding
+    assert_equal 'Hello, 世界!', result[:data].force_encoding(Encoding::UTF_8)
+  end
+
+  def test_parameter_binding_for_simple_types
+    assert_nil @db.query_single_value('select ?', nil)
+
+    # 32-bit integers
+    assert_equal -2** 31, @db.query_single_value('select ?', -2**31)
+    assert_equal 2**31 - 1, @db.query_single_value('select ?', 2**31 - 1)
+
+    # 64-bit integers
+    assert_equal -2 ** 63, @db.query_single_value('select ?', -2 ** 63)
+    assert_equal 2**63 - 1, @db.query_single_value('select ?', 2**63 - 1)
+
+    # floats
+    assert_equal Float::MIN, @db.query_single_value('select ?', Float::MIN)
+    assert_equal Float::MAX, @db.query_single_value('select ?', Float::MAX)
+
+    # boolean
+    assert_equal 1, @db.query_single_value('select ?', true)
+    assert_equal 0, @db.query_single_value('select ?', false)
+
+    # strings and symbols
+    assert_equal 'foo', @db.query_single_value('select ?', 'foo')
+    assert_equal 'foo', @db.query_single_value('select ?', :foo)
+  end
+
   def test_value_casting
     r = @db.query_single_value("select 'abc'")
     assert_equal 'abc', r
@@ -293,7 +387,7 @@ end
   end
 
   def test_database_busy_timeout
-    fn = "/tmp/extralite-#{rand(10000)}.db"
+    fn = Tempfile.new('extralite_test_database_busy_timeout').path
     db1 = Extralite::Database.new(fn)
     db2 = Extralite::Database.new(fn)
 
@@ -388,17 +482,77 @@ end
     assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect
   end
 
+  def test_database_inspect_on_closed_database
+    db = Extralite::Database.new(':memory:')
+    assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect
+    db.close
+    assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ \(closed\)\>$/, db.inspect
+  end
+
   def test_string_encoding
     db = Extralite::Database.new(':memory:')
     v = db.query_single_value("select 'foo'")
     assert_equal 'foo', v
     assert_equal 'UTF-8', v.encoding.name
   end
+
+  def test_database_transaction_commit
+    path = Tempfile.new('extralite_test_database_transaction_commit').path
+    db1 = Extralite::Database.new(path)
+    db2 = Extralite::Database.new(path)
+
+    db1.execute('create table foo(x)')
+    assert_equal ['foo'], db1.tables
+    assert_equal ['foo'], db2.tables
+
+    q1 = Queue.new
+    q2 = Queue.new
+    th = Thread.new do
+      db1.transaction do
+        assert_equal true, db1.transaction_active?
+        db1.execute('insert into foo values (42)')
+        q1 << true
+        q2.pop
+      end
+      assert_equal false, db1.transaction_active?
+    end
+    q1.pop
+    # transaction not yet committed
+    assert_equal false, db2.transaction_active?
+    assert_equal [], db2.query('select * from foo')
+
+    q2 << true
+    th.join
+    # transaction now committed
+    assert_equal [{ x: 42 }], db2.query('select * from foo')
+  end
+
+  def test_database_transaction_rollback
+    db = Extralite::Database.new(':memory:')
+    db.execute('create table foo(x)')
+
+    assert_equal [], db.query('select * from foo')
+
+    exception = nil
+    begin
+      db.transaction do
+        db.execute('insert into foo values (42)')
+        raise 'bar'
+      end
+    rescue => e
+      exception = e
+    end
+
+    assert_equal [], db.query('select * from foo')
+    assert_kind_of RuntimeError, exception
+    assert_equal 'bar', exception.message
+  end
 end
 
 class ScenarioTest < MiniTest::Test
   def setup
-    @db = Extralite::Database.new('/tmp/extralite.db')
+    @fn = Tempfile.new('extralite_scenario_test').path
+    @db = Extralite::Database.new(@fn)
     @db.query('create table if not exists t (x,y,z)')
     @db.query('delete from t')
     @db.query('insert into t values (1, 2, 3)')
@@ -408,7 +562,7 @@ class ScenarioTest < MiniTest::Test
   def test_concurrent_transactions
     done = false
     t = Thread.new do
-      db = Extralite::Database.new('/tmp/extralite.db')
+      db = Extralite::Database.new(@fn)
       db.query 'begin immediate'
       sleep 0.01 until done
 
@@ -465,6 +619,7 @@ class ScenarioTest < MiniTest::Test
   def test_database_trace
     sqls = []
     @db.trace { |sql| sqls << sql }
+    GC.start
 
     @db.query('select 1')
     assert_equal ['select 1'], sqls
@@ -515,10 +670,107 @@ class BackupTest < MiniTest::Test
   end
 
   def test_backup_with_fn
-    tmp_fn = "/tmp/#{rand(86400)}.db"
+    tmp_fn = Tempfile.new('extralite_test_backup_with_fn').path
     @src.backup(tmp_fn)
 
     db = Extralite::Database.new(tmp_fn)
     assert_equal [[1, 2, 3], [4, 5, 6]], db.query_ary('select * from t')
   end
 end
+
+class GVLReleaseThresholdTest < Minitest::Test
+  def setup
+    @sql = <<~SQL
+      WITH RECURSIVE r(i) AS (
+        VALUES(0)
+        UNION ALL
+        SELECT i FROM r
+        LIMIT 3000000
+      )
+      SELECT i FROM r WHERE i = 1;
+    SQL
+  end
+
+  def test_default_gvl_release_threshold
+    db = Extralite::Database.new(':memory:')
+    assert_equal 1000, db.gvl_release_threshold
+  end
+
+  def test_gvl_always_release
+    skip if !IS_LINUX
+
+    delays = []
+    running = true
+    t1 = Thread.new do
+      last = Time.now
+      while running
+        sleep 0.1
+        now = Time.now
+        delays << (now - last)
+        last = now
+      end
+    end
+    t2 = Thread.new do
+      db = Extralite::Database.new(':memory:')
+      db.gvl_release_threshold = 1
+      db.query(@sql)
+    ensure
+      running = false
+    end
+    t2.join
+    t1.join
+
+    assert delays.size > 4
+    assert_equal 0, delays.select { |d| d > 0.15 }.size
+  end
+
+  def test_gvl_always_hold
+    skip if !IS_LINUX
+
+    delays = []
+    running = true
+
+    signal = Queue.new
+    db = Extralite::Database.new(':memory:')
+    db.gvl_release_threshold = 0
+
+    t1 = Thread.new do
+      last = Time.now
+      while running
+        signal << true
+        sleep 0.1
+        now = Time.now
+        delays << (now - last)
+        last = now
+      end
+    end
+
+    t2 = Thread.new do
+      signal.pop
+      db.query(@sql)
+    ensure
+      running = false
+    end
+    t2.join
+    t1.join
+
+    assert delays.size >= 1
+    assert delays.first > 0.2
+  end
+
+  def test_gvl_mode_get_set
+    db = Extralite::Database.new(':memory:')
+    assert_equal 1000, db.gvl_release_threshold
+
+    db.gvl_release_threshold = 42
+    assert_equal 42, db.gvl_release_threshold
+
+    db.gvl_release_threshold = 0
+    assert_equal 0, db.gvl_release_threshold
+
+    assert_raises(ArgumentError) { db.gvl_release_threshold = :foo }
+
+    db.gvl_release_threshold = nil
+    assert_equal 1000, db.gvl_release_threshold
+  end
+end

data/test/test_iterator.rb

@@ -103,7 +103,8 @@ class IteratorTest < MiniTest::Test
   end
 
   def test_return_from_block_issue_26
-    db = Extralite::Database.new('/tmp/locked.db')
+    fn = Tempfile.new('extralite_test_return_from_block_issue_26').path
+    db = Extralite::Database.new(fn)
 
     λ = ->(sql) {
       db.prepare(sql).each { |r| r.each { |_, v| return v } }

data/test/test_query.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
+require 'date'
 
 class QueryTest < MiniTest::Test
   def setup
@@ -267,7 +268,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_each_without_block
-    query = @db.prepare('select * from t') 
+    query = @db.prepare('select * from t')
     iter = query.each
     assert_kind_of Extralite::Iterator, iter
 
@@ -294,7 +295,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_each_ary_without_block
-    query = @db.prepare('select * from t') 
+    query = @db.prepare('select * from t')
     iter = query.each_ary
     assert_kind_of Extralite::Iterator, iter
 
@@ -322,7 +323,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_each_single_column_without_block
-    query = @db.prepare('select x from t') 
+    query = @db.prepare('select x from t')
     iter = query.each_single_column
     assert_kind_of Extralite::Iterator, iter
 
@@ -375,6 +376,9 @@ class QueryTest < MiniTest::Test
   def test_query_parameter_binding_simple
     r = @db.prepare('select x, y, z from t where x = ?').bind(1).next
     assert_equal({ x: 1, y: 2, z: 3 }, r)
+
+    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(Date.today).next }
+    assert_equal error.message, 'Cannot bind parameter at position 1 of type Date'
   end
 
   def test_query_parameter_binding_with_index
@@ -404,6 +408,38 @@ class QueryTest < MiniTest::Test
     assert_equal({ x: 4, y: 5, z: 6 }, r)
   end
 
+  class Foo; end
+
+  def test_parameter_binding_from_hash
+    assert_equal 42, @db.prepare('select :bar').bind(foo: 41, bar: 42).next_single_column
+    assert_equal 42, @db.prepare('select :bar').bind('foo' => 41, 'bar' => 42).next_single_column
+    assert_equal 42, @db.prepare('select ?8').bind(7 => 41, 8 => 42).next_single_column
+    assert_nil @db.prepare('select :bar').bind(foo: 41).next_single_column
+
+    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(Foo.new => 42).next_single_column }
+    assert_equal error.message, 'Cannot bind parameter with a key of type QueryTest::Foo'
+
+    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(%w[a b] => 42).next_single_column }
+    assert_equal error.message, 'Cannot bind parameter with a key of type Array'
+  end
+
+  def test_parameter_binding_from_struct
+    foo_bar = Struct.new(:":foo", :bar)
+    value = foo_bar.new(41, 42)
+    assert_equal 41, @db.prepare('select :foo').bind(value).next_single_column
+    assert_equal 42, @db.prepare('select :bar').bind(value).next_single_column
+    assert_nil @db.prepare('select :baz').bind(value).next_single_column
+  end
+
+  def test_parameter_binding_from_data_class
+    skip "Data isn't supported in Ruby < 3.2" if RUBY_VERSION < '3.2'
+
+    foo_bar = Data.define(:":foo", :bar)
+    value = foo_bar.new(":foo": 41, bar: 42)
+    assert_equal 42, @db.prepare('select :bar').bind(value).next_single_column
+    assert_nil @db.prepare('select :baz').bind(value).next_single_column
+  end
+
   def test_query_columns
     r = @db.prepare("select 'abc' as a, 'def' as b").columns
     assert_equal [:a, :b], r
@@ -459,7 +495,7 @@ class QueryTest < MiniTest::Test
       { a: 1, b: '2', c: 3 },
       { a: '4', b: 5, c: 6 }
     ], @db.query('select * from foo')
-  end  
+  end
 
   def test_query_status
     assert_equal 0, @query.status(Extralite::SQLITE_STMTSTATUS_RUN)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '2.3'
+  version: '2.4'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-12 00:00:00.000000000 Z
+date: 2023-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -88,12 +88,14 @@ extensions:
 extra_rdoc_files:
 - README.md
 files:
+- ".editorconfig"
 - ".github/FUNDING.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
+- Gemfile-bundle
 - Gemfile.lock
 - LICENSE
 - README.md
@@ -118,7 +120,9 @@ files:
 - lib/sequel/adapters/extralite.rb
 - test/extensions/text.dylib
 - test/extensions/text.so
+- test/fixtures/image.png
 - test/helper.rb
+- test/issue-38.rb
 - test/perf_ary.rb
 - test/perf_hash.rb
 - test/perf_prepared.rb