extralite-bundle 2.4 → 2.6

data/test/test_database.rb

@@ -61,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')
@@ -288,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
@@ -311,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')
 
@@ -320,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 [
@@ -329,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')
 
@@ -338,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 [
@@ -347,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
@@ -477,6 +813,19 @@ 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
@@ -547,6 +896,53 @@ end
     assert_kind_of RuntimeError, exception
     assert_equal 'bar', exception.message
   end
+
+  def test_database_transaction_rollback!
+    db = Extralite::Database.new(':memory:')
+    db.execute('create table foo(x)')
+
+    exception = nil
+    begin
+      db.transaction do
+        db.execute('insert into foo values (42)')
+        db.rollback!
+      end
+    rescue => e
+      exception = e
+    end
+
+    assert_equal [], db.query('select * from foo')
+    assert_nil exception
+  end
+
+  def test_database_savepoint
+    db = Extralite::Database.new(':memory:')
+    db.execute('create table foo(x)')
+
+    db.transaction do
+      assert_equal [], db.query('select * from foo')
+
+      db.execute('insert into foo values (42)')
+      assert_equal [42], db.query_single_column('select x from foo')
+
+      db.savepoint(:a)
+
+      db.execute('insert into foo values (43)')
+      assert_equal [42, 43], db.query_single_column('select x from foo')
+      
+      db.savepoint(:b)
+
+      db.execute('insert into foo values (44)')
+      assert_equal [42, 43, 44], db.query_single_column('select x from foo')
+
+      db.rollback_to(:b)
+      assert_equal [42, 43], db.query_single_column('select x from foo')
+
+      db.release(:a)
+
+      assert_equal [42, 43], db.query_single_column('select x from foo')
+    end
+  end
 end
 
 class ScenarioTest < MiniTest::Test
@@ -616,6 +1012,32 @@ 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 }
@@ -678,7 +1100,7 @@ class BackupTest < MiniTest::Test
   end
 end
 
-class GVLReleaseThresholdTest < Minitest::Test
+class ConcurrencyTest < Minitest::Test
   def setup
     @sql = <<~SQL
       WITH RECURSIVE r(i) AS (
@@ -773,4 +1195,241 @@ class GVLReleaseThresholdTest < Minitest::Test
     db.gvl_release_threshold = nil
     assert_equal 1000, db.gvl_release_threshold
   end
-end
+
+  def test_progress_handler_simple
+    db = Extralite::Database.new(':memory:')
+
+    buf = []
+    db.on_progress(1) { buf << :progress }
+
+    result = db.query_single_row('select 1 as a, 2 as b, 3 as c')
+    assert_equal({ a: 1, b: 2, c: 3 }, result)
+    assert_in_range 5..7, buf.size
+
+    buf = []
+    db.on_progress(2) { buf << :progress }
+
+    result = db.query_single_row('select 1 as a, 2 as b, 3 as c')
+    assert_equal({ a: 1, b: 2, c: 3 }, result)
+    assert_in_range 2..4, buf.size
+  end
+
+  LONG_QUERY = <<~SQL
+    WITH RECURSIVE
+      fibo (curr, next)
+    AS
+    ( SELECT 1,1
+      UNION ALL
+      SELECT next, curr + next FROM fibo
+      LIMIT 10000000 )
+    SELECT curr, next FROM fibo LIMIT 1 OFFSET 10000000-1;
+  SQL
+
+  def test_progress_handler_timeout_interrupt
+    db = Extralite::Database.new(':memory:')
+    t0 = Time.now
+    db.on_progress(1000) do
+      Thread.pass
+      db.interrupt if Time.now - t0 >= 0.2
+    end
+
+    q = db.prepare(LONG_QUERY)
+    result = nil
+    err = nil
+    begin
+      result = q.next
+    rescue => e
+      err = e
+    end
+    t1 = Time.now
+
+    assert_nil result
+    assert_equal 1, ((t1 - t0) * 5).round.to_i
+    assert_kind_of Extralite::InterruptError, err
+
+    # try a second time, just to make sure no undefined state is left behind
+    t0 = Time.now
+    q = db.prepare(LONG_QUERY)
+    result = nil
+    err = nil
+    begin
+      result = q.next
+    rescue => e
+      err = e
+    end
+    t1 = Time.now
+
+    assert_nil result
+    assert_equal 1, ((t1 - t0) * 5).round.to_i
+    assert_kind_of Extralite::InterruptError, err
+  end
+
+  class CustomTimeoutError < RuntimeError
+  end
+
+  def test_progress_handler_timeout_raise
+    db = Extralite::Database.new(':memory:')
+    t0 = Time.now
+    db.on_progress(1000) do
+      Thread.pass
+      raise CustomTimeoutError if Time.now - t0 >= 0.2
+    end
+
+    q = db.prepare(LONG_QUERY)
+    result = nil
+    err = nil
+    begin
+      result = q.next
+    rescue => e
+      err = e
+    end
+    t1 = Time.now
+
+    assert_nil result
+    assert_equal 1, ((t1 - t0) * 5).round.to_i
+    assert_kind_of CustomTimeoutError, err
+
+    # try a second time, just to make sure no undefined state is left behind
+    t0 = Time.now
+    q = db.prepare(LONG_QUERY)
+    result = nil
+    err = nil
+    begin
+      result = q.next
+    rescue => e
+      err = e
+    end
+    t1 = Time.now
+
+    assert_nil result
+    assert_equal 1, ((t1 - t0) * 5).round.to_i
+    assert_kind_of CustomTimeoutError, err
+  end
+
+  def test_progress_handler_busy_timeout
+    fn = Tempfile.new('extralite_test_progress_handler_busy_timeout').path
+    db1 = Extralite::Database.new(fn)
+    db2 = Extralite::Database.new(fn)
+
+    db1.query('begin exclusive')
+    assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+
+    t0 = Time.now
+    db2.on_progress(1000) do
+      Thread.pass
+      raise CustomTimeoutError if Time.now - t0 >= 0.2
+    end
+
+    result = nil
+    err = nil
+    begin
+      result = db2.execute('begin exclusive')
+    rescue => e
+      err = e
+    end
+    t1 = Time.now
+
+    assert_nil result
+    assert_equal 1, ((t1 - t0) * 5).round.to_i
+    assert_kind_of CustomTimeoutError, err
+
+    # Try a second time, to ensure no undefined state remains behind
+    t0 = Time.now
+    result = nil
+    err = nil
+    begin
+      result = db2.execute('begin exclusive')
+    rescue => e
+      err = e
+    end
+    t1 = Time.now
+
+    assert_nil result
+    assert_equal 1, ((t1 - t0) * 5).round.to_i
+    assert_kind_of CustomTimeoutError, err
+  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