extralite-bundle 1.26 → 2.0

data/lib/extralite/sqlite3_constants.rb

@@ -46,7 +46,7 @@ module Extralite
   SQLITE_LIMIT_VARIABLE_NUMBER        =  9
   SQLITE_LIMIT_TRIGGER_DEPTH          = 10
   SQLITE_LIMIT_WORKER_THREADS         = 11
-  
+
   SQLITE_OK                           =   0
   SQLITE_ERROR                        =   1
   SQLITE_INTERNAL                     =   2

data/lib/extralite/version.rb

@@ -1,4 +1,4 @@
 module Extralite
   # Extralite version
-  VERSION = '1.26'
+  VERSION = '2.0'
 end

data/lib/sequel/adapters/extralite.rb

@@ -11,24 +11,20 @@ require 'sequel/adapters/shared/sqlite'
 module Sequel
   # Extralite Sequel adapter
   module Extralite
-    # @!visibility private
     FALSE_VALUES = (%w'0 false f no n'.each(&:freeze) + [0]).freeze
 
     blob = Object.new
-    # @!visibility private
     def blob.call(s)
       Sequel::SQL::Blob.new(s.to_s)
     end
 
     boolean = Object.new
-    # @!visibility private
     def boolean.call(s)
       s = s.downcase if s.is_a?(String)
       !FALSE_VALUES.include?(s)
     end
 
     date = Object.new
-    # @!visibility private
     def date.call(s)
       case s
       when String
@@ -43,26 +39,22 @@ module Sequel
     end
 
     integer = Object.new
-    # @!visibility private
     def integer.call(s)
       s.to_i
     end
 
     float = Object.new
-    # @!visibility private
     def float.call(s)
       s.to_f
     end
 
     numeric = Object.new
-    # @!visibility private
     def numeric.call(s)
       s = s.to_s unless s.is_a?(String)
       BigDecimal(s) rescue s
     end
 
     time = Object.new
-    # @!visibility private
     def time.call(s)
       case s
       when String
@@ -77,7 +69,7 @@ module Sequel
       end
     end
 
