sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/sqlanywhere.rb

@@ -1,9 +1,9 @@
-require 'sqlanywhere'
+# frozen-string-literal: true
 
-Sequel.require %w'shared/sqlanywhere', 'adapters'
+require 'sqlanywhere'
+require_relative 'shared/sqlanywhere'
 
 module Sequel
-  # Module for holding all SqlAnywhere-related classes and modules for Sequel.
   module SqlAnywhere
 
     class SQLAnywhereException < StandardError
@@ -17,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
@@ -72,35 +83,37 @@ 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 do |conn|
+        synchronize(opts[:server]) do |conn|
           _execute(conn, :rows, sql, opts)
         end
       end
 
       def execute(sql, opts=OPTS, &block)
-        synchronize do |conn|
+        synchronize(opts[:server]) do |conn|
           _execute(conn, :select, sql, opts, &block)
         end
       end
 
       def execute_insert(sql, opts=OPTS)
-        synchronize do |conn|
+        synchronize(opts[:server]) do |conn|
           _execute(conn, :insert, sql, opts)
         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_yield(sql){@api.sqlany_execute_direct(conn, sql)}
+        unless rs = log_connection_yield(sql, conn){@api.sqlany_execute_direct(conn, sql)}
           result, errstr = @api.sqlany_error(conn)
           raise_error(SQLAnywhereException.new(errstr, result, sql))
         end
@@ -111,7 +124,7 @@ module Sequel
         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?
@@ -119,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
@@ -126,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)
@@ -154,17 +166,20 @@ module Sequel
             else
               cps[type]
             end
-            col_infos << [i, output_identifier(name), cp]
+            col_infos << [output_identifier(name), cp]
           end
 
-          @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,80 +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
       
@@ -105,9 +112,13 @@ 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_yield(s){db.execute_batch(s)}}
+        connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
         
         class << db
           attr_reader :prepared_statements
@@ -144,11 +155,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
@@ -179,15 +194,15 @@ module Sequel
             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)}
+            opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
             case type
             when :select
-              log_yield(sql, log_args){conn.query(sql, args, &block)}
+              log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
             when :insert
-              log_yield(sql, log_args){conn.execute(sql, args)}
+              log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
               conn.last_insert_row_id
             when :update
-              log_yield(sql, log_args){conn.execute_batch(sql, args)}
+              log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
               conn.changes
             end
           end
@@ -239,19 +254,20 @@ module Sequel
           end
         end
         unless cps
-          cps = log_yield("PREPARE #{name}: #{sql}"){conn.prepare(sql)}
+          cps = log_connection_yield("PREPARE #{name}: #{sql}", conn){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
-        log_sql = "EXECUTE #{name}"
+        log_sql = String.new
+        log_sql << "EXECUTE #{name}"
         if ps.log_sql
           log_sql << " ("
           log_sql << sql
           log_sql << ")"
         end
         if block
-          log_yield(log_sql, args){cps.execute(ps_args, &block)}
+          log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
         else
-          log_yield(log_sql, args){cps.execute!(ps_args){|r|}}
+          log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
           case type
           when :insert
             conn.last_insert_row_id
@@ -266,17 +282,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
         
@@ -297,35 +318,25 @@ 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)
-      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]]}
-          @columns = cols.map(&:first)
+          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
@@ -336,19 +347,6 @@ module Sequel
         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
-      end
-      
       private
       
       # The base type name for a given type, without any parenthetical part.
@@ -361,9 +359,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