extralite-bundle 2.3 → 2.4

data/ext/sqlite3/sqlite3.h

@@ -146,9 +146,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.44.0"
-#define SQLITE_VERSION_NUMBER 3044000
-#define SQLITE_SOURCE_ID      "2023-11-01 11:23:50 17129ba1ff7f0daf37100ee82d507aef7827cf38de1866e2633096ae6ad81301"
+#define SQLITE_VERSION        "3.44.2"
+#define SQLITE_VERSION_NUMBER 3044002
+#define SQLITE_SOURCE_ID      "2023-11-24 11:41:44 ebead0e7230cd33bcec9f95d2183069565b9e709bf745c9b5db65cc0cbf92c0f"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -5573,13 +5573,27 @@ SQLITE_API int sqlite3_create_window_function(
 ** </dd>
 **
 ** [[SQLITE_SUBTYPE]] <dt>SQLITE_SUBTYPE</dt><dd>
-** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call
+** The SQLITE_SUBTYPE flag indicates to SQLite that a function might call
 ** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
-** Specifying this flag makes no difference for scalar or aggregate user
-** functions. However, if it is not specified for a user-defined window
-** function, then any sub-types belonging to arguments passed to the window
-** function may be discarded before the window function is called (i.e.
-** sqlite3_value_subtype() will always return 0).
+** This flag instructs SQLite to omit some corner-case optimizations that
+** might disrupt the operation of the [sqlite3_value_subtype()] function,
+** causing it to return zero rather than the correct subtype().
+** SQL functions that invokes [sqlite3_value_subtype()] should have this
+** property.  If the SQLITE_SUBTYPE property is omitted, then the return
+** value from [sqlite3_value_subtype()] might sometimes be zero even though
+** a non-zero subtype was specified by the function argument expression.
+**
+** [[SQLITE_RESULT_SUBTYPE]] <dt>SQLITE_RESULT_SUBTYPE</dt><dd>
+** The SQLITE_RESULT_SUBTYPE flag indicates to SQLite that a function might call
+** [sqlite3_result_subtype()] to cause a sub-type to be associated with its
+** result.
+** Every function that invokes [sqlite3_result_subtype()] should have this
+** property.  If it does not, then the call to [sqlite3_result_subtype()]
+** might become a no-op if the function is used as term in an
+** [expression index].  On the other hand, SQL functions that never invoke
+** [sqlite3_result_subtype()] should avoid setting this property, as the
+** purpose of this property is to disable certain optimizations that are
+** incompatible with subtypes.
 ** </dd>
 ** </dl>
 */
@@ -5587,6 +5601,7 @@ SQLITE_API int sqlite3_create_window_function(
 #define SQLITE_DIRECTONLY       0x000080000
 #define SQLITE_SUBTYPE          0x000100000
 #define SQLITE_INNOCUOUS        0x000200000
+#define SQLITE_RESULT_SUBTYPE   0x001000000
 
 /*
 ** CAPI3REF: Deprecated Functions
@@ -5783,6 +5798,12 @@ SQLITE_API int sqlite3_value_encoding(sqlite3_value*);
 ** information can be used to pass a limited amount of context from
 ** one SQL function to another.  Use the [sqlite3_result_subtype()]
 ** routine to set the subtype for the return value of an SQL function.
+**
+** Every [application-defined SQL function] that invoke this interface
+** should include the [SQLITE_SUBTYPE] property in the text
+** encoding argument when the function is [sqlite3_create_function|registered].
+** If the [SQLITE_SUBTYPE] property is omitted, then sqlite3_value_subtype()
+** might return zero instead of the upstream subtype in some corner cases.
 */
 SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*);
 
@@ -5913,14 +5934,22 @@ SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
 ** <li> ^(when sqlite3_set_auxdata() is invoked again on the same
 **       parameter)^, or
 ** <li> ^(during the original sqlite3_set_auxdata() call when a memory
-**      allocation error occurs.)^ </ul>
+**      allocation error occurs.)^
+** <li> ^(during the original sqlite3_set_auxdata() call if the function
+**      is evaluated during query planning instead of during query execution,
+**      as sometimes happens with [SQLITE_ENABLE_STAT4].)^ </ul>
 **
-** Note the last bullet in particular.  The destructor X in
+** Note the last two bullets in particular.  The destructor X in
 ** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
 ** sqlite3_set_auxdata() interface even returns.  Hence sqlite3_set_auxdata()
 ** should be called near the end of the function implementation and the
 ** function implementation should not make any use of P after
