extralite 2.4 → 2.6

data/test/test_query.rb

@@ -37,6 +37,11 @@ class QueryTest < MiniTest::Test
     results = q.bind(foo: 'c').to_a_ary
 
     assert_equal [['a', 'b', 'c']], results
+
+    # try again with the same parameters
+    results = q.to_a_ary
+
+    assert_equal [['a', 'b', 'c']], results
   end
 
   def test_query_next
@@ -478,7 +483,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')
 
@@ -488,7 +511,7 @@ 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 [
@@ -497,6 +520,328 @@ class QueryTest < MiniTest::Test
     ], @db.query('select * from foo')
   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)
     @query.to_a
@@ -552,4 +897,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.4'
+  version: '2.6'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-24 00:00:00.000000000 Z
+date: 2024-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -90,6 +90,7 @@ extra_rdoc_files:
 files:
 - ".editorconfig"
 - ".github/FUNDING.yml"
+- ".github/workflows/test-bundle.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".yardopts"
@@ -102,6 +103,7 @@ files:
 - Rakefile
 - TODO.md
 - bin/update_sqlite_source
+- ext/extralite/changeset.c
 - ext/extralite/common.c
 - ext/extralite/database.c
 - ext/extralite/extconf-bundle.rb
@@ -123,10 +125,13 @@ files:
 - 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
+- test/perf_hash_prepared.rb
 - test/run.rb
+- test/test_changeset.rb
 - test/test_database.rb
 - test/test_extralite.rb
 - test/test_iterator.rb
@@ -152,14 +157,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Extra-lightweight SQLite3 wrapper for Ruby

data/test/perf_prepared.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/inline'
-
-gemfile do
-  source 'https://rubygems.org'
-  gem 'extralite', path: '..'
-  gem 'sqlite3'
-  gem 'benchmark-ips'
-end
-
-require 'benchmark/ips'
-require 'fileutils'
-
-DB_PATH = '/tmp/extralite_sqlite3_perf.db'
-
-def prepare_database(count)
-  FileUtils.rm(DB_PATH) rescue nil
-  db = Extralite::Database.new(DB_PATH)
-  db.query('create table foo ( a integer primary key, b text )')
-  db.query('begin')
-  count.times { db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
-  db.query('commit')
-end
-
-def sqlite3_prepare
-  db = SQLite3::Database.new(DB_PATH, :results_as_hash => true)
-  db.prepare('select * from foo')
-end
-
-def sqlite3_run(stmt, count)
-  # db = SQLite3::Database.new(DB_PATH, :results_as_hash => true)
-  results = stmt.execute.to_a
-  raise unless results.size == count
-end
-
-def extralite_prepare
-  db = Extralite::Database.new(DB_PATH)
-  db.prepare('select * from foo')
-end
-
-def extralite_run(query, count)
-  # db = Extralite::Database.new(DB_PATH)
-  results = query.to_a
-  raise unless results.size == count
-end
-
-[10, 1000, 100000].each do |c|
-  puts; puts; puts "Record count: #{c}"
-
-  prepare_database(c)
-
-  sqlite3_stmt = sqlite3_prepare
-  extralite_stmt = extralite_prepare
-
-  Benchmark.ips do |x|
-    x.config(:time => 3, :warmup => 1)
-
-    x.report("sqlite3")   { sqlite3_run(sqlite3_stmt, c) }
-    x.report("extralite") { extralite_run(extralite_stmt, c) }
-
-    x.compare!
-  end
-end