extralite-bundle 2.5 → 2.7

data/test/test_database.rb

@@ -4,8 +4,9 @@ require_relative 'helper'
 
 require 'date'
 require 'tempfile'
+require 'json'
 
-class DatabaseTest < MiniTest::Test
+class DatabaseTest < Minitest::Test
   def setup
     @db = Extralite::Database.new(':memory:')
     @db.query('create table if not exists t (x,y,z)')
@@ -47,27 +48,38 @@ class DatabaseTest < MiniTest::Test
     assert_equal [], r
   end
 
-  def test_query_single_row
-    r = @db.query_single_row('select * from t order by x desc limit 1')
-    assert_equal({ x: 4, y: 5, z: 6 }, r)
+  def test_query_argv
+    r = @db.query_argv('select * from t')
+    assert_equal [[1, 2, 3], [4, 5, 6]], r
 
-    r = @db.query_single_row('select * from t where x = 2')
-    assert_nil r
+    r = @db.query_argv('select * from t where x = 2')
+    assert_equal [], r
+
+    # with block
+    r = []
+    @db.query_argv('select * from t') { |a, b, c| r << [a, b, c] }
+    assert_equal [[1, 2, 3], [4, 5, 6]], r
+  end
+
+  def test_query_argv_with_too_many_columns
+    assert_raises(Extralite::Error) {
+      @db.query_argv('select 1, 2, 3, 4, 5, 6, 7, 8, 9');
+    }
   end
 
-  def test_query_single_column
-    r = @db.query_single_column('select y from t')
-    assert_equal [2, 5], r
+  def test_query_single
+    r = @db.query_single('select * from t order by x desc limit 1')
+    assert_equal({ x: 4, y: 5, z: 6 }, r)
 
-    r = @db.query_single_column('select y from t where x = 2')
-    assert_equal [], r
+    r = @db.query_single('select * from t where x = 2')
+    assert_nil r
   end
 
-  def test_query_single_value
-    r = @db.query_single_value('select z from t order by Z desc limit 1')
+  def test_query_single_argv
+    r = @db.query_single_argv('select z from t order by Z desc limit 1')
     assert_equal 6, r
 
-    r = @db.query_single_value('select z from t where x = 2')
+    r = @db.query_single_argv('select z from t where x = 2')
     assert_nil r
   end
 
@@ -87,7 +99,7 @@ class DatabaseTest < MiniTest::Test
   def test_multiple_statements
     @db.query("insert into t values ('a', 'b', 'c'); insert into t values ('d', 'e', 'f');")
 
-    assert_equal [1, 4, 'a', 'd'], @db.query_single_column('select x from t order by x')
+    assert_equal [1, 4, 'a', 'd'], @db.query_argv('select x from t order by x')
   end
 
   def test_multiple_statements_with_error
@@ -111,13 +123,13 @@ class DatabaseTest < MiniTest::Test
 
   def test_close
     assert_equal false, @db.closed?
-    r = @db.query_single_value('select 42')
+    r = @db.query_single_argv('select 42')
     assert_equal 42, r
 
     assert_equal @db, @db.close
     assert_equal true, @db.closed?
 
-    assert_raises(Extralite::Error) { @db.query_single_value('select 42') }
+    assert_raises(Extralite::Error) { @db.query_single_argv('select 42') }
   end
 
   def test_parameter_binding_simple
@@ -127,7 +139,7 @@ class DatabaseTest < MiniTest::Test
     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) }
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_argv('select ?', Date.today) }
     assert_equal error.message, 'Cannot bind parameter at position 1 of type Date'
   end
 
@@ -161,33 +173,33 @@ class DatabaseTest < MiniTest::Test
   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)
+    assert_equal 42, @db.query_single_argv('select :bar', foo: 41, bar: 42)
+    assert_equal 42, @db.query_single_argv('select :bar', 'foo' => 41, 'bar' => 42)
+    assert_equal 42, @db.query_single_argv('select ?8', 7 => 41, 8 => 42)
+    assert_nil @db.query_single_argv('select :bar', foo: 41)
 