-** sqlite3_set_auxdata() has been called.
+** sqlite3_set_auxdata() has been called.  Furthermore, a call to
+** sqlite3_get_auxdata() that occurs immediately after a corresponding call
+** to sqlite3_set_auxdata() might still return NULL if an out-of-memory
+** condition occurred during the sqlite3_set_auxdata() call or if the
+** function is being evaluated during query planning rather than during
+** query execution.
 **
 ** ^(In practice, auxiliary data is preserved between function calls for
 ** function parameters that are compile-time constants, including literal
@@ -6194,6 +6223,20 @@ SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);
 ** higher order bits are discarded.
 ** The number of subtype bytes preserved by SQLite might increase
 ** in future releases of SQLite.
+**
+** Every [application-defined SQL function] that invokes this interface
+** should include the [SQLITE_RESULT_SUBTYPE] property in its
+** text encoding argument when the SQL function is
+** [sqlite3_create_function|registered].  If the [SQLITE_RESULT_SUBTYPE]
+** property is omitted from the function that invokes sqlite3_result_subtype(),
+** then in some cases the sqlite3_result_subtype() might fail to set
+** the result subtype.
+**
+** If SQLite is compiled with -DSQLITE_STRICT_SUBTYPE=1, then any
+** SQL function that invokes the sqlite3_result_subtype() interface
+** and that does not have the SQLITE_RESULT_SUBTYPE property will raise
+** an error.  Future versions of SQLite might enable -DSQLITE_STRICT_SUBTYPE=1
+** by default.
 */
 SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int);
 

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.3'
+  VERSION = '2.4'
 end

data/lib/extralite.rb

@@ -25,6 +25,10 @@ module Extralite
   class InterruptError < Error
   end
 
+  # An exception raised when an Extralite doesn't know how to bind a parameter to a query
+  class ParameterError < Error
+  end
+
   # An SQLite database
   class Database
     # @!visibility private
@@ -52,6 +56,29 @@ module Extralite
       value.is_a?(Hash) ? pragma_set(value) : pragma_get(value)
     end
 
+    # Starts a transaction and runs the given block. If an exception is raised
+    # in the block, the transaction is rolled back. Otherwise, the transaction
+    # is commited after running the block.
+    #
+    #     db.transaction do
+    #       db.execute('insert into foo values (1, 2, 3)')
+    #       raise if db.query_single_value('select x from bar') > 42
+    #     end
+    #
+    # @param mode [Symbol, String] transaction mode (deferred, immediate or exclusive). Defaults to immediate.
+    # @return [Any] the given block's return value
+    def transaction(mode = :immediate)
+      execute "begin #{mode} transaction"
+    
+      abort = false
+      yield self
+    rescue
+      abort = true
+      raise
+    ensure
+      execute(abort ? 'rollback' : 'commit')
+    end
+
     private
 
     def pragma_set(values)

data/test/helper.rb

@@ -5,3 +5,5 @@ require 'extralite'
 require 'minitest/autorun'
 
 puts "sqlite3 version: #{Extralite.sqlite3_version}"
+
+IS_LINUX = RUBY_PLATFORM =~ /linux/

