extralite 2.6 → 2.7.1

data/test/test_query.rb

@@ -2,8 +2,9 @@
 
 require_relative 'helper'
 require 'date'
+require 'json'
 
-class QueryTest < MiniTest::Test
+class QueryTest < Minitest::Test
   def setup
     @db = Extralite::Database.new(':memory:')
     @db.query('create table if not exists t (x,y,z)')
@@ -17,10 +18,47 @@ class QueryTest < MiniTest::Test
 
   def test_prepare
     query = @db.prepare('select 1')
-    assert_equal 1, query.next_single_column
+    assert_equal({ '1': 1 }, query.next)
 
     query = @db.prepare('select x from t where y = ?', 5)
-    assert_equal 4, query.next_single_column
+    assert_equal({ x: 4 }, query.next)
+  end
+
+  def test_mode
+    query = @db.prepare('select 1')
+    assert_equal :hash, query.mode
+    
+    query.mode = :argv
+    assert_equal :argv, query.mode
+
+    query.mode = :ary
+    assert_equal :ary, query.mode
+
+    assert_raises(Extralite::Error) { query.mode = :foo }
+    assert_equal :ary, query.mode
+
+    query.mode = :hash
+    assert_equal :hash, query.mode
+  end
+
+  def test_prepare_argv
+    query = @db.prepare_argv('select 1')
+    assert_equal :argv, query.mode
+
+    assert_equal 1, query.next
+  end
+
+  def test_prepare_argv_with_too_many_columns
+    q = @db.prepare_argv('select 1, 2, 3, 4, 5, 6, 7, 8, 9')
+
+    assert_raises(Extralite::Error) { q.next }
+  end
+
+  def test_prepare_ary
+    query = @db.prepare_ary('select 1')
+    assert_equal :ary, query.mode
+
+    assert_equal [1], query.next
   end
 
   def test_query_props
@@ -33,13 +71,13 @@ class QueryTest < MiniTest::Test
   def test_bind
     @db.query("insert into t values ('a', 'b', 'c')")
 
-    q = @db.prepare('select * from t where `z` = :foo')
-    results = q.bind(foo: 'c').to_a_ary
+    q = @db.prepare_ary('select * from t where `z` = :foo')
+    results = q.bind(foo: 'c').to_a
 
     assert_equal [['a', 'b', 'c']], results
 
     # try again with the same parameters
-    results = q.to_a_ary
+    results = q.to_a
 
     assert_equal [['a', 'b', 'c']], results
   end
@@ -61,19 +99,6 @@ class QueryTest < MiniTest::Test
     # EOF should repeat
     v = query.next
     assert_nil v
-
-    query = @db.prepare('select * from t')
-    v = query.next_hash
-    assert_equal({ x: 1, y: 2, z: 3}, v)
-
-    v = query.next_hash
-    assert_equal({ x: 4, y: 5, z: 6}, v)
-
-    v = query.next_hash
-    assert_equal({ x: 7, y: 8, z: 9}, v)
-
-    v = query.next_hash
-    assert_nil v
   end
 
   def test_query_next_with_row_count
@@ -134,97 +159,112 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_next_ary
-    query = @db.prepare('select * from t')
-    v = query.next_ary
+    query = @db.prepare_ary('select * from t')
+    v = query.next
     assert_equal([1, 2, 3], v)
 
-    v = query.next_ary
+    v = query.next
     assert_equal([4, 5, 6], v)
 
-    v = query.next_ary
+    v = query.next
     assert_equal([7, 8, 9], v)
 
-    v = query.next_ary
+    v = query.next
     assert_nil v
 
-    v = query.next_ary
+    v = query.next
     assert_nil v
   end
 
   def test_query_next_ary_with_row_count
-    query = @db.prepare('select * from t')
-    v = query.next_ary(1)
+    query = @db.prepare_ary('select * from t')
+    v = query.next(1)
     assert_equal([[1, 2, 3]], v)
 
