extralite-bundle 2.14 → 3.0.0

data/gemspec.rb

@@ -15,11 +15,11 @@ def common_spec(s)
   s.rdoc_options = ['--title', 'Extralite', '--main', 'README.md']
   s.extra_rdoc_files = ['README.md']
   s.require_paths = ['lib']
-  s.required_ruby_version = '>= 3.2'
+  s.required_ruby_version = '>= 3.4'
 
   s.add_development_dependency  'rake-compiler',        '1.3.1'
-  s.add_development_dependency  'minitest',             '6.0.1'
+  s.add_development_dependency  'minitest'
   s.add_development_dependency  'simplecov',            '0.22.0'
   s.add_development_dependency  'yard',                 '0.9.38'
-  s.add_development_dependency  'sequel',               '5.100.0'
+  s.add_development_dependency  'sequel',               '5.105.0'
 end

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '2.14'
+  VERSION = '3.0.0'
 end

data/lib/extralite.rb

@@ -236,7 +236,7 @@ module Extralite
     # @return [Any] the given block's return value
     def transaction(mode = :immediate)
       abort = false
-      execute "begin #{mode} transaction"    
+      execute "begin #{mode} transaction"
       yield self
     rescue => e
       abort = true
@@ -296,6 +296,10 @@ module Extralite
       raise Rollback
     end
 
+    def quote(str)
+      str.gsub("'", "''")
+    end
+
     private
 
     def pragma_set(values)
@@ -311,4 +315,101 @@ module Extralite
   class Query
     alias_method :execute_multi, :batch_execute
   end
+
+  class Transform
+    alias_method :orig_initialize, :initialize
+
+    # call-seq:
+    #   Extralite::Transform.new(literal_spec) -> transform
+    #   Extralite::Transform.new { dsl_spec } -> transform
+    #
+    # Initializes a new transform with with the given spec. The spec may be
+    # expressed as a hash containing the columns and any nested entities, or as a
+    # block with the transform DSL.
+    #
+    #     # literal transform spec
+    #     transform = Extralite::Transform.new(
+    #       columns: {
+    #         id: { type: :integer, identity: true },
+    #         content: { type: :text },
+    #         author: {
+    #           type: :relation,
+    #           columns: {
+    #             id: { type: :integer, identity: true },
+    #             name: { type: :text },
+    #           }
+    #         }
+    #       }
+    #     )
+    #
+    #     # DSL spec
+    #     transform = Extralite::Transform.new do
+    #       {
+    #         id:       integer.identity,
+    #         content:  text,
+    #         author: {
+    #           id:     integer.identity,
+    #           name:   text
+    #         }
+    #       }
+    #     end
+    #
+    # @param spec [Hash, nil] literal spec
+    # @param block [Proc, nil] DSL spec
+    # @return [void]
+    def initialize(spec = nil, &block)
+      return orig_initialize(spec) if spec
+      raise "No spec given" if !block
+
+      orig_initialize(dsl_to_spec(block))
+    end
+
+    private
+
+    class DSLContext
+      attr_reader :hash
+
+      def initialize(hash = {})
+        @hash = hash
+      end
+
+      def auto      = mutate(type: nil)
+      def integer   = mutate(type: :integer)
+      def float     = mutate(type: :float)
+      def text      = mutate(type: :text)
+      def bool      = mutate(type: :bool)
+      def json      = mutate(type: :json)
+      def identity  = mutate(identity: true)
+
+    private
+      def mutate(opts)
+        DSLContext.new(@hash.merge(opts))
+      end
+    end
+
+    def dsl_to_spec(block)
+      intermediate = DSLContext.new.instance_eval(&block)
+      dsl_intermediate_to_spec(intermediate)
+    end
+
+    def dsl_intermediate_to_spec(intermediate)
+      columns = intermediate.each_with_object({}) do |(k, v), h|
+        h[k] = dsl_translate_intermediate_value(v)
+      end
+      { type: :relation, columns: }
+    end
+
+    def dsl_translate_intermediate_value(v)
+      case v
+      when DSLContext
+        v.hash
+      when Hash
+        dsl_intermediate_to_spec(v)
+      when Array
+        [dsl_intermediate_to_spec(v[0])]
+      else
+        raise Extralite::Error, 'Invalid transform spec'
+      end
+    end
+  end
 end

data/test/perf_array.rb

@@ -4,7 +4,7 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'sqlite3', '2.6.0'
+  gem 'sqlite3', '2.9.5'
   gem 'extralite', path: '..'
   gem 'benchmark-ips'
 end

data/test/perf_hash.rb

@@ -7,7 +7,7 @@ require 'bundler/inline'
 gemfile do
   source 'https://rubygems.org'
   gem 'extralite', path: '..'
-  gem 'sqlite3', '2.6.0'
+  gem 'sqlite3', '2.9.5'
   gem 'benchmark-ips'
 end
 

data/test/perf_hash_prepared.rb