data/test/issue-38.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "./lib/extralite"
+require "benchmark"
+
+# Setup
+
+File.delete("benchmark.sqlite3") if File.exist?("benchmark.sqlite3")
+
+POOL_SIZE = 10
+
+EXTRALITE_CONNECTIONS = POOL_SIZE.times.map do
+  db = Extralite::Database.new("benchmark.sqlite3")
+  db.execute("PRAGMA journal_mode = WAL")
+  db.execute("PRAGMA synchronous = NORMAL")
+  db.execute("PRAGMA journal_size_limit = 64000000")
+  db.execute("PRAGMA mmap_size = 128000000")
+  db.execute("PRAGMA cache_size = 2000")
+  db.execute("PRAGMA busy_timeout = 5000")
+  db
+end
+
+SQLITE3_CONNECTIONS = POOL_SIZE.times.map do
+  db = SQLite3::Database.new("benchmark.sqlite3")
+  db.execute("PRAGMA journal_mode = WAL")
+  db.execute("PRAGMA synchronous = NORMAL")
+  db.execute("PRAGMA journal_size_limit = 64000000")
+  db.execute("PRAGMA mmap_size = 128000000")
+  db.execute("PRAGMA cache_size = 2000")
+  db.execute("PRAGMA busy_timeout = 5000")
+  db
+end
+
+EXTRALITE_CONNECTIONS[0].execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, created_at TEXT, updated_at TEXT) STRICT")
+insert_statement = EXTRALITE_CONNECTIONS[0].prepare("INSERT INTO users (name, created_at, updated_at) VALUES (?, ?, ?)")
+1000.times do
+  insert_statement.execute("John Doe", Time.now.iso8601, Time.now.iso8601)
+end
+
+# Benchmark variations
+
+THREAD_COUNTS = [1, 2, 4, 8]
+LIMITS = [10, 100, 1000]
+CLIENTS = %w[extralite sqlite3]
+
+# Benchmark
+
+GC.disable
+Benchmark.bm do |x|
+  LIMITS.each do |limit|
+    THREAD_COUNTS.each do |thread_count|
+      CLIENTS.each do |client|
+        GC.start
+
+        x.report("#{client.rjust('extralite'.length)} - limit: #{limit}, threads: #{thread_count}") do
+          threads = thread_count.times.map do |thread_number|
+            Thread.new do
+              start = Time.now
+              if client == "extralite"
+                1_000.times do
+                  records = EXTRALITE_CONNECTIONS[thread_number].query_ary("SELECT * FROM users LIMIT #{limit}")
+                  raise "Expected #{limit} but got #{length}" unless records.length == limit
+                end
+              else
+                1_000.times do
+                  records = SQLITE3_CONNECTIONS[thread_number].query("SELECT * FROM users LIMIT #{limit}").entries
+                  raise "Expected #{limit} but got #{length}" unless records.length == limit
+                end
+              end
+            end
+          end
+          threads.each(&:join)
+        end
+      end
+      puts
+    end
+  end
+end
+GC.enable

data/test/perf_ary.rb

@@ -12,15 +12,18 @@ end
 require 'benchmark/ips'
 require 'fileutils'
 