-    # Hash with string keys and callable values for converting SQLite types.
+    # Hash with string keys and callable values for converting SQLITE types.
     SQLITE_TYPES = {}
     {
       %w'date' => date,
@@ -92,10 +84,6 @@ module Sequel
     end
     SQLITE_TYPES.freeze
 
-    # @!visibility private
-    USE_EXTENDED_RESULT_CODES = false
-    
-    # Database adapter for Sequel
     class Database < Sequel::Database
       include ::Sequel::SQLite::DatabaseMethods
       
@@ -112,7 +100,12 @@ module Sequel
       # The conversion procs to use for this database
       attr_reader :conversion_procs
 
-      # Connect to the database. Since SQLite is a file based database,
+      def initialize(opts = OPTS)
+        super
+        @allow_regexp = typecast_value_boolean(opts[:setup_regexp_function])
+      end
+
+      # Connect to the database. Since Extralite is a file based database,
       # available options are limited:
       #
       # :database :: database name (filename or ':memory:' or file: URI)
@@ -123,16 +116,19 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
         opts[:database] = ':memory:' if blank_object?(opts[:database])
-        # sqlite3_opts = {}
-        # sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
-        db = ::Extralite::Database.new(opts[:database].to_s)#, sqlite3_opts)
+        # db opts may be used in a future version of Extralite
+        db_opts = {}
+        db_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
+        db = ::Extralite::Database.new(opts[:database].to_s)
         # db.busy_timeout(typecast_value_integer(opts.fetch(:timeout, 5000)))
 
-        # if USE_EXTENDED_RESULT_CODES
-        #   db.extended_result_codes = true
-        # end
-        
         connection_pragmas.each{|s| log_connection_yield(s, db){db.query(s)}}
+
+        if typecast_value_boolean(opts[:setup_regexp_function])
+          db.create_function("regexp", 2) do |func, regexp_str, string|
+            func.result = Regexp.new(regexp_str).match(string) ? 1 : 0
+          end
+        end
         
         class << db
           attr_reader :prepared_statements
@@ -142,9 +138,14 @@ module Sequel
         db
       end
 
+      # Whether this Database instance is setup to allow regexp matching.
+      # True if the :setup_regexp_function option was passed when creating the Database.
+      def allow_regexp?
+        @allow_regexp
+      end
+
       # Disconnect given connections from the database.
       def disconnect_connection(c)
-        c.prepared_statements.each_value{|v| v.first.close }
         c.close
       end
       
@@ -163,24 +164,22 @@ module Sequel
       # table while a prepared statement that references it still exists.
       def execute_ddl(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
-          conn.prepared_statements.values.each{|cps, s| cps.close}
-          conn.prepared_statements.clear
+          # conn.prepared_statements.values.each{|cps, s| cps.close}
+          # conn.prepared_statements.clear
           super
         end
       end
       
-      # @!visibility private
       def execute_insert(sql, opts=OPTS)
         _execute(:insert, sql, opts)
       end
       
-      # @!visibility private
       def freeze
         @conversion_procs.freeze
         super
       end
 
-      # Handle Integer and Float arguments, since SQLite can store timestamps as integers and floats.
+      # Handle Integer and Float arguments, since Extralite can store timestamps as integers and floats.
       def to_application_timestamp(s)
         case s
         when String
@@ -202,32 +201,31 @@ module Sequel
         set_integer_booleans
       end
       
-      # Yield an available connection. Rescue any Extralite::Error and turn
-      # them into DatabaseErrors.
+      # Yield an available connection.  Rescue
+      # any Extralite::Errors and turn them into DatabaseErrors.
       def _execute(type, sql, opts, &block)
-        begin
-          synchronize(opts[:server]) do |conn|
-            return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
-            log_args = opts[:arguments]
-            args = {}
-            opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v) }
-            case type
-            when :select
-              log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
-            when :insert
-              log_connection_yield(sql, conn, log_args){conn.query(sql, args)}
-              conn.last_insert_rowid
-            when :update
-              log_connection_yield(sql, conn, log_args){conn.query(sql, args)}
-              conn.changes
-            end
+        synchronize(opts[:server]) do |conn|
+          return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
+          log_args = opts[:arguments]
+          args = {}
+          opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
+          case type
+          when :select
+            query = conn.prepare(sql, args)
+            log_connection_yield(sql, conn, log_args){block.call(query.each, query.columns)}
+          when :insert
+            log_connection_yield(sql, conn, log_args){conn.query(sql, args)}
+            conn.last_insert_rowid
+          when :update
+            log_connection_yield(sql, conn, log_args){conn.query(sql, args)}
+            conn.changes
           end
-        rescue ::Extralite::Error => e
-          raise_error(e)
         end
+      rescue ::Extralite::Error => e
+        raise_error(e)
       end
       
-      # The SQLite adapter does not need the pool to convert exceptions.
+      # The Extralite adapter does not need the pool to convert exceptions.
       # Also, force the max connections to 1 if a memory database is being
       # used, as otherwise each connection gets a separate database.
       def connection_pool_default_options
@@ -281,9 +279,10 @@ module Sequel
           log_sql << ")"
         end
         if block
-          log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
+          cps.bind(ps_args)
+          log_connection_yield(log_sql, conn, args){block.call(cps.each, cps.columns)}
         else
-          log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
+          log_connection_yield(log_sql, conn, args){cps.bind(ps_args).to_a}
           case type
           when :insert
             conn.last_insert_rowid
@@ -293,10 +292,7 @@ module Sequel
         end
       end
       
-      # # SQLite3 raises ArgumentError in addition to SQLite3::Exception in
-      # # some cases, such as operations on a closed database.
       def database_error_classes
-        #[Extralite::Error, ArgumentError]
         [::Extralite::Error]
       end
 
@@ -304,19 +300,14 @@ module Sequel
         Dataset
       end
 