-    v = query.next_ary(2)
+    v = query.next(2)
     assert_equal([[4, 5, 6], [7, 8, 9]], v)
 
-    v = query.next_ary(2)
+    v = query.next(2)
     assert_equal([], v)
 
-    v = query.next_ary(2)
+    v = query.next(2)
     assert_nil v
   end
 
   def test_query_next_ary_with_block
-    query = @db.prepare('select * from t')
+    query = @db.prepare_ary('select * from t')
     buf = []
-    v = query.next_ary { |r| buf << r }
+    v = query.next { |r| buf << r }
     assert_equal query, v
     assert_equal [[1, 2, 3]], buf
 
     buf = []
-    v = query.next_ary(2) { |r| buf << r }
+    v = query.next(2) { |r| buf << r }
     assert_equal query, v
     assert_equal [[4, 5, 6], [7, 8, 9]], buf
 
     buf = []
-    v = query.next_ary(2) { |r| buf << r }
+    v = query.next(2) { |r| buf << r }
     assert_equal query, v
     assert_equal [], buf
   end
 
-  def test_query_next_single_column
-    query = @db.prepare('select x from t')
-    v = query.next_single_column
+  def test_query_next_argv_single_column
+    query = @db.prepare_argv('select x from t')
+    v = query.next
     assert_equal(1, v)
 
-    v = query.next_single_column
+    v = query.next
     assert_equal(4, v)
 
-    v = query.next_single_column
+    v = query.next
     assert_equal(7, v)
 
-    v = query.next_single_column
+    v = query.next
     assert_nil v
   end
 
-  def test_query_next_single_column_with_row_count
-    query = @db.prepare('select x from t')
-    v = query.next_single_column(1)
+  def test_query_next_argv_multi_column
+    query = @db.prepare_argv('select x, y from t')
+    v = query.next
+    assert_equal([1, 2], v)
+
+    v = query.next
+    assert_equal([4, 5], v)
+
+    v = query.next
+    assert_equal([7, 8], v)
+
+    v = query.next
+    assert_nil v
+  end
+
+  def test_query_next_argv_with_row_count
+    query = @db.prepare_argv('select x from t')
+    v = query.next(1)
     assert_equal([1], v)
 
-    v = query.next_single_column(3)
+    v = query.next(3)
     assert_equal([4, 7], v)
 
-    v = query.next_single_column(2)
+    v = query.next(2)
     assert_nil v
   end
 
-  def test_query_next_single_column_with_block
-    query = @db.prepare('select x from t')
+  def test_query_next_argv_with_block
+    query = @db.prepare_argv('select x, y from t')
     buf = []
-    v = query.next_single_column { |r| buf << r }
+    v = query.next { |x, y| buf << [x, y] }
     assert_equal query, v
-    assert_equal [1], buf
+    assert_equal [[1, 2]], buf
 
     buf = []
-    v = query.next_single_column(2) { |r| buf << r }
+    v = query.next(2) { |x, y| buf << [x, y] }
     assert_equal query, v
-    assert_equal [4, 7], buf
+    assert_equal [[4, 5], [7, 8]], buf
 
     buf = []
-    v = query.next_single_column(2) { |r| buf << r }
+    v = query.next(2) { |x, y| buf << [x, y] }
     assert_equal query, v
     assert_equal [], buf
   end
@@ -233,14 +273,13 @@ class QueryTest < MiniTest::Test
     assert_equal [{ x: 1, y: 2, z: 3 }], @query.bind(1).to_a
     assert_equal [{ x: 4, y: 5, z: 6 }], @query.bind(4).to_a
 
-    assert_equal [{ x: 1, y: 2, z: 3 }], @query.bind(1).to_a_hash
-    assert_equal [{ x: 4, y: 5, z: 6 }], @query.bind(4).to_a_hash
+    @query.mode = :ary
 
