extralite 2.3 → 2.5

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:')
@@ -58,7 +61,7 @@ class DatabaseTest < MiniTest::Test
 
     r = @db.query_single_column('select y from t where x = 2')
     assert_equal [], r
-end
+  end
 
   def test_query_single_value
     r = @db.query_single_value('select z from t order by Z desc limit 1')
@@ -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
@@ -194,16 +288,38 @@ end
     assert_equal [], @db.tables
   end
 
+  def test_tables_with_db_name
+    assert_equal ['t'], @db.tables('main')
+
+    @db.query('create table foo (bar text)')
+    assert_equal ['t', 'foo'], @db.tables('main')
+
+    @db.query('drop table t')
+    assert_equal ['foo'], @db.tables('main')
+
+    @db.query('drop table foo')
+    assert_equal [], @db.tables('main')
+
+    assert_raises { @db.tables('foo') }
+
+    fn = Tempfile.new('extralite_test_tables_with_db_name').path
+    @db.execute "attach database '#{fn}' as foo"
+
+    assert_equal [], @db.tables('foo')
+    @db.execute 'create table foo.bar (x, y)'
+    assert_equal ['bar'], @db.tables('foo')
+  end
+
   def test_pragma
-    assert_equal [{journal_mode: 'memory'}], @db.pragma('journal_mode')
-    assert_equal [{synchronous: 2}], @db.pragma('synchronous')
+    assert_equal 'memory', @db.pragma('journal_mode')
+    assert_equal 2, @db.pragma('synchronous')
 
-    assert_equal [{schema_version: 1}], @db.pragma(:schema_version)
-    assert_equal [{recursive_triggers: 0}], @db.pragma(:recursive_triggers)
+    assert_equal 1, @db.pragma(:schema_version)
+    assert_equal 0, @db.pragma(:recursive_triggers)
 
     assert_equal [], @db.pragma(schema_version: 33, recursive_triggers: 1)
-    assert_equal [{schema_version: 33}], @db.pragma(:schema_version)
-    assert_equal [{recursive_triggers: 1}], @db.pragma(:recursive_triggers)
+    assert_equal 33, @db.pragma(:schema_version)
+    assert_equal 1, @db.pragma(:recursive_triggers)
   end
 
   def test_execute
@@ -217,7 +333,13 @@ end
     assert_equal [[1, 2, 3], [42, 5, 6]], @db.query_ary('select * from t order by x')
   end
 
-  def test_execute_multi
+  def test_execute_with_params_array
+    changes = @db.execute('update t set x = ? where z = ?', [42, 6])
+    assert_equal 1, changes
+    assert_equal [[1, 2, 3], [42, 5, 6]], @db.query_ary('select * from t order by x')
+  end
+
+  def test_batch_execute
     @db.query('create table foo (a, b, c)')
     assert_equal [], @db.query('select * from foo')
 
@@ -226,7 +348,7 @@ end
       ['4', 5, 6]
     ]
 
-    changes = @db.execute_multi('insert into foo values (?, ?, ?)', records)
+    changes = @db.batch_execute('insert into foo values (?, ?, ?)', records)
 
     assert_equal 2, changes
     assert_equal [
@@ -235,7 +357,7 @@ end
     ], @db.query('select * from foo')
   end
 
-  def test_execute_multi_single_values
+  def test_batch_execute_single_values
     @db.query('create table foo (bar)')
     assert_equal [], @db.query('select * from foo')
 
@@ -244,7 +366,7 @@ end
       'bye'
     ]
 
-    changes = @db.execute_multi('insert into foo values (?)', records)
+    changes = @db.batch_execute('insert into foo values (?)', records)
 
     assert_equal 2, changes
     assert_equal [
@@ -253,6 +375,314 @@ end
     ], @db.query('select * from foo')
   end
 