-      if USE_EXTENDED_RESULT_CODES
-        # Support SQLite exception codes if ruby-sqlite3 supports them.
-        def sqlite_error_code(exception)
-          exception.code if exception.respond_to?(:code)
-        end
+      def extralite_error_code(exception)
+        exception.code if exception.respond_to?(:code)
       end
     end
     
-    # Dataset adapter for Sequel
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
 
-      # @!visibility private
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
@@ -332,42 +323,49 @@ module Sequel
         
         private
         
-        # SQLite uses a : before the name of the argument for named
+        # Extralite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
           LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
         end
       end
       
-      # @!visibility private
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
-      # @!visibility private
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
-      # @!visibility private
+      # Support regexp functions if using :setup_regexp_function Database option.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :~, :'!~', :'~*', :'!~*'
+          return super unless supports_regexp?
+
+          case_insensitive = [:'~*', :'!~*'].include?(op)
+          sql << 'NOT ' if [:'!~', :'!~*'].include?(op)
+          sql << '('
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[0])
+          sql << ')' if case_insensitive
+          sql << ' REGEXP '
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[1])
+          sql << ')' if case_insensitive
+          sql << ')'
+        else
+          super
+        end
+      end
+
       def fetch_rows(sql, &block)
-        execute(sql, &block)
-        # execute(sql) do |result|
-        #   cps = db.conversion_procs
-        #   type_procs = result.types.map{|t| cps[base_type_name(t)]}
-        #   j = -1
-        #   cols = result.columns.map{|c| [output_identifier(c), type_procs[(j+=1)]]}
-        #   self.columns = cols.map(&:first)
-        #   max = cols.length
-        #   result.each do |values|
-        #     row = {}
-        #     i = -1
-        #     while (i += 1) < max
-        #       name, type_proc = cols[i]
-        #       v = values[i]
-        #       if type_proc && v
-        #         v = type_proc.call(v)
-        #       end
-        #       row[name] = v
-        #     end
-        #     yield row
-        #   end
-        # end
+        execute(sql) do |result, columns|
+          self.columns = columns
+          max = columns.size
+          result.each(&block)
+        end
+      end
+
+      # Support regexp if using :setup_regexp_function Database option.
+      def supports_regexp?
+        db.allow_regexp?
       end
       
       private

data/test/perf_prepared.rb

@@ -39,9 +39,9 @@ def extralite_prepare
   db.prepare('select * from foo')
 end
 
-def extralite_run(stmt, count)
+def extralite_run(query, count)
   # db = Extralite::Database.new(DB_PATH)
-  results = stmt.query
+  results = query.to_a
   raise unless results.size == count
 end
 

data/test/test_database.rb

@@ -176,7 +176,7 @@ end
     when /darwin/
       @db.load_extension(File.join(__dir__, 'extensions/text.dylib'))
     end
-    
+
     r = @db.query_single_value("select reverse('abcd')")
     assert_equal 'dcba', r
   end
@@ -285,7 +285,7 @@ end
     fn = "/tmp/extralite-#{rand(10000)}.db"
     db1 = Extralite::Database.new(fn)
     db2 = Extralite::Database.new(fn)
-    
+
     db1.query('begin exclusive')
     assert_raises(Extralite::BusyError) { db2.query('begin exclusive') }
 
@@ -349,7 +349,7 @@ end
     end
 
     @db.query('create table t2 (v not null)')
-    
+
     assert_raises(Extralite::Error) { @db.query('insert into t2 values (null)') }
     assert_equal Extralite::SQLITE_CONSTRAINT_NOTNULL, @db.errcode
     assert_equal 'NOT NULL constraint failed: t2.v', @db.errmsg
@@ -357,8 +357,8 @@ end
 
 
   def test_close_with_open_prepared_statement
-    stmt = @db.prepare('select * from t')
-    stmt.query
+    query = @db.prepare('select * from t')
+    query.next
     @db.close
   end
 end
@@ -439,15 +439,15 @@ class ScenarioTest < MiniTest::Test
     @db.query('select 2')
     assert_equal ['select 1', 'select 2'], sqls
 
