extralite 2.4 → 2.5

data/test/issue-54.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "./lib/extralite"
+
+puts 'Connecting to database...'
+
+connection_1 = Extralite::Database.new("test.sqlite3")
+puts "#{connection_1} connected"
+connection_2 = Extralite::Database.new("test.sqlite3")
+connection_2.busy_timeout = 0
+puts "#{connection_2} connected"
+
+[connection_1, connection_2].each do |connection|
+  puts "#{connection} beginning transaction..."
+  connection.execute "begin immediate transaction"
+end
+
+[connection_1, connection_2].each do |connection|
+  puts "#{connection} rolling back transaction..."
+  connection.execute "rollback transaction"
+end

data/test/issue-59.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "./lib/extralite"
+require "benchmark"
+require "tempfile"
+require "fileutils"
+
+p sqlite_version: Extralite.sqlite3_version
+
+N = (ENV['N'] || 1000).to_i
+p N: N
+
+fn1 = '/tmp/db1'
+fn2 = '/tmp/db2'
+
+FileUtils.rm(fn1) rescue nil
+FileUtils.rm(fn2) rescue nil
+
+p fn1: fn1
+p fn2: fn2
+
+db1 = Extralite::Database.new fn1
+db1.execute "pragma journal_mode = wal;"
+db1.transaction do
+  db1.execute "create table t1 ( a integer primary key, b text );"
+  values = N.times.map { |i| "#{i}-#{rand(1000)}" }
+  db1.execute_multi "insert into t1 ( b ) values ( ? );", values
+
+  p count: db1.query_single_value("select count(*) from t1")
+  p some_rows: db1.query("select * from t1 limit 5")
+end
+
+db2 = Extralite::Database.new fn2
+db2.execute "pragma journal_mode = wal;"
+db2.execute "attach '#{fn1}' as db1;"
+db2.execute "create table t2 ( a integer primary key, b text );"
+
+p main_tables: db2.tables
+p db1_tables: db2.tables('db1')
+
+overall = Benchmark.realtime do
+  t1 = Thread.new do
+    time1 = Benchmark.realtime do
+      db2.execute "create unique index db1.t1_b_unique on t1 (b);"
+    end
+    p({ indexing: time1 })
+  end
+
+  t2 = Thread.new do
+    time2 = Benchmark.realtime do
+      (N / 10000).times do |i|
+        values = 10000.times.map { |i| "#{i}-#{rand(1000)}" }
+        db2.transaction do
+          db2.execute_multi "insert into main.t2 ( b ) values ( ? );", values
+        end
+      end
+    end
+    p({ inserting: time2 })
+    p count_t2: db2.query_single_value("select count(*) from main.t2")
+    p some_rows_t2: db2.query("select * from main.t2 limit 5")
+    end
+
+  t1.join
+  t2.join
+end
+
+p({ overall: overall })
+
+db1.close
+db2.close

data/test/test_database.rb

@@ -61,7 +61,7 @@ class DatabaseTest < MiniTest::Test
 
     r = @db.query_single_column('select y from t where x = 2')
     assert_equal [], r
-end
+  end
 
   def test_query_single_value
     r = @db.query_single_value('select z from t order by Z desc limit 1')
@@ -288,16 +288,38 @@ end
     assert_equal [], @db.tables
   end
 
+  def test_tables_with_db_name
+    assert_equal ['t'], @db.tables('main')
+
+    @db.query('create table foo (bar text)')
+    assert_equal ['t', 'foo'], @db.tables('main')
+
+    @db.query('drop table t')
+    assert_equal ['foo'], @db.tables('main')
+
+    @db.query('drop table foo')
+    assert_equal [], @db.tables('main')
+
+    assert_raises { @db.tables('foo') }
+
+    fn = Tempfile.new('extralite_test_tables_with_db_name').path
+    @db.execute "attach database '#{fn}' as foo"
+
+    assert_equal [], @db.tables('foo')
+    @db.execute 'create table foo.bar (x, y)'
+    assert_equal ['bar'], @db.tables('foo')
+  end
+
   def test_pragma