+  def test_batch_execute_with_each_interface
+    @db.query('create table foo (bar)')
+    assert_equal [], @db.query('select * from foo')
+
+    changes = @db.batch_execute('insert into foo values (?)', 1..3)
+
+    assert_equal 3, changes
+    assert_equal [
+      { bar: 1 },
+      { bar: 2 },
+      { bar: 3 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_batch_execute_with_proc
+    source = [42, 43, 44]
+
+    @db.query('create table foo (a)')
+    assert_equal [], @db.query('select * from foo')
+
+    pr = proc { source.shift }
+    changes = @db.batch_execute('insert into foo values (?)', pr)
+
+    assert_equal 3, changes
+    assert_equal [
+      { a: 42 },
+      { a: 43 },
+      { a: 44 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_batch_query_with_array
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+    results = @db.batch_query('insert into foo values (?, ?, ?) returning *', data)
+    assert_equal [
+      [{ a: 1, b: '2', c: 3 }],
+      [{ a: '4', b: 5, c: 6 }]
+    ], results
+
+    results = @db.batch_query('update foo set c = ? returning *', [42, 43])
+    assert_equal [
+      [{ a: 1, b: '2', c: 42 }, { a: '4', b: 5, c: 42 }],
+      [{ a: 1, b: '2', c: 43 }, { a: '4', b: 5, c: 43 }]
+    ], results
+
+    array = []
+    changes = @db.batch_query('update foo set c = ? returning *', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 4, changes
+    assert_equal [
+      [{ a: 1, b: '2', c: 44 }, { a: '4', b: 5, c: 44 }],
+      [{ a: 1, b: '2', c: 45 }, { a: '4', b: 5, c: 45 }]
+    ], array
+  end
+
+  def test_batch_query_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    results = @db.batch_query('insert into foo (b) values (?) returning *', 11..13)
+    assert_equal [
+      [{ a: 1, b: 11 }],
+      [{ a: 2, b: 12 }],
+      [{ a: 3, b: 13 }]
+    ], results
+
+    results = @db.batch_query('update foo set b = ? returning *', [42, 43])
+    assert_equal [
+      [{ a: 1, b: 42 }, { a: 2, b: 42 }, { a: 3, b: 42 }],
+      [{ a: 1, b: 43 }, { a: 2, b: 43 }, { a: 3, b: 43 }]
+    ], results
+
+    array = []
+    changes = @db.batch_query('update foo set b = ? returning *', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [{ a: 1, b: 44 }, { a: 2, b: 44 }, { a: 3, b: 44 }],
+      [{ a: 1, b: 45 }, { a: 2, b: 45 }, { a: 3, b: 45 }]
+    ], array
+  end
+
+  def parameter_source_proc(values)
+    proc { values.shift }
+  end
+
+  def test_batch_query_with_proc
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    pr = parameter_source_proc([5, 4, 3])
+    assert_kind_of Proc, pr
+    results = @db.batch_query('insert into foo (b) values (?) returning *', pr)
+    assert_equal [
+      [{ a: 1, b: 5 }],
+      [{ a: 2, b: 4 }],
+      [{ a: 3, b: 3 }]
+    ], results
+
+    pr = parameter_source_proc([42, 43])
+    results = @db.batch_query('update foo set b = ? returning *', pr)
+    assert_equal [
+      [{ a: 1, b: 42 }, { a: 2, b: 42 }, { a: 3, b: 42 }],
+      [{ a: 1, b: 43 }, { a: 2, b: 43 }, { a: 3, b: 43 }]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = @db.batch_query('update foo set b = ? returning *', pr) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [{ a: 1, b: 44 }, { a: 2, b: 44 }, { a: 3, b: 44 }],
+      [{ a: 1, b: 45 }, { a: 2, b: 45 }, { a: 3, b: 45 }]
+    ], array
+  end
+
+  def test_batch_query_ary_with_array
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+    results = @db.batch_query_ary('insert into foo values (?, ?, ?) returning *', data)
+    assert_equal [
+      [[1, '2', 3]],
+      [['4', 5, 6]]
+    ], results
+
+    results = @db.batch_query_ary('update foo set c = ? returning *', [42, 43])
+    assert_equal [
+      [[1, '2', 42], ['4', 5, 42]],
+      [[1, '2', 43], ['4', 5, 43]]
+    ], results
+
+    array = []
+    changes = @db.batch_query_ary('update foo set c = ? returning *', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 4, changes
+    assert_equal [
+      [[1, '2', 44], ['4', 5, 44]],
+      [[1, '2', 45], ['4', 5, 45]]
+    ], array
+  end
+
+  def test_batch_query_ary_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', 11..13)
+    assert_equal [
+      [[1, 11]],
+      [[2, 12]],
+      [[3, 13]]
+    ], results
+
+    results = @db.batch_query_ary('update foo set b = ? returning *', [42, 43])
+    assert_equal [
+      [[1, 42], [2, 42], [3, 42]],
+      [[1, 43], [2, 43], [3, 43]]
+    ], results
+
+    array = []
+    changes = @db.batch_query_ary('update foo set b = ? returning *', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [[1, 44], [2, 44], [3, 44]],
+      [[1, 45], [2, 45], [3, 45]]
+    ], array
+  end
+
+  def test_batch_query_ary_with_proc
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    pr = parameter_source_proc([5, 4, 3])
+    assert_kind_of Proc, pr
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', pr)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    pr = parameter_source_proc([42, 43])
+    results = @db.batch_query_ary('update foo set b = ? returning *', pr)
+    assert_equal [
+      [[1, 42], [2, 42], [3, 42]],
+      [[1, 43], [2, 43], [3, 43]]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = @db.batch_query_ary('update foo set b = ? returning *', pr) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [[1, 44], [2, 44], [3, 44]],
+      [[1, 45], [2, 45], [3, 45]]
+    ], array
+  end
+
+  def test_batch_query_single_column_with_array
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+    results = @db.batch_query_single_column('insert into foo values (?, ?, ?) returning c', data)
+    assert_equal [
+      [3],
+      [6]
+    ], results
+
+    results = @db.batch_query_single_column('update foo set c = ? returning c * 10 + cast(b as integer)', [42, 43])
+    assert_equal [
+      [422, 425],
+      [432, 435]
+    ], results
+
+    array = []
+    changes = @db.batch_query_single_column('update foo set c = ? returning c * 10 + cast(b as integer)', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 4, changes
+    assert_equal [
+      [442, 445],
+      [452, 455]
+    ], array
+  end
+
+  def test_batch_query_single_column_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    results = @db.batch_query_single_column('insert into foo (b) values (?) returning b * 10 + a', 11..13)
+    assert_equal [
+      [111],
+      [122],
+      [133]
+    ], results
+
+    results = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', 42..43)
+    assert_equal [
+      [421, 422, 423],
+      [431, 432, 433]
+    ], results
+
+    array = []
+    changes = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', 44..45) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
+
+  def test_batch_query_single_column_with_proc
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    pr = parameter_source_proc([5, 4, 3])
+    assert_kind_of Proc, pr
+    results = @db.batch_query_single_column('insert into foo (b) values (?) returning b', pr)
+    assert_equal [
+      [5],
+      [4],
+      [3]
+    ], results
+
+    pr = parameter_source_proc([42, 43])
+    results = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', pr)
+    assert_equal [
+      [421, 422, 423],
+      [431, 432, 433]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', pr) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
+
   def test_interrupt
     t = Thread.new do
       sleep 0.5
@@ -293,7 +723,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)
 
@@ -383,22 +813,95 @@ end
     assert_equal true, db.read_only?
   end
 
+  def test_database_initialize_options
+    db = Extralite::Database.new(':memory:', gvl_release_threshold: 23)
+    assert_equal 23, db.gvl_release_threshold
+
+    fn = Tempfile.new('extralite_test_database_initialize_options_1').path
+    db = Extralite::Database.new(fn, wal_journal_mode: true)
+    assert_equal 'wal', db.pragma(:journal_mode)
+
+    fn = Tempfile.new('extralite_test_database_initialize_options_2').path
+    db = Extralite::Database.new(fn, synchronous: true)
+    assert_equal 1, db.pragma(:synchronous)
+  end
+
   def test_database_inspect
     db = Extralite::Database.new(':memory:')
     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 +911,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
 
@@ -462,9 +965,36 @@ class ScenarioTest < MiniTest::Test
     assert_equal [1, 4, 7], result
   end
 
+  def test_concurrent_queries
+    @db.query('delete from t')
+    @db.gvl_release_threshold = 1
+    q1 = @db.prepare('insert into t values (?, ?, ?)')
+    q2 = @db.prepare('insert into t values (?, ?, ?)')
+
+    t1 = Thread.new do
+      data = (1..50).each_slice(10).map { |a| a.map { |i| [i, i + 1, i + 2] } }
+      data.each do |params|
+        q1.batch_execute(params)
+      end
+    end
+
+    t2 = Thread.new do
+      data = (51..100).each_slice(10).map { |a| a.map { |i| [i, i + 1, i + 2] } }
+      data.each do |params|
+        q2.batch_execute(params)
+      end
+    end
+
+    t1.join
+    t2.join
+
+    assert_equal (1..100).to_a, @db.query_single_column('select x from t order by x')
+  end
+
   def test_database_trace
     sqls = []
     @db.trace { |sql| sqls << sql }
+    GC.start
 
     @db.query('select 1')
     assert_equal ['select 1'], sqls
@@ -515,10 +1045,191 @@ 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
+
+class RactorTest < Minitest::Test
+  def test_ractor_simple
+    skip if SKIP_RACTOR_TESTS
+    
+    fn = Tempfile.new('extralite_test_database_in_ractor').path
+
+    r = Ractor.new do
+      path = receive
+      db = Extralite::Database.new(path)
+      i = receive
+      db.execute 'insert into foo values (?)', i
+    end
+
+    r << fn
+    db = Extralite::Database.new(fn)
+    db.execute 'create table foo (x)'
+    r << 42
+    r.take # wait for ractor to terminate
+
+    assert_equal 42, db.query_single_value('select x from foo')
+  end
+
+  # Adapted from here: https://github.com/sparklemotion/sqlite3-ruby/pull/365/files
+  def test_ractor_share_database
+    skip if SKIP_RACTOR_TESTS
+
+    db_receiver = Ractor.new do
+      db = Ractor.receive
+      Ractor.yield db.object_id
+      begin
+        db.execute("create table foo (b)")
+        raise "Should have raised an exception in db.execute()"
+      rescue => e
+        Ractor.yield e
+      end
+    end
+    sleep 0.1
+    db_creator = Ractor.new(db_receiver) do |db_receiver|
+      db = Extralite::Database.new(":memory:")
+      Ractor.yield db.object_id
+      db_receiver.send(db)
+      sleep 0.1
+      db.execute("create table foo (a)")
+    end
+    first_oid = db_creator.take
+    second_oid = db_receiver.take
+    refute_equal first_oid, second_oid
+    ex = db_receiver.take
+    assert_kind_of Extralite::Error, ex
+    assert_equal "Database is closed", ex.message
+  end
+
+  STRESS_DB_NAME = Tempfile.new('extralite_test_ractor_stress').path
+
+  # Adapted from here: https://github.com/sparklemotion/sqlite3-ruby/pull/365/files
+  def test_ractor_stress
+    skip if SKIP_RACTOR_TESTS
+    
+    Ractor.make_shareable(STRESS_DB_NAME)
+
+    db = Extralite::Database.new(STRESS_DB_NAME)
+    db.execute("PRAGMA journal_mode=WAL") # A little slow without this
+    db.execute("create table stress_test (a integer primary_key, b text)")
+    random = Random.new.freeze
+    ractors = (0..9).map do |ractor_number|
+      Ractor.new(random, ractor_number) do |random, ractor_number|
+        db_in_ractor = Extralite::Database.new(STRESS_DB_NAME)
+        db_in_ractor.busy_timeout = 3
+        10.times do |i|
+          db_in_ractor.execute("insert into stress_test(a, b) values (#{ractor_number * 100 + i}, '#{random.rand}')")
+        end
+      end
+    end
+    ractors.each { |r| r.take }
+    final_check = Ractor.new do
+      db_in_ractor = Extralite::Database.new(STRESS_DB_NAME)
+      count = db_in_ractor.query_single_value("select count(*) from stress_test")
+      Ractor.yield count
+    end
+    count = final_check.take
+    assert_equal 100, count
+  end
+end