-    stmt = @db.prepare('select 3')
-    
-    stmt.query
+    query = @db.prepare('select 3')
+
+    query.to_a
     assert_equal ['select 1', 'select 2', 'select 3'], sqls
 
     # turn off
     @db.trace
 
-    stmt.query
+    query.to_a
 
     @db.query('select 4')
     assert_equal ['select 1', 'select 2', 'select 3'], sqls

data/test/test_extralite.rb

@@ -20,7 +20,7 @@ class ExtraliteTest < MiniTest::Test
 
       assert_operator 0, :<, a[0]
       assert_operator a[0], :<=, a[1]
-      
+
       assert_equal a, b
       assert_equal a, c
 

data/test/test_iterator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class IteratorTest < MiniTest::Test
+  def setup
+    @db = Extralite::Database.new(':memory:')
+    @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)')
+    @db.query('insert into t values (4, 5, 6)')
+    @db.query('insert into t values (7, 8, 9)')
+
+    @query = @db.prepare('select * from t')
+  end
+
+  def test_iterator_each_idempotency
+    iter = @query.each
+    assert_equal iter, iter.each
+    assert_equal iter, iter.each.each
+  end
+
+  def test_iterator_hash
+    iter = @query.each
+    assert_kind_of Extralite::Iterator, iter
+
+    buf = []
+    v = iter.each { |r| buf << r }
+    assert_equal iter, v
+    assert_equal [{x: 1, y: 2, z: 3},{ x: 4, y: 5, z: 6 }, { x: 7, y: 8, z: 9 }], buf
+  end
+
+  def test_iterator_ary
+    iter = @query.each_ary
+    assert_kind_of Extralite::Iterator, iter
+
+    buf = []
+    v = iter.each { |r| buf << r }
+    assert_equal iter, v
+    assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], buf
+  end
+
+  def test_iterator_single_column
+    query = @db.prepare('select x from t')
+    iter = query.each_single_column
+    assert_kind_of Extralite::Iterator, iter
+
+    buf = []
+    v = iter.each { |r| buf << r }
+    assert_equal iter, v
+    assert_equal [1, 4, 7], buf
+  end
+
+  def test_iterator_next
+    iter = @query.each
+    assert_equal({x: 1, y: 2, z: 3}, iter.next)
+    assert_equal({x: 4, y: 5, z: 6}, iter.next)
+    assert_equal({x: 7, y: 8, z: 9}, iter.next)
+    assert_nil iter.next
+    assert_nil iter.next
+
+    iter = @query.reset.each_ary
+    assert_equal([1, 2, 3], iter.next)
+    assert_equal([4, 5, 6], iter.next)
+    assert_equal([7, 8, 9], iter.next)
+    assert_nil iter.next
+    assert_nil iter.next
+
+    iter = @db.prepare('select y from t').each_single_column
+    assert_equal(2, iter.next)
+    assert_equal(5, iter.next)
+    assert_equal(8, iter.next)
+    assert_nil iter.next
+    assert_nil iter.next
+  end
+
+  def test_iterator_to_a
+    iter = @query.each
+    assert_equal [{x: 1, y: 2, z: 3},{ x: 4, y: 5, z: 6 }, { x: 7, y: 8, z: 9 }], iter.to_a
+
+    iter = @query.each_ary
+    assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9]], iter.to_a
+
+    iter = @db.prepare('select x from t').each_single_column
+    assert_equal [1, 4, 7], iter.to_a
+  end
+
+  def test_iterator_enumerable_methods
+    mapped = @query.each.map { |row| row[:x] * 10 }
+    assert_equal [10, 40, 70], mapped
+
+    mapped = @query.each_ary.map { |row| row[1] * 10 }
+    assert_equal [20, 50, 80], mapped
+
+    query = @db.prepare('select z from t')
+    mapped = query.each_single_column.map { |v| v * 10 }
+    assert_equal [30, 60, 90], mapped
+  end
+end