extralite 2.3 → 2.5

data/test/test_iterator.rb

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

data/test/test_query.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
+require 'date'
 
 class QueryTest < MiniTest::Test
   def setup
@@ -267,7 +268,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_each_without_block
-    query = @db.prepare('select * from t') 
+    query = @db.prepare('select * from t')
     iter = query.each
     assert_kind_of Extralite::Iterator, iter
 
@@ -294,7 +295,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_each_ary_without_block
-    query = @db.prepare('select * from t') 
+    query = @db.prepare('select * from t')
     iter = query.each_ary
     assert_kind_of Extralite::Iterator, iter
 
@@ -322,7 +323,7 @@ class QueryTest < MiniTest::Test
   end
 
   def test_query_each_single_column_without_block
-    query = @db.prepare('select x from t') 
+    query = @db.prepare('select x from t')
     iter = query.each_single_column
     assert_kind_of Extralite::Iterator, iter
 
@@ -375,6 +376,9 @@ class QueryTest < MiniTest::Test
   def test_query_parameter_binding_simple
     r = @db.prepare('select x, y, z from t where x = ?').bind(1).next
     assert_equal({ x: 1, y: 2, z: 3 }, r)
+
+    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(Date.today).next }
+    assert_equal error.message, 'Cannot bind parameter at position 1 of type Date'
   end
 
   def test_query_parameter_binding_with_index
@@ -404,6 +408,38 @@ class QueryTest < MiniTest::Test
     assert_equal({ x: 4, y: 5, z: 6 }, r)
   end
 
+  class Foo; end
+
+  def test_parameter_binding_from_hash
+    assert_equal 42, @db.prepare('select :bar').bind(foo: 41, bar: 42).next_single_column
+    assert_equal 42, @db.prepare('select :bar').bind('foo' => 41, 'bar' => 42).next_single_column
+    assert_equal 42, @db.prepare('select ?8').bind(7 => 41, 8 => 42).next_single_column
+    assert_nil @db.prepare('select :bar').bind(foo: 41).next_single_column
+
+    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(Foo.new => 42).next_single_column }
+    assert_equal error.message, 'Cannot bind parameter with a key of type QueryTest::Foo'
+
+    error = assert_raises(Extralite::ParameterError) { @db.prepare('select ?').bind(%w[a b] => 42).next_single_column }
+    assert_equal error.message, 'Cannot bind parameter with a key of type Array'
+  end
+
+  def test_parameter_binding_from_struct
+    foo_bar = Struct.new(:":foo", :bar)
+    value = foo_bar.new(41, 42)
+    assert_equal 41, @db.prepare('select :foo').bind(value).next_single_column
+    assert_equal 42, @db.prepare('select :bar').bind(value).next_single_column
+    assert_nil @db.prepare('select :baz').bind(value).next_single_column
+  end
+
+  def test_parameter_binding_from_data_class
+    skip "Data isn't supported in Ruby < 3.2" if RUBY_VERSION < '3.2'
+
+    foo_bar = Data.define(:":foo", :bar)
+    value = foo_bar.new(":foo": 41, bar: 42)
+    assert_equal 42, @db.prepare('select :bar').bind(value).next_single_column
+    assert_nil @db.prepare('select :baz').bind(value).next_single_column
+  end
+
   def test_query_columns
     r = @db.prepare("select 'abc' as a, 'def' as b").columns
     assert_equal [:a, :b], r
@@ -442,7 +478,25 @@ class QueryTest < MiniTest::Test
     assert_equal [[1, 2, 3], [4, 5, 6], [42, 8, 9]], @db.query_ary('select * from t order by z')
   end
 
-  def test_query_execute_multi
+  def test_query_execute_with_mixed_params
+    @db.execute 'delete from t'
+    q = @db.prepare('insert into t values (?, ?, ?)')
+    
+    q.execute(1, [2], 3)
+    q.execute([4, 5], 6)
+    q.execute([7], 8, [9])
+
+    assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], @db.query_ary('select * from t order by z')
+  end
+
+  def test_query_chverons
+    q = @db.prepare('update t set x = ? where z = ?')
+    assert_equal q, (q << [42, 9])
+    assert_equal [[1, 2, 3], [4, 5, 6], [42, 8, 9]], @db.query_ary('select * from t order by z')
+  end
+
+
+  def test_query_batch_execute
     @db.query('create table foo (a, b, c)')
     assert_equal [], @db.query('select * from foo')
 
@@ -452,14 +506,336 @@ class QueryTest < MiniTest::Test
     ]
 
     p = @db.prepare('insert into foo values (?, ?, ?)')