-    assert_equal [[1, 2, 3]], @query.bind(1).to_a_ary
-    assert_equal [[4, 5, 6]], @query.bind(4).to_a_ary
+    assert_equal [[1, 2, 3]], @query.bind(1).to_a
+    assert_equal [[4, 5, 6]], @query.bind(4).to_a
 
-    query = @db.prepare('select y from t')
-    assert_equal [2, 5, 8], query.to_a_single_column
+    query = @db.prepare_argv('select y from t')
+    assert_equal [2, 5, 8], query.to_a
   end
 
   def test_query_each
@@ -285,23 +324,24 @@ class QueryTest < MiniTest::Test
 
   def test_query_each_ary
     buf = []
-    @query.bind(1).each_ary { |r| buf << r }
+    @query.mode = :ary
+    @query.bind(1).each { |r| buf << r }
     assert_equal [[1, 2, 3]], buf
 
     # each should reset the stmt
     buf = []
-    @query.each_ary { |r| buf << r }
+    @query.each { |r| buf << r }
     assert_equal [[1, 2, 3]], buf
 
-    query = @db.prepare('select * from t')
+    query = @db.prepare_ary('select * from t')
     buf = []
-    query.each_ary { |r| buf << r }
+    query.each { |r| buf << r }
     assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], buf
   end
 
   def test_query_each_ary_without_block
-    query = @db.prepare('select * from t')
-    iter = query.each_ary
+    query = @db.prepare_ary('select * from t')
+    iter = query.each
     assert_kind_of Extralite::Iterator, iter
 
     buf = []
@@ -310,26 +350,54 @@ class QueryTest < MiniTest::Test
     assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], buf
   end
 
-  def test_query_each_single_column
-    query = @db.prepare('select x from t where x = ?')
+  def test_query_each_argv
     buf = []
-    query.bind(1).each_single_column { |r| buf << r }
+    @query.mode = :argv
+    @query.bind(1).each { |a, b, c| buf << [a, b, c] }
+    assert_equal [[1, 2, 3]], buf
+
+    # each should reset the stmt
+    buf = []
+    @query.each { |a, b, c| buf << [a, b, c] }
+    assert_equal [[1, 2, 3]], buf
+
+    query = @db.prepare_argv('select * from t')
+    buf = []
+    query.each { |a, b, c| buf << [a, b, c] }
+    assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], buf
+  end
+
+  def test_query_each_argv_without_block
+    query = @db.prepare_argv('select * from t')
+    iter = query.each
+    assert_kind_of Extralite::Iterator, iter
+
+    buf = []
+    v = iter.each { |a, b, c| buf << [a, b, c] }
+    assert_equal iter, v
+    assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], buf
+  end
+
+  def test_query_each_argv_single_column
+    query = @db.prepare_argv('select x from t where x = ?')
+    buf = []
+    query.bind(1).each { |r| buf << r }
     assert_equal [1], buf
 
     # each should reset the stmt
     buf = []
-    query.each_single_column { |r| buf << r }
+    query.each { |r| buf << r }
     assert_equal [1], buf
 
-    query = @db.prepare('select x from t')
+    query = @db.prepare_argv('select x from t')
     buf = []
-    query.each_single_column { |r| buf << r }
+    query.each { |r| buf << r }
     assert_equal [1, 4, 7], buf
   end
 
-  def test_query_each_single_column_without_block
-    query = @db.prepare('select x from t')
-    iter = query.each_single_column
+  def test_query_each_argv_single_column_without_block
+    query = @db.prepare_argv('select x from t')
+    iter = query.each
     assert_kind_of Extralite::Iterator, iter
 
     buf = []
@@ -416,33 +484,33 @@ class QueryTest < MiniTest::Test
   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
+    assert_equal 42, @db.prepare_argv('select :bar').bind(foo: 41, bar: 42).next
+    assert_equal 42, @db.prepare_argv('select :bar').bind('foo' => 41, 'bar' => 42).next
+    assert_equal 42, @db.prepare_argv('select ?8').bind(7 => 41, 8 => 42).next
+    assert_nil @db.prepare_argv('select :bar').bind(foo: 41).next
 