-    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', Foo.new => 42) }
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_argv('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) }
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_argv('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)
+    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)
+    assert_equal 41, @db.query_single_argv('select :foo', value)
+    assert_equal 42, @db.query_single_argv('select :bar', value)
+    assert_nil @db.query_single_argv('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)
+    foo_bar = Data.define(:':foo', :bar)
+    value = foo_bar.new(':foo': 41, bar: 42)
+    assert_equal 42, @db.query_single_argv('select :bar', value)
+    assert_nil @db.query_single_argv('select :baz', value)
   end
 
   def test_parameter_binding_for_blobs
@@ -197,69 +209,69 @@ class DatabaseTest < MiniTest::Test
 
     # it's a string, not a blob
     @db.execute('INSERT INTO blobs VALUES (?)', 'Hello, 世界!')
-    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    result = @db.query_single(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)
+    result = @db.query_single(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)
+    result = @db.query_single(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)
+    result = @db.query_single(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)
+    assert_nil @db.query_single_argv('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)
+    assert_equal(-2** 31, @db.query_single_argv('select ?', -2**31))
+    assert_equal(2**31 - 1, @db.query_single_argv('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)
+    assert_equal(-2 ** 63, @db.query_single_argv('select ?', -2 ** 63))
+    assert_equal(2**63 - 1, @db.query_single_argv('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)
+    assert_equal Float::MIN, @db.query_single_argv('select ?', Float::MIN)
+    assert_equal Float::MAX, @db.query_single_argv('select ?', Float::MAX)
 
     # boolean
-    assert_equal 1, @db.query_single_value('select ?', true)
-    assert_equal 0, @db.query_single_value('select ?', false)
+    assert_equal 1, @db.query_single_argv('select ?', true)
+    assert_equal 0, @db.query_single_argv('select ?', false)
 
     # strings and symbols
-    assert_equal 'foo', @db.query_single_value('select ?', 'foo')
-    assert_equal 'foo', @db.query_single_value('select ?', :foo)
+    assert_equal 'foo', @db.query_single_argv('select ?', 'foo')
+    assert_equal 'foo', @db.query_single_argv('select ?', :foo)
   end
 
   def test_value_casting
-    r = @db.query_single_value("select 'abc'")
+    r = @db.query_single_argv("select 'abc'")
     assert_equal 'abc', r
 
-    r = @db.query_single_value('select 123')
+    r = @db.query_single_argv('select 123')
     assert_equal 123, r
 
-    r = @db.query_single_value('select 12.34')
+    r = @db.query_single_argv('select 12.34')
     assert_equal 12.34, r
 
-    r = @db.query_single_value('select zeroblob(4)')
+    r = @db.query_single_argv('select zeroblob(4)')
     assert_equal "\x00\x00\x00\x00", r
 
-    r = @db.query_single_value('select null')
+    r = @db.query_single_argv('select null')
     assert_nil r
   end
 
@@ -271,7 +283,7 @@ class DatabaseTest < MiniTest::Test
       @db.load_extension(File.join(__dir__, 'extensions/text.dylib'))
     end
 
-    r = @db.query_single_value("select reverse('abcd')")
+    r = @db.query_single_argv("select reverse('abcd')")
     assert_equal 'dcba', r
   end
 
@@ -592,7 +604,7 @@ class DatabaseTest < MiniTest::Test
     ], array
   end
 
-  def test_batch_query_single_column_with_array
+  def test_batch_query_argv_with_array
     @db.query('create table foo (a, b, c)')
     assert_equal [], @db.query('select * from foo')
 
@@ -600,20 +612,20 @@ class DatabaseTest < MiniTest::Test
       [1, '2', 3],
       ['4', 5, 6]
     ]
-    results = @db.batch_query_single_column('insert into foo values (?, ?, ?) returning c', data)
+    results = @db.batch_query_argv('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])
+    results = @db.batch_query_argv('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|
+    changes = @db.batch_query_argv('update foo set c = ? returning c * 10 + cast(b as integer)', [44, 45]) do |rows|
       array << rows
     end
     assert_equal 4, changes
@@ -623,25 +635,25 @@ class DatabaseTest < MiniTest::Test
     ], array
   end
 
-  def test_batch_query_single_column_with_enumerable
+  def test_batch_query_argv_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)
+    results = @db.batch_query_argv('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)
+    results = @db.batch_query_argv('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|
+    changes = @db.batch_query_argv('update foo set b = ? returning b * 10 + a', 44..45) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -651,13 +663,13 @@ class DatabaseTest < MiniTest::Test
     ], array
   end
 
-  def test_batch_query_single_column_with_proc
+  def test_batch_query_argv_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)
+    results = @db.batch_query_argv('insert into foo (b) values (?) returning b', pr)
     assert_equal [
       [5],
       [4],
@@ -665,7 +677,7 @@ class DatabaseTest < MiniTest::Test
     ], results
 
     pr = parameter_source_proc([42, 43])
-    results = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', pr)
+    results = @db.batch_query_argv('update foo set b = ? returning b * 10 + a', pr)
     assert_equal [
       [421, 422, 423],
       [431, 432, 433]
@@ -673,7 +685,7 @@ class DatabaseTest < MiniTest::Test
 
     array = []
     pr = parameter_source_proc([44, 45])
-    changes = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', pr) do |rows|
+    changes = @db.batch_query_argv('update foo set b = ? returning b * 10 + a', pr) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -703,6 +715,8 @@ class DatabaseTest < MiniTest::Test
       SQL
     }
     t.join
+  ensure
+    t&.kill
   end
 
   def test_database_status
@@ -766,6 +780,8 @@ class DatabaseTest < MiniTest::Test
 
     db2.busy_timeout = nil
     assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
+  ensure
+    t&.kill
   end
 
   def test_database_total_changes
@@ -817,30 +833,31 @@ class DatabaseTest < MiniTest::Test
     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)
+    fn = Tempfile.new('extralite_test_database_initialize_options_wal').path
+    db = Extralite::Database.new(fn, wal: 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)
+
+    fn = Tempfile.new('extralite_test_database_initialize_options_pragma').path
+    db = Extralite::Database.new(fn, pragma: { application_id: 42 })
+    assert_equal 42, db.pragma(:application_id)
   end
 
   def test_database_inspect
     db = Extralite::Database.new(':memory:')
-    assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect
+    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
+    assert_match(/^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect)
     db.close
-    assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ \(closed\)\>$/, db.inspect
+    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'")
+    v = db.query_single_argv("select 'foo'")
     assert_equal 'foo', v
     assert_equal 'UTF-8', v.encoding.name
   end
@@ -856,7 +873,7 @@ class DatabaseTest < MiniTest::Test
 
     q1 = Queue.new
     q2 = Queue.new
-    th = Thread.new do
+    t = Thread.new do
       db1.transaction do
         assert_equal true, db1.transaction_active?
         db1.execute('insert into foo values (42)')
@@ -871,9 +888,11 @@ class DatabaseTest < MiniTest::Test
     assert_equal [], db2.query('select * from foo')
 
     q2 << true
-    th.join
+    t.join
     # transaction now committed
     assert_equal [{ x: 42 }], db2.query('select * from foo')
+  ensure
+    t&.kill
   end
 
   def test_database_transaction_rollback
@@ -896,9 +915,109 @@ class DatabaseTest < MiniTest::Test
     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_argv('select x from foo')
+
+      db.savepoint(:a)
+
+      db.execute('insert into foo values (43)')
+      assert_equal [42, 43], db.query_argv('select x from foo')
+      
+      db.savepoint(:b)
+
+      db.execute('insert into foo values (44)')
+      assert_equal [42, 43, 44], db.query_argv('select x from foo')
+
+      db.rollback_to(:b)
+      assert_equal [42, 43], db.query_argv('select x from foo')
+
+      db.release(:a)
+
+      assert_equal [42, 43], db.query_argv('select x from foo')
+    end
+  end
+
+  def test_prepare
+    q = @db.prepare('select * from t order by x')
+    assert_kind_of Extralite::Query, q
+
+    assert_equal [
+      { x: 1, y: 2, z: 3},
+      { x: 4, y: 5, z: 6}
+    ], q.to_a
+  end
+
+  def test_prepare_argv
+    q = @db.prepare_argv('select * from t order by x')
+    assert_kind_of Extralite::Query, q
+
+    buf = []
+    q.each { |x, y, z| buf << z }
+    assert_equal [3, 6], buf
+  end
+
+  def test_prepare_ary
+    q = @db.prepare_ary('select * from t order by x')
+    assert_kind_of Extralite::Query, q
+
+    assert_equal [
+      [1, 2, 3],
+      [4, 5, 6]
+    ], q.to_a
+  end
+
+  def test_prepare_with_transform
+    q = @db.prepare('select * from t order by x') { |h| h[:x] * 100 + h[:y] * 10 + h[:z] }
+    assert_equal [
+      123,
+      456
+    ], q.to_a
+  end
+
+  def test_prepare_argv_with_transform
+    q = @db.prepare_argv('select * from t order by x') { |x, y, z| x * 100 + y * 10 + z }
+    assert_equal [
+      123,
+      456
+    ], q.to_a
+  end
+
+  def test_prepare_ary_with_transform
+    q = @db.prepare_ary('select * from t order by x') { |r| r * 2 }
+    assert_equal [
+      [1, 2, 3, 1, 2, 3],
+      [4, 5, 6, 4, 5, 6]
+    ], q.to_a
+  end
 end
 
-class ScenarioTest < MiniTest::Test
+class ScenarioTest < Minitest::Test
   def setup
     @fn = Tempfile.new('extralite_scenario_test').path
     @db = Extralite::Database.new(@fn)
@@ -927,7 +1046,7 @@ class ScenarioTest < MiniTest::Test
 
     sleep 0.1
     @db.query 'begin deferred'
-    result = @db.query_single_column('select x from t')
+    result = @db.query_argv('select x from t')
     assert_equal [1, 4], result
 
     assert_raises(Extralite::BusyError) do
@@ -961,8 +1080,10 @@ class ScenarioTest < MiniTest::Test
     @db.query('insert into t values (7, 8, 9)')
     @db.query('commit')
 
-    result = @db.query_single_column('select x from t')
+    result = @db.query_argv('select x from t')
     assert_equal [1, 4, 7], result
+  ensure
+    t&.kill
   end
 
   def test_concurrent_queries
@@ -988,7 +1109,10 @@ class ScenarioTest < MiniTest::Test
     t1.join
     t2.join
 
-    assert_equal (1..100).to_a, @db.query_single_column('select x from t order by x')
+    assert_equal (1..100).to_a, @db.query_argv('select x from t order by x')
+  ensure
+    t1&.kill
+    t2&.kill
   end
 
   def test_database_trace
@@ -1017,7 +1141,7 @@ class ScenarioTest < MiniTest::Test
   end
 end
 
-class BackupTest < MiniTest::Test
+class BackupTest < Minitest::Test
   def setup
     @src = Extralite::Database.new(':memory:')
     @dst = Extralite::Database.new(':memory:')
@@ -1053,7 +1177,7 @@ class BackupTest < MiniTest::Test
   end
 end
 
-class GVLReleaseThresholdTest < Minitest::Test
+class ConcurrencyTest < Minitest::Test
   def setup
     @sql = <<~SQL
       WITH RECURSIVE r(i) AS (
@@ -1097,6 +1221,9 @@ class GVLReleaseThresholdTest < Minitest::Test
 
     assert delays.size > 4
     assert_equal 0, delays.select { |d| d > 0.15 }.size
+  ensure
+    t1&.kill
+    t2&.kill
   end
 
   def test_gvl_always_hold
@@ -1131,6 +1258,9 @@ class GVLReleaseThresholdTest < Minitest::Test
 
     assert delays.size >= 1
     assert delays.first > 0.2
+  ensure
+    t1&.kill
+    t2&.kill
   end
 
   def test_gvl_mode_get_set
@@ -1148,6 +1278,327 @@ class GVLReleaseThresholdTest < Minitest::Test
     db.gvl_release_threshold = nil
     assert_equal 1000, db.gvl_release_threshold
   end
+
+  def test_progress_handler_simple
+    db = Extralite::Database.new(':memory:')
+
+    buf = []
+    db.on_progress(period: 1) { buf << :progress }
+
+    result = db.query_single('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(period: 2) { buf << :progress }
+
+    result = db.query_single('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
+
+  def test_progress_handler_normal_mode
+    db = Extralite::Database.new(':memory:')
+
+    count = 0
+    db.on_progress(period: 1) { count += 1 }
+    db.query('select 1 as a')
+    assert count > 0
+    base_count = count
+
+    count = 0
+    db.on_progress(period: 1) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal base_count * 10, count
+
+    count = 0
+    db.on_progress(period: 10, tick: 1) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal base_count, count
+  end
+
+  def test_progress_handler_at_least_once_mode
+    db = Extralite::Database.new(':memory:')
+
+    count = 0
+    db.on_progress(period: 1) { count += 1 }
+    db.query('select 1 as a')
+    assert count > 0
+    base_count = count
+
+    count = 0
+    db.on_progress(period: 1, mode: :at_least_once) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal base_count * 10 + 10, count
+
+    count = 0
+    db.on_progress(period: 10, tick: 1, mode: :at_least_once) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal base_count + 10, count
+  end
+
+  def test_progress_handler_once_mode
+    db = Extralite::Database.new(':memory:')
+
+    count = 0
+    db.on_progress(mode: :once) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal 10, count
+
+    count = 0
+    db.on_progress(period: 1, mode: :once) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal 10, count
+
+    count = 0
+    db.on_progress(period: 10, tick: 1, mode: :once) { count += 1 }
+    10.times { db.query('select 1 as a') }
+    assert_equal 10, count
+  end
+
+  def test_progress_handler_once_mode_with_batch_query
+    db = Extralite::Database.new(':memory:')
+
+    count = 0
+    db.on_progress(period: 1, mode: :once) { count += 1 }
+    db.batch_query('select ?', 1..10)
+    assert_equal 10, count
+
+    db.batch_query('select ?', 1..3)
+    assert_equal 13, count
+  end
+
+  def test_progress_handler_reset
+    db = Extralite::Database.new(':memory:')
+
+    count = 0
+    set_progress = -> {
+      count = 0
+      db.on_progress(mode: :once) { count += 1 }
+    }
+
+    set_progress.()
+    10.times { db.query('select 1 as a') }
+    assert_equal 10, count
+
+    count = 0
+    db.on_progress(mode: :none)
+    10.times { db.query('select 1 as a') }
+    assert_equal 0, count
+
+    set_progress.()
+    10.times { db.query('select 1 as a') }
+    assert_equal 10, count
+
+    count = 0
+    db.on_progress(period: 0) { foo }
+    10.times { db.query('select 1 as a') }
+    assert_equal 0, count
+
+    set_progress.()
+    10.times { db.query('select 1 as a') }
+    assert_equal 10, count
+
+    count = 0
+    db.on_progress
+    10.times { db.query('select 1 as a') }
+    assert_equal 0, count
+  end
+
+  def test_progress_handler_invalid_arg
+    db = Extralite::Database.new(':memory:')
+    
+    assert_raises(TypeError) { db.on_progress(period: :foo) }
+    assert_raises(TypeError) { db.on_progress(tick: :foo) }
+    assert_raises(ArgumentError) { db.on_progress(mode: :foo) }
+  end
+
+  def test_progress_handler_once_mode_with_prepared_query
+    db = Extralite::Database.new(':memory:')
+    db.execute 'create table foo (x)'
+    db.batch_query('insert into foo values (?)', 1..10)
+    q = db.prepare('select x from foo')
+
+    count = 0
+    db.on_progress(period: 1, mode: :once) { count += 1 }
+
+    q.to_a
+    assert_equal 1, count
+
+    q.reset
+    record_count = 0
+    assert_equal 2, count
+    while q.next
+      record_count += 1
+    end
+    assert_equal 10, record_count
+    assert_equal 2, count
+
+    q.reset
+    assert_equal 3, count
+    while q.next
+      record_count += 1
+    end
+    assert_equal 3, count
+  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 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 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 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
+
+  def test_global_progress_handler
+    count = 0
+    Extralite.on_progress(tick: 1, period: 1) { count += 1 }
+
+    db = Extralite::Database.new(':memory:')
+    10.times { db.query('select 1') }
+    refute_equal 0, count
+
+    old_count = count
+    Extralite.on_progress # remove global progress handler
+
+    # already opened db should preserve progress handler behaviour
+    10.times { db.query('select 1') }
+    refute_equal old_count, count
+
+    old_count = count
+    db2 = Extralite::Database.new(':memory:')
+    10.times { db2.query('select 1') }
+    assert_equal old_count, count
+  ensure
+    Extralite.on_progress(mode: :none)
+  end
 end
 
 class RactorTest < Minitest::Test
@@ -1169,67 +1620,232 @@ class RactorTest < Minitest::Test
     r << 42
     r.take # wait for ractor to terminate
 
-    assert_equal 42, db.query_single_value('select x from foo')
+    assert_equal 42, db.query_single_argv('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
+    skip "skipped for now as ractors seem kinda flakey (failing sporadically)"
 
     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()"
+        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:")
+      db = Extralite::Database.new(':memory:')
       Ractor.yield db.object_id
       db_receiver.send(db)
       sleep 0.1
-      db.execute("create table foo (a)")
+      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
+    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)")
+    fn = Tempfile.new('extralite_test_ractor_stress').path
     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
+      sleep 0.05
+      Ractor.new(fn, random, ractor_number) do |rfn, r, n|
+        rdb = Extralite::Database.new(rfn)
+        rdb.busy_timeout = 3
+        rdb.pragma(journal_mode: 'wal', synchronous: 1)
+        rdb.execute('create table if not exists stress_test (a integer primary_key, b text)')
+        changes = 0
         10.times do |i|
-          db_in_ractor.execute("insert into stress_test(a, b) values (#{ractor_number * 100 + i}, '#{random.rand}')")
+          changes += rdb.execute('insert into stress_test(a, b) values (?, ?)', n * 100 + i, r.rand)
         end
+        Ractor.yield changes
       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")
+
+    buf = []
+    ractors.each { |r| buf << r.take }
+    assert_equal [10] * 10, buf
+
+    final_check = Ractor.new(fn) do |rfn|
+      rdb = Extralite::Database.new(rfn, wal: true)
+      count = rdb.query_single_argv('select count(*) from stress_test')
       Ractor.yield count
     end
     count = final_check.take
     assert_equal 100, count
   end
 end
+
+class DatabaseTransformTest < Minitest::Test
+  def setup
+    @db = Extralite::Database.new(':memory:')
+    @db.query('create table t (a, b, c)')
+
+    @q3 = @db.prepare('select * from t where a = ?')
+    @q4 = @db.prepare('select * from t order by a')
+
+    @db.batch_execute('insert into t (a, b, c) values (?, ?, ?)', [
+      [1, 2, { foo: 42, bar: 43 }.to_json],
+      [4, 5, { foo: 45, bar: 46 }.to_json]
+    ])
+  end
+
+  class MyModel
+    def initialize(h)
+      @h = h
+    end
+
+    def values
+      @h
+    end
+  end
+
+  def test_query_hash_transform
+    transform = ->(h) { MyModel.new(h) }
+
+    sql = 'select a, b from t where a = ?'
+    o = @db.query(transform, sql, 1).first
+    assert_kind_of MyModel, o
+    assert_equal({ a: 1, b: 2 }, o.values)
+
+    o = @db.query(transform, sql, 4).first
+    assert_kind_of MyModel, o
+    assert_equal({ a: 4, b: 5 }, o.values)
+
+    sql = 'select a, b from t order by a'
+    assert_equal [
+      { a: 1, b: 2 },
+      { a: 4, b: 5 }
+    ], @db.query(transform, sql).map(&:values)
+
+    buf = []
+    @db.query(transform, sql) { |r| buf << r.values }
+    assert_equal [
+      { a: 1, b: 2 },
+      { a: 4, b: 5 }
+    ], buf
+  end
+
+  def test_query_ary_transform
+    transform = ->(h) { MyModel.new(h) }
+
+    sql = 'select a, b from t where a = ?'
+    o = @db.query_ary(transform, sql, 1).first
+    assert_kind_of MyModel, o
+    assert_equal([1, 2], o.values)
+
+    o = @db.query_ary(transform, sql, 4).first
+    assert_kind_of MyModel, o
+    assert_equal([4, 5], o.values)
+
+    sql = 'select a, b from t order by a'
+    assert_equal [
+      [1, 2],
+      [4, 5]
+    ], @db.query_ary(transform, sql).map(&:values)
+
+    buf = []
+    @db.query_ary(transform, sql) { |r| buf << r.values }
+    assert_equal [
+      [1, 2],
+      [4, 5]
+    ], buf
+  end
+
+  def test_query_hash_single_row_transform
+    transform = ->(h) { MyModel.new(h) }
+
+    sql = 'select a, b from t where a = ?'
+    o = @db.query_single(transform, sql, 1)
+    assert_kind_of MyModel, o
+    assert_equal({ a: 1, b: 2 }, o.values)
+
+    o = @db.query_single(transform, sql, 4)
+    assert_kind_of MyModel, o
+    assert_equal({ a: 4, b: 5 }, o.values)
+  end
+
+  def test_query_ary_single_row_transform
+    transform = ->(h) { MyModel.new(h) }
+
+    sql = 'select a, b from t where a = ?'
+    o = @db.query_single_ary(transform, sql, 1)
+    assert_kind_of MyModel, o
+    assert_equal([1, 2], o.values)
+
+    o = @db.query_single_ary(transform, sql, 4)
+    assert_kind_of MyModel, o
+    assert_equal([4, 5], o.values)
+  end
+
+  def test_query_argv_single_column_transform
+    transform = ->(c) { JSON.parse(c, symbolize_names: true) }
+    sql = 'select c from t where a = ?'
+
+    assert_equal([{ foo: 42, bar: 43 }], @db.query_argv(transform, sql, 1))
+    assert_equal([{ foo: 45, bar: 46 }], @db.query_argv(transform, sql, 4))
+
+    sql = 'select c from t order by a'
+    assert_equal [
+      { foo: 42, bar: 43 },
+      { foo: 45, bar: 46 }
+    ], @db.query_argv(transform, sql)
+
+    buf = []
+    @db.query_argv(transform, sql) { |r| buf << r }
+    assert_equal [
+      { foo: 42, bar: 43 },
+      { foo: 45, bar: 46 }
+    ], buf
+  end
+
+  def test_query_argv_single_row_single_column
+    transform = ->(c) { JSON.parse(c, symbolize_names: true) }
+    sql = 'select c from t where a = ?'
+
+    assert_equal({ foo: 42, bar: 43 }, @db.query_single_argv(transform, sql, 1))
+    assert_equal({ foo: 45, bar: 46 }, @db.query_single_argv(transform, sql, 4))
+  end
+
+  def test_query_argv_multi_column
+    transform = ->(a, b, c) { { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
+    sql = 'select * from t where a = ?'
+
+    assert_equal([{ a: 1, b: 2, c: { foo: 42, bar: 43 }}], @db.query_argv(transform, sql, 1))
+    assert_equal([{ a: 4, b: 5, c: { foo: 45, bar: 46 }}], @db.query_argv(transform, sql, 4))
+
+    sql = 'select * from t order by a'
+    assert_equal [
+      { a: 1, b: 2, c: { foo: 42, bar: 43 }},
+      { a: 4, b: 5, c: { foo: 45, bar: 46 }}
+    ], @db.query_argv(transform, sql)
+
+    buf = []
+    @db.query_argv(transform, sql) { |r| buf << r }
+    assert_equal [
+      { a: 1, b: 2, c: { foo: 42, bar: 43 }},
+      { a: 4, b: 5, c: { foo: 45, bar: 46 }}
+    ], buf
+  end
+
+  def test_query_argv_single_row_multi_column
+    transform = ->(a, b, c) { { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
+    sql = 'select * from t where a = ?'
+
+    assert_equal({ a: 1, b: 2, c: { foo: 42, bar: 43 }}, @db.query_single_argv(transform, sql, 1))
+    assert_equal({ a: 4, b: 5, c: { foo: 45, bar: 46 }}, @db.query_single_argv(transform, sql, 4))
+  end
+end