-    changes = p.execute_multi(records)
+    changes = p.batch_execute(records)
 
     assert_equal 2, changes
     assert_equal [
       { a: 1, b: '2', c: 3 },
       { a: '4', b: 5, c: 6 }
     ], @db.query('select * from foo')
-  end  
+  end
+
+  def test_query_batch_execute_with_each_interface
+    @db.query('create table foo (a)')
+    assert_equal [], @db.query('select * from foo')
+
+    p = @db.prepare('insert into foo values (?)')
+    changes = p.batch_execute(1..3)
+
+    assert_equal 3, changes
+    assert_equal [
+      { a: 1 },
+      { a: 2 },
+      { a: 3 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_query_batch_execute_with_proc
+    source = [42, 43, 44]
+
+    @db.query('create table foo (a)')
+    assert_equal [], @db.query('select * from foo')
+
+    p = @db.prepare('insert into foo values (?)')
+    pr = proc { source.shift }
+    changes = p.batch_execute(pr)
+
+    assert_equal 3, changes
+    assert_equal [
+      { a: 42 },
+      { a: 43 },
+      { a: 44 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_query_batch_query_with_array
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning *')
+
+    results = q.batch_query([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 = q.batch_query([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 test_query_batch_query_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning *')
+
+    results = q.batch_query(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 = q.batch_query(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_query_batch_query_with_proc
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning *')
+
+    pr = parameter_source_proc([42, 43])
+    results = q.batch_query(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 = q.batch_query(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_query_batch_query_ary_with_array
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning *')
+
+    results = q.batch_query_ary([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|
+      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_query_batch_query_ary_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning *')
+
+    results = q.batch_query_ary(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|
+      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_query_batch_query_ary_with_proc
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning *')
+
+    pr = parameter_source_proc([42, 43])
+    results = q.batch_query_ary(pr)
+    assert_equal [
+      [[1, 42], [2, 42], [3, 42]],
+      [[1, 43], [2, 43], [3, 43]]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = q.batch_query_ary(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_query_batch_query_single_column_with_array
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning b * 10 + a')
+
+    results = q.batch_query_single_column([42, 43])
+    assert_equal [
+      [421, 422, 423],
+      [431, 432, 433]
+    ], results
+
+    array = []
+    changes = q.batch_query_single_column([44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
+
+  def test_query_batch_query_single_column_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning b * 10 + a')
+
+    results = q.batch_query_single_column(42..43)
+    assert_equal [
+      [421, 422, 423],
+      [431, 432, 433]
+    ], results
+
+    array = []
+    changes = q.batch_query_single_column(44..45) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
+
+  def test_query_batch_query_single_column_with_proc
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [5, 4, 3]
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', data)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    q = @db.prepare('update foo set b = ? returning b * 10 + a')
+
+    pr = parameter_source_proc([42, 43])
+    results = q.batch_query_single_column(pr)
+    assert_equal [
+      [421, 422, 423],
+      [431, 432, 433]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = q.batch_query_single_column(pr) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
 
   def test_query_status
     assert_equal 0, @query.status(Extralite::SQLITE_STMTSTATUS_RUN)
@@ -516,4 +892,24 @@ class QueryTest < MiniTest::Test
     q = @db.prepare('select x from t')
     assert_match /^\#\<Extralite::Query:0x[0-9a-f]+ #{q.sql.inspect}\>$/, q.inspect
   end
+
+  def test_query_clone
+    q1 = @db.prepare('select x from t')
+    q2 = q1.clone
+
+    assert_kind_of Extralite::Query, q2
+    assert_equal @db, q2.database
+    assert_equal q1.sql, q2.sql
+    refute_equal q1, q2
+  end
+
+  def test_query_dup
+    q1 = @db.prepare('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_equal q1, q2
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '2.3'
+  version: '2.5'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-12 00:00:00.000000000 Z
+date: 2024-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -88,12 +88,15 @@ extensions:
 extra_rdoc_files:
 - README.md
 files:
+- ".editorconfig"
 - ".github/FUNDING.yml"
+- ".github/workflows/test-bundle.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
+- Gemfile-bundle
 - Gemfile.lock
 - LICENSE
 - README.md
@@ -118,7 +121,11 @@ files:
 - lib/sequel/adapters/extralite.rb
 - test/extensions/text.dylib
 - test/extensions/text.so
+- test/fixtures/image.png
 - test/helper.rb
+- test/issue-38.rb
+- test/issue-54.rb
+- test/issue-59.rb
 - test/perf_ary.rb
 - test/perf_hash.rb
 - test/perf_prepared.rb
@@ -148,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="