-    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(Foo.new => 42).next_single_column }
+    error = assert_raises(Extralite::ParameterError) { @db.prepare_argv('select ?').bind(Foo.new => 42).next }
     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 }
+    error = assert_raises(Extralite::ParameterError) { @db.prepare_argv('select ?').bind(%w[a b] => 42).next }
     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.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
+    assert_equal 41, @db.prepare_argv('select :foo').bind(value).next
+    assert_equal 42, @db.prepare_argv('select :bar').bind(value).next
+    assert_nil @db.prepare_argv('select :baz').bind(value).next
   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
+    foo_bar = Data.define(:':foo', :bar)
+    value = foo_bar.new(':foo': 41, bar: 42)
+    assert_equal 42, @db.prepare_argv('select :bar').bind(value).next
+    assert_nil @db.prepare_argv('select :baz').bind(value).next
   end
 
   def test_query_columns
@@ -451,10 +519,10 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_columns_with_parameterized_sql
-    q = @db.prepare('select * from t where z = :z')
+    q = @db.prepare_ary('select * from t where z = :z')
     q.bind(z: 9)
     assert_equal [:x, :y, :z], q.columns
-    assert_equal [[7, 8, 9]], q.to_a_ary
+    assert_equal [[7, 8, 9]], q.to_a
   end
 
   def test_query_close
@@ -664,16 +732,16 @@ class QueryTest < MiniTest::Test
       [[3, 3]]
     ], results
 
-    q = @db.prepare('update foo set b = ? returning *')
+    q = @db.prepare_ary('update foo set b = ? returning *')
 
-    results = q.batch_query_ary([42, 43])
+    results = q.batch_query([42, 43])
     assert_equal [
       [[1, 42], [2, 42], [3, 42]],
       [[1, 43], [2, 43], [3, 43]]
     ], results
 
     array = []
-    changes = q.batch_query_ary([44, 45]) do |rows|
+    changes = q.batch_query([44, 45]) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -695,16 +763,16 @@ class QueryTest < MiniTest::Test
       [[3, 3]]
     ], results
 
-    q = @db.prepare('update foo set b = ? returning *')
+    q = @db.prepare_ary('update foo set b = ? returning *')
 
-    results = q.batch_query_ary(42..43)
+    results = q.batch_query(42..43)
     assert_equal [
       [[1, 42], [2, 42], [3, 42]],
       [[1, 43], [2, 43], [3, 43]]
     ], results
 
     array = []
-    changes = q.batch_query_ary(44..45) do |rows|
+    changes = q.batch_query(44..45) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -726,10 +794,10 @@ class QueryTest < MiniTest::Test
       [[3, 3]]
     ], results
 
-    q = @db.prepare('update foo set b = ? returning *')
+    q = @db.prepare_ary('update foo set b = ? returning *')
 
     pr = parameter_source_proc([42, 43])
-    results = q.batch_query_ary(pr)
+    results = q.batch_query(pr)
     assert_equal [
       [[1, 42], [2, 42], [3, 42]],
       [[1, 43], [2, 43], [3, 43]]
@@ -737,7 +805,7 @@ class QueryTest < MiniTest::Test
 
     array = []
     pr = parameter_source_proc([44, 45])
-    changes = q.batch_query_ary(pr) do |rows|
+    changes = q.batch_query(pr) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -759,16 +827,16 @@ class QueryTest < MiniTest::Test
       [[3, 3]]
     ], results
 
-    q = @db.prepare('update foo set b = ? returning b * 10 + a')
+    q = @db.prepare_argv('update foo set b = ? returning b * 10 + a')
 
-    results = q.batch_query_single_column([42, 43])
+    results = q.batch_query([42, 43])
     assert_equal [
       [421, 422, 423],
       [431, 432, 433]
     ], results
 
     array = []