-DB_PATH = '/tmp/extralite_sqlite3_perf.db'
+DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
+puts "DB_PATH = #{DB_PATH.inspect}"
+
 
 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('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
 end
 
 def sqlite3_run(count)

data/test/perf_hash.rb

@@ -12,15 +12,17 @@ end
 require 'benchmark/ips'
 require 'fileutils'
 
-DB_PATH = '/tmp/extralite_sqlite3_perf.db'
+DB_PATH = "/tmp/extralite_sqlite3_perf-#{Time.now.to_i}-#{rand(10000)}.db"
+puts "DB_PATH = #{DB_PATH.inspect}"
 
 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('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
 end
 
 def sqlite3_run(count)
@@ -36,7 +38,7 @@ def extralite_run(count)
 end
 
 [10, 1000, 100000].each do |c|
-  puts; puts; puts "Record count: #{c}"
+  puts "Record count: #{c}"
 
   prepare_database(c)
 
@@ -48,4 +50,5 @@ end
 
     x.compare!
   end
+  puts; puts; 
 end

data/test/test_database.rb

@@ -2,6 +2,9 @@
 
 require_relative 'helper'
 
+require 'date'
+require 'tempfile'
+
 class DatabaseTest < MiniTest::Test
   def setup
     @db = Extralite::Database.new(':memory:')
@@ -123,6 +126,9 @@ end
 
     r = @db.query('select x, y, z from t where z = ?', 6)
     assert_equal [{ x: 4, y: 5, z: 6 }], r
+
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', Date.today) }
+    assert_equal error.message, 'Cannot bind parameter at position 1 of type Date'
   end
 
   def test_parameter_binding_with_index
@@ -152,6 +158,94 @@ end
     assert_equal [{ x: 4, y: 5, z: 6 }], r
   end
 
+  class Foo; end
+
+  def test_parameter_binding_from_hash
+    assert_equal 42, @db.query_single_value('select :bar', foo: 41, bar: 42)
+    assert_equal 42, @db.query_single_value('select :bar', 'foo' => 41, 'bar' => 42)
+    assert_equal 42, @db.query_single_value('select ?8', 7 => 41, 8 => 42)
+    assert_nil @db.query_single_value('select :bar', foo: 41)
+
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', Foo.new => 42) }
+    assert_equal error.message, 'Cannot bind parameter with a key of type DatabaseTest::Foo'
+
+    error = assert_raises(Extralite::ParameterError) { @db.query_single_value('select ?', %w[a b] => 42) }
+    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.query_single_value('select :foo', value)
+    assert_equal 42, @db.query_single_value('select :bar', value)
+    assert_nil @db.query_single_value('select :baz', value)
+  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.query_single_value('select :bar', value)
+    assert_nil @db.query_single_value('select :baz', value)
+  end
+
+  def test_parameter_binding_for_blobs
+    sql = 'SELECT typeof(data) AS type, data FROM blobs WHERE ROWID = ?'
+    blob_path = File.expand_path('fixtures/image.png', __dir__)
+    @db.execute('CREATE TABLE blobs (data BLOB)')
+
+    # it's a string, not a blob
+    @db.execute('INSERT INTO blobs VALUES (?)', 'Hello, 世界!')
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'text', result[:type]
+    assert_equal Encoding::UTF_8, result[:data].encoding
+
+    data = File.binread(blob_path)
+    @db.execute('INSERT INTO blobs VALUES (?)', data)
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'blob', result[:type]
+    assert_equal data, result[:data]
+
+    data = (+'Hello, 世界!').force_encoding(Encoding::ASCII_8BIT)
+    @db.execute('INSERT INTO blobs VALUES (?)', data)
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'blob', result[:type]
+    assert_equal Encoding::ASCII_8BIT, result[:data].encoding
+    assert_equal 'Hello, 世界!', result[:data].force_encoding(Encoding::UTF_8)
+
+    data = Extralite::Blob.new('Hello, 世界!')
+    @db.execute('INSERT INTO blobs VALUES (?)', data)
+    result = @db.query_single_row(sql, @db.last_insert_rowid)
+    assert_equal 'blob', result[:type]
+    assert_equal Encoding::ASCII_8BIT, result[:data].encoding
+    assert_equal 'Hello, 世界!', result[:data].force_encoding(Encoding::UTF_8)
+  end
+
+  def test_parameter_binding_for_simple_types
+    assert_nil @db.query_single_value('select ?', nil)
+
+    # 32-bit integers
+    assert_equal -2** 31, @db.query_single_value('select ?', -2**31)
+    assert_equal 2**31 - 1, @db.query_single_value('select ?', 2**31 - 1)
+
+    # 64-bit integers
+    assert_equal -2 ** 63, @db.query_single_value('select ?', -2 ** 63)
+    assert_equal 2**63 - 1, @db.query_single_value('select ?', 2**63 - 1)
+
+    # floats
+    assert_equal Float::MIN, @db.query_single_value('select ?', Float::MIN)
+    assert_equal Float::MAX, @db.query_single_value('select ?', Float::MAX)
+
+    # boolean
+    assert_equal 1, @db.query_single_value('select ?', true)
+    assert_equal 0, @db.query_single_value('select ?', false)
+
+    # strings and symbols
+    assert_equal 'foo', @db.query_single_value('select ?', 'foo')
+    assert_equal 'foo', @db.query_single_value('select ?', :foo)
+  end
+
   def test_value_casting
     r = @db.query_single_value("select 'abc'")
     assert_equal 'abc', r
@@ -293,7 +387,7 @@ end
   end
 
   def test_database_busy_timeout
-    fn = "/tmp/extralite-#{rand(10000)}.db"
+    fn = Tempfile.new('extralite_test_database_busy_timeout').path
     db1 = Extralite::Database.new(fn)
     db2 = Extralite::Database.new(fn)
 
@@ -388,17 +482,77 @@ end
     assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect
   end
 
+  def test_database_inspect_on_closed_database
+    db = Extralite::Database.new(':memory:')
+    assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ :memory:\>$/, db.inspect
+    db.close
+    assert_match /^\#\<Extralite::Database:0x[0-9a-f]+ \(closed\)\>$/, db.inspect
+  end
+
   def test_string_encoding
     db = Extralite::Database.new(':memory:')
     v = db.query_single_value("select 'foo'")
     assert_equal 'foo', v
     assert_equal 'UTF-8', v.encoding.name
   end
+
+  def test_database_transaction_commit
+    path = Tempfile.new('extralite_test_database_transaction_commit').path
+    db1 = Extralite::Database.new(path)
+    db2 = Extralite::Database.new(path)
+
+    db1.execute('create table foo(x)')
+    assert_equal ['foo'], db1.tables
+    assert_equal ['foo'], db2.tables
+
+    q1 = Queue.new
+    q2 = Queue.new
+    th = Thread.new do
+      db1.transaction do
+        assert_equal true, db1.transaction_active?
+        db1.execute('insert into foo values (42)')
+        q1 << true
+        q2.pop
+      end
+      assert_equal false, db1.transaction_active?
+    end
+    q1.pop
+    # transaction not yet committed
+    assert_equal false, db2.transaction_active?
+    assert_equal [], db2.query('select * from foo')
+
+    q2 << true
+    th.join
+    # transaction now committed
+    assert_equal [{ x: 42 }], db2.query('select * from foo')
+  end
+
+  def test_database_transaction_rollback
+    db = Extralite::Database.new(':memory:')
+    db.execute('create table foo(x)')
+
+    assert_equal [], db.query('select * from foo')
+
+    exception = nil
+    begin
+      db.transaction do
+        db.execute('insert into foo values (42)')
+        raise 'bar'
+      end
+    rescue => e
+      exception = e
+    end
+
+    assert_equal [], db.query('select * from foo')
+    assert_kind_of RuntimeError, exception
+    assert_equal 'bar', exception.message
+  end
 end
 
 class ScenarioTest < MiniTest::Test
   def setup
-    @db = Extralite::Database.new('/tmp/extralite.db')
+    @fn = Tempfile.new('extralite_scenario_test').path
+    @db = Extralite::Database.new(@fn)
     @db.query('create table if not exists t (x,y,z)')
     @db.query('delete from t')
     @db.query('insert into t values (1, 2, 3)')
@@ -408,7 +562,7 @@ class ScenarioTest < MiniTest::Test
   def test_concurrent_transactions
     done = false
     t = Thread.new do
-      db = Extralite::Database.new('/tmp/extralite.db')
+      db = Extralite::Database.new(@fn)
       db.query 'begin immediate'
       sleep 0.01 until done
 
@@ -465,6 +619,7 @@ class ScenarioTest < MiniTest::Test
   def test_database_trace
     sqls = []
     @db.trace { |sql| sqls << sql }
+    GC.start
 
     @db.query('select 1')
     assert_equal ['select 1'], sqls
@@ -515,10 +670,107 @@ class BackupTest < MiniTest::Test
   end
 
   def test_backup_with_fn
-    tmp_fn = "/tmp/#{rand(86400)}.db"
+    tmp_fn = Tempfile.new('extralite_test_backup_with_fn').path
     @src.backup(tmp_fn)
 
     db = Extralite::Database.new(tmp_fn)
     assert_equal [[1, 2, 3], [4, 5, 6]], db.query_ary('select * from t')
   end
 end
+
+class GVLReleaseThresholdTest < Minitest::Test
+  def setup
+    @sql = <<~SQL
+      WITH RECURSIVE r(i) AS (
+        VALUES(0)
+        UNION ALL
+        SELECT i FROM r
+        LIMIT 3000000
+      )
+      SELECT i FROM r WHERE i = 1;
+    SQL
+  end
+
+  def test_default_gvl_release_threshold
+    db = Extralite::Database.new(':memory:')
+    assert_equal 1000, db.gvl_release_threshold
+  end
+
+  def test_gvl_always_release
+    skip if !IS_LINUX
+
+    delays = []
+    running = true
+    t1 = Thread.new do
+      last = Time.now
+      while running
+        sleep 0.1
+        now = Time.now
+        delays << (now - last)
+        last = now
+      end
+    end
+    t2 = Thread.new do
+      db = Extralite::Database.new(':memory:')
+      db.gvl_release_threshold = 1
+      db.query(@sql)
+    ensure
+      running = false
+    end
+    t2.join
+    t1.join
+
+    assert delays.size > 4
+    assert_equal 0, delays.select { |d| d > 0.15 }.size
+  end
+
+  def test_gvl_always_hold
+    skip if !IS_LINUX
+
+    delays = []
+    running = true
+
+    signal = Queue.new
+    db = Extralite::Database.new(':memory:')
+    db.gvl_release_threshold = 0
+
+    t1 = Thread.new do
+      last = Time.now
+      while running
+        signal << true
+        sleep 0.1
+        now = Time.now
+        delays << (now - last)
+        last = now
+      end
+    end
+
+    t2 = Thread.new do
+      signal.pop
+      db.query(@sql)
+    ensure
+      running = false
+    end
+    t2.join
+    t1.join
+
+    assert delays.size >= 1
+    assert delays.first > 0.2
+  end
+
+  def test_gvl_mode_get_set
+    db = Extralite::Database.new(':memory:')
+    assert_equal 1000, db.gvl_release_threshold
+
+    db.gvl_release_threshold = 42
+    assert_equal 42, db.gvl_release_threshold
+
+    db.gvl_release_threshold = 0
+    assert_equal 0, db.gvl_release_threshold
+
+    assert_raises(ArgumentError) { db.gvl_release_threshold = :foo }
+
+    db.gvl_release_threshold = nil
+    assert_equal 1000, db.gvl_release_threshold
+  end
+end

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 } }