@@ -5,7 +5,7 @@ require 'bundler/inline'
 gemfile do
   source 'https://rubygems.org'
   gem 'extralite', path: '..'
-  gem 'sqlite3', '2.6.0'
+  gem 'sqlite3', '2.9.5'
   gem 'benchmark-ips'
 end
 
@@ -18,7 +18,7 @@ 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')

data/test/perf_splat.rb

@@ -4,7 +4,7 @@ require 'bundler/inline'
 
 gemfile do
   source 'https://rubygems.org'
-  gem 'sqlite3', '2.6.0'
+  gem 'sqlite3', '2.9.5'
   gem 'extralite', path: '..'
   gem 'benchmark-ips'
 end

data/test/perf_transform.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Run on Ruby 3.3 with YJIT enabled
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'extralite', path: '..'
+  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}"
+
+$extralite_db = Extralite::Database.new(DB_PATH, gvl_release_threshold: -1)
+
+def prepare_database(count)
+  $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 run_normal(count)
+  results = $extralite_db.query('select * from foo')
+  raise unless results.size == count
+end
+
+@transform = Extralite::Transform.new {
+  { a: integer, b: text }
+}
+
+def run_transform(count)
+  results = $extralite_db.query(@transform, 'select * from foo')
+  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("normal")    { run_normal(c) }
+    x.report("transform") { run_transform(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_database.rb

@@ -302,6 +302,15 @@ class DatabaseTest < Minitest::Test
 
     r = @db.query_single_splat("select reverse('abcd')")
     assert_equal 'dcba', r
+
+    e = nil
+    begin
+      @db.execute("select load_extension('/extensions/foo')")
+    rescue => e
+    end
+
+    assert_kind_of Extralite::SQLError, e
+    assert_equal 'not authorized', e.message
   end
 
   def test_tables
@@ -341,7 +350,7 @@ class DatabaseTest < Minitest::Test
 
   def test_pragma
     assert_equal 'memory', @db.pragma('journal_mode')
-    assert_equal 2, @db.pragma('synchronous')
+    assert_equal 1, @db.pragma('synchronous')
 
     assert_equal 1, @db.pragma(:schema_version)
     assert_equal 0, @db.pragma(:recursive_triggers)
@@ -866,14 +875,17 @@ class DatabaseTest < Minitest::Test
     db = Extralite::Database.new(':memory:', gvl_release_threshold: 23)
     assert_equal 23, db.gvl_release_threshold
 
-    fn = Tempfile.new('extralite_test_database_initialize_options_wal').path
-    db = Extralite::Database.new(fn, wal: true)
+    fn = Tempfile.new('extralite_test_database_initialize_modern').path
+    db = Extralite::Database.new(fn)
     assert_equal 'wal', db.pragma(:journal_mode)
     assert_equal 1, db.pragma(:synchronous)
+    assert_equal 1, db.pragma(:foreign_keys)
 
-    fn = Tempfile.new('extralite_test_database_initialize_options_pragma').path
-    db = Extralite::Database.new(fn, pragma: { application_id: 42 })
-    assert_equal 42, db.pragma(:application_id)
+    fn = Tempfile.new('extralite_test_database_initialize_legacy').path
+    db = Extralite::Database.new(fn, legacy: true)
+    assert_equal 'delete', db.pragma(:journal_mode)
+    assert_equal 2, db.pragma(:synchronous)
+    assert_equal 0, db.pragma(:foreign_keys)
   end
 
   def test_database_inspect
@@ -1052,7 +1064,7 @@ class DatabaseTest < Minitest::Test
   def test_wal_checkpoint
     fn = Tempfile.new('extralite_test_wal_checkpoint').path
 
-    db = Extralite::Database.new(fn, wal: true)
+    db = Extralite::Database.new(fn)
 
     db.execute 'create table t (x, y, z)'
     rows = (1..1000).map { [rand, rand, rand] }
@@ -1121,12 +1133,27 @@ class DatabaseTest < Minitest::Test
     assert_nil result
     assert_equal [7, 8], @db.query_splat('SELECT x FROM t ORDER BY x')
   end
+
+  def test_quote
+    assert_equal '"abc', @db.quote('"abc')
+    assert_equal "''abc''def", @db.quote("'abc'def")
+
+    assert_equal "'abc'def", @db.query_single_splat("select '#{@db.quote("'abc'def")}'")
+  end
+
+  def test_cache_flush
+    assert_equal @db, @db.cache_flush
+  end
+
+  def test_release_memory
+    assert_equal @db, @db.release_memory
+  end
 end
 
 class ScenarioTest < Minitest::Test
   def setup
     @fn = Tempfile.new('extralite_scenario_test').path
-    @db = Extralite::Database.new(@fn)
+    @db = Extralite::Database.new(@fn, legacy: true)
     @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)')
@@ -1136,7 +1163,7 @@ class ScenarioTest < Minitest::Test
   def test_concurrent_transactions
     done = false
     t = Thread.new do
-      db = Extralite::Database.new(@fn)
+      db = Extralite::Database.new(@fn, legacy: true)
       db.query 'begin immediate'
       sleep 0.01 until done
 
@@ -1806,7 +1833,7 @@ class RactorTest < Minitest::Test
     assert_equal [10] * 10, buf
 
     final_check = Ractor.new(fn) do |rfn|
-      rdb = Extralite::Database.new(rfn, wal: true)
+      rdb = Extralite::Database.new(rfn)
       count = rdb.query_single_splat('select count(*) from stress_test')
       Ractor.yield count
     end

data/test/test_query.rb

@@ -27,7 +27,7 @@ class QueryTest < Minitest::Test
   def test_mode
     query = @db.prepare('select 1')
     assert_equal :hash, query.mode
-    
+
     query.mode = :splat
     assert_equal :splat, query.mode
 
@@ -554,7 +554,7 @@ class QueryTest < Minitest::Test
   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])