-    assert_equal [{journal_mode: 'memory'}], @db.pragma('journal_mode')
-    assert_equal [{synchronous: 2}], @db.pragma('synchronous')
+    assert_equal 'memory', @db.pragma('journal_mode')
+    assert_equal 2, @db.pragma('synchronous')
 
-    assert_equal [{schema_version: 1}], @db.pragma(:schema_version)
-    assert_equal [{recursive_triggers: 0}], @db.pragma(:recursive_triggers)
+    assert_equal 1, @db.pragma(:schema_version)
+    assert_equal 0, @db.pragma(:recursive_triggers)
 
     assert_equal [], @db.pragma(schema_version: 33, recursive_triggers: 1)
-    assert_equal [{schema_version: 33}], @db.pragma(:schema_version)
-    assert_equal [{recursive_triggers: 1}], @db.pragma(:recursive_triggers)
+    assert_equal 33, @db.pragma(:schema_version)
+    assert_equal 1, @db.pragma(:recursive_triggers)
   end
 
   def test_execute
@@ -311,7 +333,13 @@ end
     assert_equal [[1, 2, 3], [42, 5, 6]], @db.query_ary('select * from t order by x')
   end
 
-  def test_execute_multi
+  def test_execute_with_params_array
+    changes = @db.execute('update t set x = ? where z = ?', [42, 6])
+    assert_equal 1, changes
+    assert_equal [[1, 2, 3], [42, 5, 6]], @db.query_ary('select * from t order by x')
+  end
+
+  def test_batch_execute
     @db.query('create table foo (a, b, c)')
     assert_equal [], @db.query('select * from foo')
 
@@ -320,7 +348,7 @@ end
       ['4', 5, 6]
     ]
 
-    changes = @db.execute_multi('insert into foo values (?, ?, ?)', records)
+    changes = @db.batch_execute('insert into foo values (?, ?, ?)', records)
 
     assert_equal 2, changes
     assert_equal [
@@ -329,7 +357,7 @@ end
     ], @db.query('select * from foo')
   end
 
-  def test_execute_multi_single_values
+  def test_batch_execute_single_values
     @db.query('create table foo (bar)')
     assert_equal [], @db.query('select * from foo')
 
@@ -338,7 +366,7 @@ end
       'bye'
     ]
 
-    changes = @db.execute_multi('insert into foo values (?)', records)
+    changes = @db.batch_execute('insert into foo values (?)', records)
 
     assert_equal 2, changes
     assert_equal [
@@ -347,6 +375,314 @@ end
     ], @db.query('select * from foo')
   end
 
