extralite 2.5 → 2.6

data/test/perf_ary.rb

@@ -15,26 +15,25 @@ require 'fileutils'
 DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
 puts "DB_PATH = #{DB_PATH.inspect}"
 
+$sqlite3_db = SQLite3::Database.new(DB_PATH)
+$extralite_db = Extralite::Database.new(DB_PATH, gvl_release_threshold: -1)
 
 def prepare_database(count)
   db = Extralite::Database.new(DB_PATH)
-  db.query('create table if not exists foo ( a integer primary key, b text )')
-  db.query('delete from foo')
-  db.query('begin')
-  count.times { db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
-  db.query('commit')
-  db.close
+  $extralite_db.query('create table if not exists foo ( a integer primary key, b text )')
+  $extralite_db.query('delete from foo')
+  $extralite_db.query('begin')
+  count.times { $extralite_db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
+  $extralite_db.query('commit')
 end
 
 def sqlite3_run(count)
-  db = SQLite3::Database.new(DB_PATH)
-  results = db.execute('select * from foo')
+  results = $sqlite3_db.execute('select * from foo')
   raise unless results.size == count
 end
 
 def extralite_run(count)
-  db = Extralite::Database.new(DB_PATH)
-  results = db.query_ary('select * from foo')
+  results = $extralite_db.query('select * from foo')
   raise unless results.size == count
 end
 
@@ -43,12 +42,15 @@ end
 
   prepare_database(c)
 
-  Benchmark.ips do |x|
-    x.config(:time => 3, :warmup => 1)
+  bm = Benchmark.ips do |x|
+    x.config(:time => 5, :warmup => 2)
 
     x.report("sqlite3") { sqlite3_run(c) }
     x.report("extralite") { extralite_run(c) }
 
     x.compare!
   end
+  puts;
+  bm.entries.each { |e| puts "#{e.label}: #{(e.ips * c).round.to_i} rows/s" }
+  puts;
 end

data/test/perf_hash.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Run on Ruby 3.3 with YJIT enabled
+
 require 'bundler/inline'
 
 gemfile do
@@ -15,40 +17,40 @@ require 'fileutils'
 DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
 puts "DB_PATH = #{DB_PATH.inspect}"
 
+$sqlite3_db = SQLite3::Database.new(DB_PATH, results_as_hash: true)
+$extralite_db = Extralite::Database.new(DB_PATH, gvl_release_threshold: -1)
+
 def prepare_database(count)
-  db = Extralite::Database.new(DB_PATH)
-  db.query('create table if not exists foo ( a integer primary key, b text )')
-  db.query('delete from foo')
-  db.query('begin')
-  count.times { db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
-  db.query('commit')
-  db.close
+  $extralite_db.query('create table if not exists foo ( a integer primary key, b text )')
+  $extralite_db.query('delete from foo')
+  $extralite_db.query('begin')
+  count.times { $extralite_db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
+  $extralite_db.query('commit')
 end
 
 def sqlite3_run(count)
-  db = SQLite3::Database.new(DB_PATH, :results_as_hash => true)
-  results = db.execute('select * from foo')
+  results = $sqlite3_db.execute('select * from foo')
   raise unless results.size == count
 end
 
 def extralite_run(count)
-  db = Extralite::Database.new(DB_PATH)
-  results = db.query('select * from foo')
+  results = $extralite_db.query('select * from foo')
   raise unless results.size == count
 end
 
 [10, 1000, 100000].each do |c|
   puts "Record count: #{c}"
-
   prepare_database(c)
 
-  Benchmark.ips do |x|
-    x.config(:time => 3, :warmup => 1)
+  bm = Benchmark.ips do |x|
+    x.config(:time => 5, :warmup => 2)
 
     x.report("sqlite3") { sqlite3_run(c) }
     x.report("extralite") { extralite_run(c) }
 
     x.compare!
   end
-  puts; puts; 
+  puts;
+  bm.entries.each { |e| puts "#{e.label}: #{(e.ips * c).round.to_i} rows/s" }
+  puts;
 end

data/test/perf_hash_prepared.rb

@@ -0,0 +1,58 @@
+# 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-#{Time.now.to_i}-#{rand(10000)}.db"
+puts "DB_PATH = #{DB_PATH.inspect}"
+
+def prepare_database(count)
+  $sqlite3_db = SQLite3::Database.new(DB_PATH, results_as_hash: true)
+  $extralite_db = Extralite::Database.new(DB_PATH, gvl_release_threshold: -1)
+    
+  $extralite_db.query('create table if not exists foo ( a integer primary key, b text )')
+  $extralite_db.query('delete from foo')
+  $extralite_db.query('begin')
+  count.times { $extralite_db.query('insert into foo (b) values (?)', "hello#{rand(1000)}" )}
+  $extralite_db.query('commit')
+
+  $sqlite3_stmt = $sqlite3_db.prepare('select * from foo')
+  $extralite_q = $extralite_db.prepare('select * from foo')
+end
+
+def sqlite3_run(count)
+  results = $sqlite3_stmt.execute
+  raise unless results.to_a.size == count
+end
+
+def extralite_run(count)
+  results = $extralite_q.to_a
+  raise unless results.size == count
+end
+
+[10, 1000, 100000].each do |c|
+  puts "Record count: #{c}"
+
+  prepare_database(c)
+
+  bm = Benchmark.ips do |x|
+    x.config(:time => 5, :warmup => 2)
+
+    x.report("sqlite3") { sqlite3_run(c) }
+    x.report("extralite") { extralite_run(c) }
+
+    x.compare!
+  end
+  puts;
+  bm.entries.each { |e| puts "#{e.label}: #{(e.ips * c).round.to_i} rows/s" }
+  puts;
+end

data/test/test_changeset.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+require 'date'
+require 'tempfile'
+
+class ChangesetTest < MiniTest::Test
+  def setup
+    @db = Extralite::Database.new(':memory:')
+    skip if !@db.respond_to?(:track_changes)
+
+    @db.execute('create table if not exists t (x integer primary key, y, z)')
+  end
+
+  def test_each
+    changeset = Extralite::Changeset.new
+
+    changeset.track(@db, [nil]) do
+      @db.execute('insert into t values (1, 2, 3)')
+    end
+    changes = []
+    changeset.each { |*o| changes << o }
+    assert_equal [
+      [:insert, 't', nil, [1, 2, 3]]
+    ], changes
+
+
+    changeset.track(@db, [nil]) do
+      @db.execute('update t set y = 22 where x = 1')
+    end
+    changes = []
+    changeset.each { |*o| changes << o }
+    assert_equal [
+      [:update, 't', [1, 2, nil], [nil, 22, nil]]
+    ], changes
+
+
+    changeset.track(@db, [nil]) do
+      @db.execute('delete from t where x = 1')
+    end
+    changes = []
+    changeset.each { |*o| changes << o }
+    assert_equal [
+      [:delete, 't', [1, 22, 3], nil]
+    ], changes
+  end
+
+  def test_to_a
+    changeset = Extralite::Changeset.new
+
+    changeset.track(@db, [nil]) do
+      @db.execute('insert into t values (1, 2, 3)')
+      @db.execute('insert into t values (4, 5, 6)')
+    end
+    assert_equal [
+      [:insert, 't', nil, [1, 2, 3]],
+      [:insert, 't', nil, [4, 5, 6]]
+    ], changeset.to_a
+
+
+    changeset.track(@db, [nil]) do
+      @db.execute('update t set y = 22.22 where z < 10')
+    end
+    assert_equal [
+      [:update, 't', [1, 2, nil], [nil, 22.22, nil]],
+      [:update, 't', [4, 5, nil], [nil, 22.22, nil]]
+    ], changeset.to_a
+
+
+    changeset.track(@db, [nil]) do
+      @db.execute('delete from t where x = 1')
+    end
+    assert_equal [
+      [:delete, 't', [1, 22.22, 3], nil]
+    ], changeset.to_a
+  end
+
+  def test_apply
+    changeset = Extralite::Changeset.new
+
+    changeset.track(@db, [:t]) do
+      @db.execute('insert into t values (1, 2, 3)')
+      @db.execute('insert into t values (4, 5, 6)')
+    end
+
+    db2 = Extralite::Database.new(':memory:')
+    db2.execute('create table if not exists t (x integer primary key, y, z)')
+
+    changeset.apply(db2)
+
+    assert_equal [
+      { x: 1, y: 2, z: 3 },
+      { x: 4, y: 5, z: 6 }
+    ], db2.query('select * from t')
+  end
+
+  def test_invert
+    changeset = Extralite::Changeset.new
+
+    changeset.track(@db, [:t]) do
+      @db.execute('insert into t values (1, 2, 3)')
+      @db.execute('insert into t values (4, 5, 6)')
+    end
+
+    db2 = Extralite::Database.new(':memory:')
+    db2.execute('create table if not exists t (x integer primary key, y, z)')
+
+    changeset.apply(db2)
+
+    assert_equal [
+      { x: 1, y: 2, z: 3 },
+      { x: 4, y: 5, z: 6 }
+    ], db2.query('select * from t')
+
+    db2.execute('insert into t values (7, 8, 9)')
+    inverted = changeset.invert
+
+    assert_kind_of Extralite::Changeset, inverted
+    refute_equal inverted, changeset
+
+    assert_equal [
+      [:delete, 't', [1, 2, 3], nil],
+      [:delete, 't', [4, 5, 6], nil],
+    ], inverted.to_a
+
+    inverted.apply(@db)
+    assert_equal [], @db.query('select * from t')
+  end
+
+  def test_blob
+    changeset = Extralite::Changeset.new
+    assert_equal "", changeset.to_blob
+
+    changeset.track(@db, [:t]) do
+      @db.execute('insert into t values (1, 2, 3)')
+      @db.execute('insert into t values (4, 5, 6)')
+    end
+
+    blob = changeset.to_blob
+    assert_kind_of String, blob
+    assert_equal Encoding::ASCII_8BIT, blob.encoding
+    assert !blob.empty?
+
+    c2 = Extralite::Changeset.new
+    c2.load(blob)
+    assert_equal c2.to_blob, blob
+
+    assert_equal [
+      [:insert, 't', nil, [1, 2, 3]],
+      [:insert, 't', nil, [4, 5, 6]]
+    ], c2.to_a
+  end
+
+  def test_empty_blob
+    changeset = Extralite::Changeset.new
+    changeset.load('')
+
+    assert_raises(Extralite::Error) { changeset.to_a }
+  end
+end

data/test/test_database.rb

@@ -896,6 +896,53 @@ 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_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
@@ -1053,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 (
@@ -1148,6 +1195,159 @@ 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(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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extralite
 version: !ruby/object:Gem::Version
-  version: '2.5'
+  version: '2.6'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-16 00:00:00.000000000 Z
+date: 2024-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -103,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
@@ -128,8 +129,9 @@ files:
 - 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
@@ -162,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !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