@@ -1014,7 +1014,7 @@ class QueryTransformTest < Minitest::Test
 
     @q1 = @db.prepare_splat('select c from t where a = ?')
     @q2 = @db.prepare_splat('select c from t order by a')
-    
+
     @q3 = @db.prepare('select * from t where a = ?')
     @q4 = @db.prepare('select * from t order by a')
 
@@ -1038,8 +1038,7 @@ class QueryTransformTest < Minitest::Test
   end
 
   def test_transform_hash
-    q = @q5.transform { |h| MyModel.new(h) }
-    assert_equal @q5, q
+    @q5.transform = ->(h) { MyModel.new(h) }
 
     o = @q5.bind(1).next
     assert_kind_of MyModel, o
@@ -1054,7 +1053,7 @@ class QueryTransformTest < Minitest::Test
       [{ a: 4, b: 5 }]
     ], @q5.batch_query([[1], [4]]).map { |a| a.map(&:values) }
 
-    @q6.transform { |h| MyModel.new(h) }
+    @q6.transform = ->(h) { MyModel.new(h) }
     assert_equal [
       { a: 1, b: 2 },
       { a: 4, b: 5 }
@@ -1070,8 +1069,7 @@ class QueryTransformTest < Minitest::Test
 
   def test_transform_array
     @q5.mode = :array
-    q = @q5.transform { |h| MyModel.new(h) }
-    assert_equal @q5, q
+    @q5.transform = ->(h) { MyModel.new(h) }
 
     o = @q5.bind(1).next
     assert_kind_of MyModel, o
@@ -1087,7 +1085,7 @@ class QueryTransformTest < Minitest::Test
     ], @q5.batch_query([[1], [4]]).map { |a| a.map(&:values) }
 
     @q6.mode = :array
-    @q6.transform { |h| MyModel.new(h) }
+    @q6.transform = ->(h) { MyModel.new(h) }
     assert_equal [
       [1, 2],
       [4, 5]
@@ -1102,8 +1100,7 @@ class QueryTransformTest < Minitest::Test
   end
 
   def test_transform_splat_single_column
-    q = @q1.transform { |c| JSON.parse(c, symbolize_names: true) }
-    assert_equal @q1, q
+    @q1.transform = ->(c) { JSON.parse(c, symbolize_names: true) }
 
     assert_equal({ foo: 42, bar: 43 }, @q1.bind(1).next)
     assert_equal({ foo: 45, bar: 46 }, @q1.bind(4).next)
@@ -1113,7 +1110,7 @@ class QueryTransformTest < Minitest::Test
       [{ foo: 45, bar: 46 }]
     ], @q1.batch_query([[1], [4]])
 
-    @q2.transform { |c| JSON.parse(c, symbolize_names: true) }
+    @q2.transform = ->(c) { JSON.parse(c, symbolize_names: true) }
     assert_equal [
       { foo: 42, bar: 43 },
       { foo: 45, bar: 46 }
@@ -1129,8 +1126,7 @@ class QueryTransformTest < Minitest::Test
 
   def test_transform_splat_multi_column
     @q3.mode = :splat
-    q = @q3.transform { |a, b, c| { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
-    assert_equal @q3, q
+    @q3.transform = ->(a, b, c) { { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
 
     assert_equal({ a: 1, b: 2, c: { foo: 42, bar: 43 }}, @q3.bind(1).next)
     assert_equal({ a: 4, b: 5, c: { foo: 45, bar: 46 }}, @q3.bind(4).next)
@@ -1141,7 +1137,7 @@ class QueryTransformTest < Minitest::Test
     ], @q3.batch_query([[1], [4]])
 
     @q4.mode = :splat
-    @q4.transform { |a, b, c| { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
+    @q4.transform = ->(a, b, c) { { a: a, b: b, c: JSON.parse(c, symbolize_names: true) } }
     assert_equal [
       { a: 1, b: 2, c: { foo: 42, bar: 43 }},
       { a: 4, b: 5, c: { foo: 45, bar: 46 }}