+  def test_batch_execute_with_each_interface
+    @db.query('create table foo (bar)')
+    assert_equal [], @db.query('select * from foo')
+
+    changes = @db.batch_execute('insert into foo values (?)', 1..3)
+
+    assert_equal 3, changes
+    assert_equal [
+      { bar: 1 },
+      { bar: 2 },
+      { bar: 3 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_batch_execute_with_proc
+    source = [42, 43, 44]
+
+    @db.query('create table foo (a)')
+    assert_equal [], @db.query('select * from foo')
+
+    pr = proc { source.shift }
+    changes = @db.batch_execute('insert into foo values (?)', pr)
+
+    assert_equal 3, changes
+    assert_equal [
+      { a: 42 },
+      { a: 43 },
+      { a: 44 }
+    ], @db.query('select * from foo')
+  end
+
+  def test_batch_query_with_array
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+    results = @db.batch_query('insert into foo values (?, ?, ?) returning *', data)
+    assert_equal [
+      [{ a: 1, b: '2', c: 3 }],
+      [{ a: '4', b: 5, c: 6 }]
+    ], results
+
+    results = @db.batch_query('update foo set c = ? returning *', [42, 43])
+    assert_equal [
+      [{ a: 1, b: '2', c: 42 }, { a: '4', b: 5, c: 42 }],
+      [{ a: 1, b: '2', c: 43 }, { a: '4', b: 5, c: 43 }]
+    ], results
+
+    array = []
+    changes = @db.batch_query('update foo set c = ? returning *', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 4, changes
+    assert_equal [
+      [{ a: 1, b: '2', c: 44 }, { a: '4', b: 5, c: 44 }],
+      [{ a: 1, b: '2', c: 45 }, { a: '4', b: 5, c: 45 }]
+    ], array
+  end
+
+  def test_batch_query_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    results = @db.batch_query('insert into foo (b) values (?) returning *', 11..13)
+    assert_equal [
+      [{ a: 1, b: 11 }],
+      [{ a: 2, b: 12 }],
+      [{ a: 3, b: 13 }]
+    ], results
+
+    results = @db.batch_query('update foo set b = ? returning *', [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 = @db.batch_query('update foo set b = ? returning *', [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_batch_query_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('insert into foo (b) values (?) returning *', pr)
+    assert_equal [
+      [{ a: 1, b: 5 }],
+      [{ a: 2, b: 4 }],
+      [{ a: 3, b: 3 }]
+    ], results
+
+    pr = parameter_source_proc([42, 43])
+    results = @db.batch_query('update foo set b = ? returning *', 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 = @db.batch_query('update foo set b = ? returning *', 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_batch_query_ary_with_array
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+    results = @db.batch_query_ary('insert into foo values (?, ?, ?) returning *', data)
+    assert_equal [
+      [[1, '2', 3]],
+      [['4', 5, 6]]
+    ], results
+
+    results = @db.batch_query_ary('update foo set c = ? returning *', [42, 43])
+    assert_equal [
+      [[1, '2', 42], ['4', 5, 42]],
+      [[1, '2', 43], ['4', 5, 43]]
+    ], results
+
+    array = []
+    changes = @db.batch_query_ary('update foo set c = ? returning *', [44, 45]) do |rows|
+      array << rows
+    end
+    assert_equal 4, changes
+    assert_equal [
+      [[1, '2', 44], ['4', 5, 44]],
+      [[1, '2', 45], ['4', 5, 45]]
+    ], array
+  end
+
+  def test_batch_query_ary_with_enumerable
+    @db.query('create table foo (a integer primary key, b)')
+    assert_equal [], @db.query('select * from foo')
+
+    results = @db.batch_query_ary('insert into foo (b) values (?) returning *', 11..13)
+    assert_equal [
+      [[1, 11]],
+      [[2, 12]],
+      [[3, 13]]
+    ], results
+
+    results = @db.batch_query_ary('update foo set b = ? returning *', [42, 43])
+    assert_equal [
+      [[1, 42], [2, 42], [3, 42]],
+      [[1, 43], [2, 43], [3, 43]]
+    ], results
+
+    array = []
+    changes = @db.batch_query_ary('update foo set b = ? returning *', [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_batch_query_ary_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_ary('insert into foo (b) values (?) returning *', pr)
+    assert_equal [
+      [[1, 5]],
+      [[2, 4]],
+      [[3, 3]]
+    ], results
+
+    pr = parameter_source_proc([42, 43])
+    results = @db.batch_query_ary('update foo set b = ? returning *', pr)
+    assert_equal [
+      [[1, 42], [2, 42], [3, 42]],
+      [[1, 43], [2, 43], [3, 43]]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = @db.batch_query_ary('update foo set b = ? returning *', 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_batch_query_single_column_with_array
+    @db.query('create table foo (a, b, c)')
+    assert_equal [], @db.query('select * from foo')
+
+    data = [
+      [1, '2', 3],
+      ['4', 5, 6]
+    ]
+    results = @db.batch_query_single_column('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])
+    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|
+      array << rows
+    end
+    assert_equal 4, changes
+    assert_equal [
+      [442, 445],
+      [452, 455]
+    ], array
+  end
+
+  def test_batch_query_single_column_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)
+    assert_equal [
+      [111],
+      [122],
+      [133]
+    ], results
+
+    results = @db.batch_query_single_column('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|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
+
+  def test_batch_query_single_column_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)
+    assert_equal [
+      [5],
+      [4],
+      [3]
+    ], results
+
+    pr = parameter_source_proc([42, 43])
+    results = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', pr)
+    assert_equal [
+      [421, 422, 423],
+      [431, 432, 433]
+    ], results
+
+    array = []
+    pr = parameter_source_proc([44, 45])
+    changes = @db.batch_query_single_column('update foo set b = ? returning b * 10 + a', pr) do |rows|
+      array << rows
+    end
+    assert_equal 6, changes
+    assert_equal [
+      [441, 442, 443],
+      [451, 452, 453]
+    ], array
+  end
+
   def test_interrupt
     t = Thread.new do
       sleep 0.5
@@ -477,6 +813,19 @@ end
     assert_equal true, db.read_only?
   end
 
+  def test_database_initialize_options
+    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)
+    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)
+  end
+
   def test_database_inspect
     db = Extralite::Database.new(':memory:')
     assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect
@@ -616,6 +965,32 @@ class ScenarioTest < MiniTest::Test
     assert_equal [1, 4, 7], result
   end
 
+  def test_concurrent_queries
+    @db.query('delete from t')
+    @db.gvl_release_threshold = 1
+    q1 = @db.prepare('insert into t values (?, ?, ?)')
+    q2 = @db.prepare('insert into t values (?, ?, ?)')
+
+    t1 = Thread.new do
+      data = (1..50).each_slice(10).map { |a| a.map { |i| [i, i + 1, i + 2] } }
+      data.each do |params|
+        q1.batch_execute(params)
+      end
+    end
+
+    t2 = Thread.new do
+      data = (51..100).each_slice(10).map { |a| a.map { |i| [i, i + 1, i + 2] } }
+      data.each do |params|
+        q2.batch_execute(params)
+      end
+    end
+
+    t1.join
+    t2.join
+
+    assert_equal (1..100).to_a, @db.query_single_column('select x from t order by x')
+  end
+
   def test_database_trace
     sqls = []
     @db.trace { |sql| sqls << sql }
@@ -773,4 +1148,88 @@ class GVLReleaseThresholdTest < Minitest::Test
     db.gvl_release_threshold = nil
     assert_equal 1000, db.gvl_release_threshold
   end
-end
+end
+
+class RactorTest < Minitest::Test
+  def test_ractor_simple
+    skip if SKIP_RACTOR_TESTS
+    
+    fn = Tempfile.new('extralite_test_database_in_ractor').path
+
+    r = Ractor.new do
+      path = receive
+      db = Extralite::Database.new(path)
+      i = receive
+      db.execute 'insert into foo values (?)', i
+    end
+
+    r << fn
+    db = Extralite::Database.new(fn)
+    db.execute 'create table foo (x)'
+    r << 42
+    r.take # wait for ractor to terminate
+
+    assert_equal 42, db.query_single_value('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
+
+    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()"
+      rescue => e
+        Ractor.yield e
+      end
+    end
+    sleep 0.1
+    db_creator = Ractor.new(db_receiver) do |db_receiver|
+      db = Extralite::Database.new(":memory:")
+      Ractor.yield db.object_id
+      db_receiver.send(db)
+      sleep 0.1
+      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
+  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)")
+    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
+        10.times do |i|
+          db_in_ractor.execute("insert into stress_test(a, b) values (#{ractor_number * 100 + i}, '#{random.rand}')")
+        end
+      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")
+      Ractor.yield count
+    end
+    count = final_check.take
+    assert_equal 100, count
+  end
+end