sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/sqlanywhere.rb

@@ -1,11 +1,9 @@
 # frozen-string-literal: true
 
 require 'sqlanywhere'
-
-Sequel.require %w'shared/sqlanywhere', 'adapters'
+require_relative 'shared/sqlanywhere'
 
 module Sequel
-  # Module for holding all SqlAnywhere-related classes and modules for Sequel.
   module SqlAnywhere
 
     class SQLAnywhereException < StandardError
@@ -19,31 +17,42 @@ module Sequel
       end
     end
 
-    TYPE_TRANSLATOR = tt = Class.new do
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
-      def boolean(s) s.to_i != 0 end
-      def date(s) ::Date.strptime(s) end
-      def decimal(s) ::BigDecimal.new(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-    end.new
+    boolean = Object.new
+    def boolean.call(s)
+      s.to_i != 0
+    end
+
+    date = Object.new
+    def date.call(s)
+      ::Date.strptime(s)
+    end
+
+    decimal = Object.new
+    class << decimal
+      alias call BigDecimal
+      public :call
+    end
+
+    time = Object.new
+    def time.call(s)
+      ::Sequel.string_to_time(s)
+    end
 
     SQLANYWHERE_TYPES = {}
     {
-        [0, 484] => tt.method(:decimal),
-        [384] => tt.method(:date),
-        [388] =>  tt.method(:time),
-        [500] => tt.method(:boolean),
-        [524, 528] => tt.method(:blob)
+        [0, 484] => decimal,
+        [384] => date,
+        [388] => time,
+        [500] => boolean,
+        [524, 528] => ::Sequel::SQL::Blob
     }.each do |k,v|
       k.each{|n| SQLANYWHERE_TYPES[n] = v}
     end
+    SQLANYWHERE_TYPES.freeze
 
-    # Database class for SQLAnywhere databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::SqlAnywhere::DatabaseMethods
 
-      DEFAULT_CONFIG = { :user => 'dba', :password => 'sql' }
-
       attr_accessor :api
 
       set_adapter_scheme :sqlanywhere
@@ -74,12 +83,10 @@ module Sequel
         conn
       end
 
-      # Closes given database connection.
       def disconnect_connection(c)
         @api.sqlany_disconnect(c)
       end
 
-      # Returns number of rows affected
       def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           _execute(conn, :rows, sql, opts)
@@ -98,9 +105,13 @@ module Sequel
         end
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       private
 
-      LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
       def _execute(conn, type, sql, opts)
         unless rs = log_connection_yield(sql, conn){@api.sqlany_execute_direct(conn, sql)}
           result, errstr = @api.sqlany_error(conn)
@@ -109,11 +120,11 @@ module Sequel
 
         case type
         when :select
-          yield rs if block_given?
+          yield rs if defined?(yield)
         when :rows
           return @api.sqlany_affected_rows(rs)
         when :insert
-          _execute(conn, :select, LAST_INSERT_ID, opts){|r| return @api.sqlany_get_column(r, 0)[1] if r && @api.sqlany_fetch_next(r) == 1}
+          _execute(conn, :select, 'SELECT @@IDENTITY', opts){|r| return @api.sqlany_get_column(r, 0)[1] if r && @api.sqlany_fetch_next(r) == 1}
         end
       ensure
         @api.sqlany_commit(conn) unless in_transaction?
@@ -121,6 +132,7 @@ module Sequel
       end
 
       def adapter_initialize
+        @convert_smallint_to_bool = true
         @conversion_procs = SQLANYWHERE_TYPES.dup
         @conversion_procs[392] = method(:to_application_timestamp_sa)
         @api = SQLAnywhere::SQLAnywhereInterface.new
@@ -128,26 +140,24 @@ module Sequel
         raise LoadError, "Could not initialize SQLAnywhere DBCAPI library" if @api.sqlany_init == 0
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def log_connection_execute(conn, sql)
         _execute(conn, nil, sql, OPTS)
       end
     end
 
-    # Dataset class for SqlAnywhere datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::SqlAnywhere::DatasetMethods
 
-      Database::DatasetClass = self
-
-      # Yield all rows matching this dataset.  If the dataset is set to
-      # split multiple statements, yield arrays of hashes one per statement
-      # instead of yielding results for all statements as hashes.
       def fetch_rows(sql)
         db = @db
         cps = db.conversion_procs
         api = db.api
         execute(sql) do |rs|
-          convert = (convert_smallint_to_bool and db.convert_smallint_to_bool)
+          convert = convert_smallint_to_bool
           col_infos = []
           api.sqlany_num_cols(rs).times do |i|
             _, _, name, _, type = api.sqlany_get_column_info(rs, i)
@@ -156,17 +166,20 @@ module Sequel
             else
               cps[type]
             end
-            col_infos << [i, output_identifier(name), cp]
+            col_infos << [output_identifier(name), cp]
           end
 
-          self.columns = col_infos.map{|a| a[1]}
+          self.columns = col_infos.map(&:first)
+          max = col_infos.length
 
           if rs
             while api.sqlany_fetch_next(rs) == 1
+              i = -1
               h = {}
-              col_infos.each do |i, name, cp|
-                _, v = api.sqlany_get_column(rs, i)
-                h[name] = cp && v ? cp[v] : v
+              while (i+=1) < max
+                name, cp = col_infos[i]
+                v = api.sqlany_get_column(rs, i)[1]
+                h[name] = cp && v ? cp.call(v) : v
               end
               yield h
             end

data/lib/sequel/adapters/sqlite.rb

@@ -1,82 +1,87 @@
 # frozen-string-literal: true
 
 require 'sqlite3'
-Sequel.require 'adapters/shared/sqlite'
+require_relative 'shared/sqlite'
 
 module Sequel
-  # Top level module for holding all SQLite-related modules and classes
-  # for Sequel.
   module SQLite
-    TYPE_TRANSLATOR = tt = Class.new do
-      FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
+    FALSE_VALUES = (%w'0 false f no n'.each(&:freeze) + [0]).freeze
 
-      def blob(s)
-        Sequel::SQL::Blob.new(s.to_s)
-      end
+    blob = Object.new
+    def blob.call(s)
+      Sequel::SQL::Blob.new(s.to_s)
+    end
 
-      def boolean(s)
-        s = s.downcase if s.is_a?(String)
-        !FALSE_VALUES.include?(s)
-      end
+    boolean = Object.new
+    def boolean.call(s)
+      s = s.downcase if s.is_a?(String)
+      !FALSE_VALUES.include?(s)
+    end
 
-      def date(s)
-        case s
-        when String
-          Sequel.string_to_date(s)
-        when Integer
-          Date.jd(s)
-        when Float
-          Date.jd(s.to_i)
-        else
-          raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
-        end
+    date = Object.new
+    def date.call(s)
+      case s
+      when String
+        Sequel.string_to_date(s)
+      when Integer
+        Date.jd(s)
+      when Float
+        Date.jd(s.to_i)
+      else
+        raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
       end
+    end
 
-      def integer(s)
-        s.to_i
-      end
+    integer = Object.new
+    def integer.call(s)
+      s.to_i
+    end
 
-      def float(s)
-        s.to_f
-      end
+    float = Object.new
+    def float.call(s)
+      s.to_f
+    end
 
-      def numeric(s)
-        s = s.to_s unless s.is_a?(String)
-        ::BigDecimal.new(s) rescue s
-      end
+    numeric = Object.new
+    def numeric.call(s)
+      s = s.to_s unless s.is_a?(String)
+      BigDecimal(s) rescue s
+    end
 
-      def time(s)
-        case s
-        when String
-          Sequel.string_to_time(s)
-        when Integer
-          Sequel::SQLTime.create(s/3600, (s % 3600)/60, s % 60)
-        when Float
-          s, f = s.divmod(1)
-          Sequel::SQLTime.create(s/3600, (s % 3600)/60, s % 60, (f*1000000).round)
-        else
-          raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
-        end
+    time = Object.new
+    def time.call(s)
+      case s
+      when String
+        Sequel.string_to_time(s)
+      when Integer
+        Sequel::SQLTime.create(s/3600, (s % 3600)/60, s % 60)
+      when Float
+        s, f = s.divmod(1)
+        Sequel::SQLTime.create(s/3600, (s % 3600)/60, s % 60, (f*1000000).round)
+      else
+        raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
       end
-
-    end.new
+    end
 
     # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
     {
-      %w'date' => tt.method(:date),
-      %w'time' => tt.method(:time),
-      %w'bit bool boolean' => tt.method(:boolean),
-      %w'integer smallint mediumint int bigint' => tt.method(:integer),
-      %w'numeric decimal money' => tt.method(:numeric),
-      %w'float double real dec fixed' + ['double precision'] => tt.method(:float),
-      %w'blob' => tt.method(:blob)
+      %w'date' => date,
+      %w'time' => time,
+      %w'bit bool boolean' => boolean,
+      %w'integer smallint mediumint int bigint' => integer,
+      %w'numeric decimal money' => numeric,
+      %w'float double real dec fixed' + ['double precision'] => float,
+      %w'blob' => blob
     }.each do |k,v|
       k.each{|n| SQLITE_TYPES[n] = v}
     end
+    SQLITE_TYPES.freeze
+
+    sqlite_version = SQLite3::VERSION.split('.').map(&:to_i)[0..1]
+    sqlite_version = sqlite_version[0] * 100 + sqlite_version[1]
+    USE_EXTENDED_RESULT_CODES = sqlite_version >= 104
     
-    # Database class for SQLite databases used with Sequel and the
-    # ruby-sqlite3 driver.
     class Database < Sequel::Database
       include ::Sequel::SQLite::DatabaseMethods
       
@@ -93,6 +98,11 @@ module Sequel
       # The conversion procs to use for this database
       attr_reader :conversion_procs
 
+      def initialize(opts = OPTS)
+        super
+        @allow_regexp = typecast_value_boolean(opts[:setup_regexp_function])
+      end
+
       # Connect to the database. Since SQLite is a file based database,
       # available options are limited:
       #
@@ -107,9 +117,19 @@ module Sequel
         sqlite3_opts = {}
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::SQLite3::Database.new(opts[:database].to_s, sqlite3_opts)
-        db.busy_timeout(opts.fetch(:timeout, 5000))
+        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.execute_batch(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
@@ -119,6 +139,12 @@ 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}
@@ -146,11 +172,15 @@ module Sequel
         end
       end
       
-      # Run the given SQL with the given arguments and return the last inserted row id.
       def execute_insert(sql, opts=OPTS)
         _execute(:insert, sql, opts)
       end
       
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       # Handle Integer and Float arguments, since SQLite can store timestamps as integers and floats.
       def to_application_timestamp(s)
         case s
@@ -176,26 +206,24 @@ module Sequel
       # Yield an available connection.  Rescue
       # any SQLite3::Exceptions 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, {}).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.execute(sql, args)}
-              conn.last_insert_row_id
-            when :update
-              log_connection_yield(sql, conn, log_args){conn.execute_batch(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
+            log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
+          when :insert
+            log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
+            conn.last_insert_row_id
+          when :update
+            log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
+            conn.changes
           end
-        rescue SQLite3::Exception => e
-          raise_error(e)
         end
+      rescue SQLite3::Exception => e
+        raise_error(e)
       end
       
       # The SQLite adapter does not need the pool to convert exceptions.
@@ -269,17 +297,22 @@ module Sequel
       def database_error_classes
         [SQLite3::Exception, ArgumentError]
       end
+
+      def dataset_class_default
+        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
+      end
     end
     
-    # Dataset class for SQLite datasets that use the ruby-sqlite3 driver.
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
 
-      Database::DatasetClass = self
-      
-      PREPARED_ARG_PLACEHOLDER = ':'.freeze
-      
-      # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
@@ -300,35 +333,47 @@ module Sequel
         def prepared_arg(k)
           LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
         end
-
-        # Always assume a prepared argument.
-        def prepared_arg?(k)
-          true
-        end
       end
       
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
-      # Execute the given type of statement with the hash of values.
-      def call(type, bind_vars={}, *values, &block)
-        ps = to_prepared_statement(type, values)
-        ps.extend(BindArgumentMethods)
-        ps.call(bind_vars, &block)
+      # 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
-      
-      # Yield a hash for each row in the dataset.
+
       def fetch_rows(sql)
         execute(sql) do |result|
-          i = -1
           cps = db.conversion_procs
           type_procs = result.types.map{|t| cps[base_type_name(t)]}
-          cols = result.columns.map{|c| i+=1; [output_identifier(c), i, type_procs[i]]}
+          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 = {}
-            cols.each do |name,id,type_proc|
-              v = values[id]
+            i = -1
+            while (i += 1) < max
+              name, type_proc = cols[i]
+              v = values[i]
               if type_proc && v
                 v = type_proc.call(v)
               end
@@ -338,18 +383,10 @@ module Sequel
           end
         end
       end
-      
-      # Prepare the given type of query with the given name and store
-      # it in the database.  Note that a new native prepared statement is
-      # created on each call to this prepared statement.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.set_prepared_statement(name, ps)
-        end
-        ps
+
+      # Support regexp if using :setup_regexp_function Database option.
+      def supports_regexp?
+        db.allow_regexp?
       end
       
       private
@@ -364,9 +401,17 @@ module Sequel
         sql << "'" << ::SQLite3::Database.quote(v) << "'"
       end
 
+      def bound_variable_modules
+        [BindArgumentMethods]
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
+      end
+
       # SQLite uses a : before the name of the argument as a placeholder.
       def prepared_arg_placeholder
-        PREPARED_ARG_PLACEHOLDER
+        ':'
       end
     end
   end