-    changes = q.batch_query_single_column([44, 45]) do |rows|
+    changes = q.batch_query([44, 45]) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -790,16 +858,16 @@ class QueryTest < MiniTest::Test
       [[3, 3]]
     ], results
 
-    q = @db.prepare('update foo set b = ? returning b * 10 + a')
+    q = @db.prepare_argv('update foo set b = ? returning b * 10 + a')
 
-    results = q.batch_query_single_column(42..43)
+    results = q.batch_query(42..43)
     assert_equal [
       [421, 422, 423],
       [431, 432, 433]
     ], results
 
     array = []
-    changes = q.batch_query_single_column(44..45) do |rows|
+    changes = q.batch_query(44..45) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -821,10 +889,10 @@ class QueryTest < MiniTest::Test
       [[3, 3]]
     ], results
 
-    q = @db.prepare('update foo set b = ? returning b * 10 + a')
+    q = @db.prepare_argv('update foo set b = ? returning b * 10 + a')
 
     pr = parameter_source_proc([42, 43])
-    results = q.batch_query_single_column(pr)
+    results = q.batch_query(pr)
     assert_equal [
       [421, 422, 423],
       [431, 432, 433]
@@ -832,7 +900,7 @@ class QueryTest < MiniTest::Test
 
     array = []
     pr = parameter_source_proc([44, 45])
-    changes = q.batch_query_single_column(pr) do |rows|
+    changes = q.batch_query(pr) do |rows|
       array << rows
     end
     assert_equal 6, changes
@@ -868,7 +936,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_eof
-    query = @db.prepare('select x from t')
+    query = @db.prepare_argv('select x from t')
     assert_equal false, query.eof?
 
     query.next
@@ -889,13 +957,13 @@ class QueryTest < MiniTest::Test
     query.next
     assert_equal false, query.eof?
 
-    assert_equal [1, 4, 7], query.to_a_single_column
+    assert_equal [1, 4, 7], query.to_a
     assert_equal true, query.eof?
   end
 
   def test_query_inspect
     q = @db.prepare('select x from t')
-    assert_match /^\#\<Extralite::Query:0x[0-9a-f]+ #{q.sql.inspect}\>$/, q.inspect
+    assert_match(/^\#\<Extralite::Query:0x[0-9a-f]+ #{q.sql.inspect}\>$/, q.inspect)
   end
 
   def test_query_clone
@@ -915,6 +983,175 @@ class QueryTest < MiniTest::Test
     assert_kind_of Extralite::Query, q2
     assert_equal @db, q2.database
     assert_equal q1.sql, q2.sql
-    refute_equal q1, q2
+    refute_same  q1, q2
+
+    q1 = @db.prepare_argv('select x from t')
+    q2 = q1.dup
+
+    assert_kind_of Extralite::Query, q2
+    assert_equal @db, q2.database
+    assert_equal q1.sql, q2.sql
+    refute_same  q1, q2
+    assert_equal :argv, q2.mode
+  end
+
+  def test_query_dup_with_transform
+    q1 = @db.prepare_ary('select x, y from t') { |a| a * 2 }
+    q2 = q1.dup
+
+    assert_equal [
+      [1, 2, 1, 2],
+      [4, 5, 4, 5],
+      [7, 8, 7, 8],
+    ], q2.to_a
+  end
+end
+
+class QueryTransformTest < Minitest::Test
+  def setup
+    @db = Extralite::Database.new(':memory:')
+    @db.query('create table t (a, b, c)')
+
+    @q1 = @db.prepare_argv('select c from t where a = ?')
+    @q2 = @db.prepare_argv('select c from t order by a')
+    
+    @q3 = @db.prepare('select * from t where a = ?')
+    @q4 = @db.prepare('select * from t order by a')
+
+    @q5 = @db.prepare('select a, b from t where a = ?')
+    @q6 = @db.prepare('select a, b 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_transform_hash
+    q = @q5.transform { |h| MyModel.new(h) }
+    assert_equal @q5, q
+
+    o = @q5.bind(1).next
+    assert_kind_of MyModel, o
+    assert_equal({ a: 1, b: 2 }, o.values)
+
+    o = @q5.bind(4).next
+    assert_kind_of MyModel, o
+    assert_equal({ a: 4, b: 5 }, o.values)
+
+    assert_equal [
+      [{ a: 1, b: 2 }],
+      [{ a: 4, b: 5 }]
+    ], @q5.batch_query([[1], [4]]).map { |a| a.map(&:values) }
+
+    @q6.transform { |h| MyModel.new(h) }
+    assert_equal [
+      { a: 1, b: 2 },
+      { a: 4, b: 5 }
+    ], @q6.to_a.map(&:values)
+
+    buf = []
+    @q6.each { |r| buf << r.values }
+    assert_equal [
+      { a: 1, b: 2 },
+      { a: 4, b: 5 }
+    ], buf
+  end
+
+  def test_transform_ary
+    @q5.mode = :ary
+    q = @q5.transform { |h| MyModel.new(h) }
+    assert_equal @q5, q
+
+    o = @q5.bind(1).next
+    assert_kind_of MyModel, o
+    assert_equal([1, 2], o.values)
+
+    o = @q5.bind(4).next
+    assert_kind_of MyModel, o
+    assert_equal([4, 5], o.values)
+
+    assert_equal [
+      [[1, 2]],
+      [[4, 5]]
+    ], @q5.batch_query([[1], [4]]).map { |a| a.map(&:values) }
+
+    @q6.mode = :ary
+    @q6.transform { |h| MyModel.new(h) }
+    assert_equal [
+      [1, 2],
+      [4, 5]
+    ], @q6.to_a.map(&:values)
+
+    buf = []
+    @q6.each { |r| buf << r.values }
+    assert_equal [
+      [1, 2],
+      [4, 5]
+    ], buf
+  end
+
+  def test_transform_argv_single_column
+    q = @q1.transform { |c| JSON.parse(c, symbolize_names: true) }
+    assert_equal @q1, q
+
+    assert_equal({ foo: 42, bar: 43 }, @q1.bind(1).next)
+    assert_equal({ foo: 45, bar: 46 }, @q1.bind(4).next)
+
+    assert_equal [
+      [{ foo: 42, bar: 43 }],
+      [{ foo: 45, bar: 46 }]
+    ], @q1.batch_query([[1], [4]])
+
+    @q2.transform { |c| JSON.parse(c, symbolize_names: true) }
+    assert_equal [
+      { foo: 42, bar: 43 },
+      { foo: 45, bar: 46 }
+    ], @q2.to_a
+
+    buf = []
+    @q2.each { |r| buf << r }
+    assert_equal [
+      { foo: 42, bar: 43 },
+      { foo: 45, bar: 46 }
+    ], buf
+  end
+
+  def test_transform_argv_multi_column
+    @q3.mode = :argv
+    q = @q3.transform { |a, b, c| { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
+    assert_equal @q3, q
+
+    assert_equal({ a: 1, b: 2, c: { foo: 42, bar: 43 }}, @q3.bind(1).next)
+    assert_equal({ a: 4, b: 5, c: { foo: 45, bar: 46 }}, @q3.bind(4).next)
+
+    assert_equal [
+      [{ a: 1, b: 2, c: { foo: 42, bar: 43 }}],
+      [{ a: 4, b: 5, c: { foo: 45, bar: 46 }}]
+    ], @q3.batch_query([[1], [4]])
+
+    @q4.mode = :argv
+    @q4.transform { |a, b, c| { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
+    assert_equal [
+      { a: 1, b: 2, c: { foo: 42, bar: 43 }},
+      { a: 4, b: 5, c: { foo: 45, bar: 46 }}
+    ], @q4.to_a
+
+    buf = []
+    @q4.each { |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
 end