sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/ado.rb

@@ -5,18 +5,97 @@ require 'win32ole'
 module Sequel
   # The ADO adapter provides connectivity to ADO databases in Windows.
   module ADO
-    class Database < Sequel::Database
-      DISCONNECT_ERROR_RE = /Communication link failure/
+    # ADO constants (DataTypeEnum)
+    # Source: https://msdn.microsoft.com/en-us/library/ms675318(v=vs.85).aspx
+    AdBigInt           = 20
+    AdBinary           = 128
+    #AdBoolean          = 11
+    #AdBSTR             = 8
+    #AdChapter          = 136
+    #AdChar             = 129
+    #AdCurrency         = 6
+    #AdDate             = 7
+    AdDBDate           = 133
+    #AdDBTime           = 134
+    AdDBTimeStamp      = 135
+    #AdDecimal          = 14
+    #AdDouble           = 5
+    #AdEmpty            = 0
+    #AdError            = 10
+    #AdFileTime         = 64
+    #AdGUID             = 72
+    #AdIDispatch        = 9
+    #AdInteger          = 3
+    #AdIUnknown         = 13
+    AdLongVarBinary    = 205
+    #AdLongVarChar      = 201
+    #AdLongVarWChar     = 203
+    AdNumeric          = 131
+    #AdPropVariant      = 138
+    #AdSingle           = 4
+    #AdSmallInt         = 2
+    #AdTinyInt          = 16
+    #AdUnsignedBigInt   = 21
+    #AdUnsignedInt      = 19
+    #AdUnsignedSmallInt = 18
+    #AdUnsignedTinyInt  = 17
+    #AdUserDefined      = 132
+    AdVarBinary        = 204
+    #AdVarChar          = 200
+    #AdVariant          = 12
+    AdVarNumeric       = 139
+    #AdVarWChar         = 202
+    #AdWChar            = 130
+
+    bigint = Object.new
+    def bigint.call(v)
+      v.to_i
+    end
+
+    numeric = Object.new
+    def numeric.call(v)
+      if v.include?(',')
+        BigDecimal(v.tr(',', '.'))
+      else
+        BigDecimal(v)
+      end
+    end
+
+    binary = Object.new
+    def binary.call(v)
+      Sequel.blob(v.pack('c*'))
+    end
 
+    date = Object.new
+    def date.call(v)
+      Date.new(v.year, v.month, v.day)
+    end
+
+    CONVERSION_PROCS = {}
+    [
+      [bigint, AdBigInt],
+      [numeric, AdNumeric, AdVarNumeric],
+      [date, AdDBDate],
+      [binary, AdBinary, AdVarBinary, AdLongVarBinary]
+    ].each do |callable, *types|
+      callable.freeze
+      types.each do |i|
+        CONVERSION_PROCS[i] = callable
+      end
+    end
+    CONVERSION_PROCS.freeze
+
+    class Database < Sequel::Database
       set_adapter_scheme :ado
 
+      attr_reader :conversion_procs
+
       # In addition to the usual database options,
       # the following options have an effect:
       #
       # :command_timeout :: Sets the time in seconds to wait while attempting
       #                     to execute a command before cancelling the attempt and generating
       #                     an error. Specifically, it sets the ADO CommandTimeout property.
-      #                     If this property is not set, the default of 30 seconds is used.
       # :driver :: The driver to use in the ADO connection string.  If not provided, a default
       #            of "SQL Server" is used.
       # :conn_string :: The full ADO connection string.  If this is provided,
@@ -28,8 +107,8 @@ module Sequel
       #
       # Pay special attention to the :provider option, as without specifying a provider,
       # many things will be broken.  The SQLNCLI10 provider appears to work well if you
-      # are connecting to Microsoft SQL Server, but it is not the default as that would
-      # break backwards compatability.
+      # are connecting to Microsoft SQL Server, but it is not the default as that is not
+      # always available and would break backwards compatability.
       def connect(server)
         opts = server_opts(server)
         s = opts[:conn_string] || "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
@@ -46,6 +125,11 @@ module Sequel
         nil
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       # Just execute so it doesn't attempt to return the number of rows modified.
       def execute_ddl(sql, opts=OPTS)
         execute(sql, opts)
@@ -76,7 +160,14 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             r = log_connection_yield(sql, conn){conn.Execute(sql)}
-            yield(r) if block_given?
+            begin
+              yield r if defined?(yield)
+            ensure
+              begin
+                r.close
+              rescue ::WIN32OLERuntimeError
+              end
+            end
           rescue ::WIN32OLERuntimeError => e
             raise_error(e)
           end
@@ -89,22 +180,44 @@ module Sequel
       def adapter_initialize
         case @opts[:conn_string]
         when /Microsoft\.(Jet|ACE)\.OLEDB/io
-          Sequel.require 'adapters/ado/access'
+          require_relative 'ado/access'
           extend Sequel::ADO::Access::DatabaseMethods
           self.dataset_class = ADO::Access::Dataset
         else
           @opts[:driver] ||= 'SQL Server'
           case @opts[:driver]
           when 'SQL Server'
-            Sequel.require 'adapters/ado/mssql'
+            require_relative 'ado/mssql'
             extend Sequel::ADO::MSSQL::DatabaseMethods
             self.dataset_class = ADO::MSSQL::Dataset
             set_mssql_unicode_strings
           end
         end
+
+        @conversion_procs = CONVERSION_PROCS.dup
+        @conversion_procs[AdDBTimeStamp] = method(:adb_timestamp_to_application_timestamp)
+
         super
       end
 
+      def adb_timestamp_to_application_timestamp(v)
+        # This hard codes a timestamp_precision of 6 when converting.
+        # That is the default timestamp_precision, but the ado/mssql adapter uses a timestamp_precision
+        # of 3.  However, timestamps returned by ado/mssql have nsec values that end up rounding to a
+        # the same value as if a timestamp_precision of 3 was hard coded (either xxx999yzz, where y is
+        # 5-9 or xxx000yzz where y is 0-4).
+        #
+        # ADO subadapters should override this they would like a different timestamp precision and the
+        # this code does not work for them (for example, if they provide full nsec precision).
+        #
+        # Note that fractional second handling for WIN32OLE objects is not correct on ruby <2.2
+        to_application_timestamp([v.year, v.month, v.day, v.hour, v.min, v.sec, (v.nsec/1000.0).round * 1000])
+      end
+
+      def dataset_class_default
+        Dataset
+      end
+
       # The ADO adapter's default provider doesn't support transactions, since it 
       # creates a new native connection for each query.  So Sequel only attempts
       # to use transactions if an explicit :provider is given.
@@ -121,7 +234,7 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ DISCONNECT_ERROR_RE)
+        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ /Communication link failure/)
       end
 
       def rollback_transaction(conn, opts=OPTS)
@@ -130,21 +243,38 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      Database::DatasetClass = self
-
       def fetch_rows(sql)
-        execute(sql) do |s|
-          columns = cols = s.Fields.extend(Enumerable).map{|column| output_identifier(column.Name)}
-          self.columns = columns
-          s.getRows.transpose.each do |r|
-            row = {}
-            cols.each{|c| row[c] = r.shift}
-            yield row
-          end unless s.eof
+        execute(sql) do |recordset|
+          cols = []
+          conversion_procs = db.conversion_procs
+
+          recordset.Fields.each do |field|
+            cols << [output_identifier(field.Name), conversion_procs[field.Type]]
+          end
+
+          self.columns = cols.map(&:first)
+          return if recordset.EOF
+          max = cols.length
+
+          recordset.GetRows.transpose.each do |field_values|
+            h = {}
+
+            i = -1
+            while (i += 1) < max
+              name, cp = cols[i]
+              h[name] = if (v = field_values[i]) && cp
+                cp.call(v)
+              else
+                v
+              end
+            end
+            
+            yield h
+          end
         end
       end
       
-      # ADO returns nil for all for delete and update statements.
+      # ADO can return for for delete and update statements, depending on the provider.
       def provides_accurate_rows_matched?
         false
       end

data/lib/sequel/adapters/amalgalite.rb

@@ -1,11 +1,9 @@
 # frozen-string-literal: true
 
 require 'amalgalite'
-Sequel.require 'adapters/shared/sqlite'
+require_relative 'shared/sqlite'
 
 module Sequel
-  # Top level module for holding all Amalgalite-related modules and classes
-  # for Sequel.
   module Amalgalite
     # Type conversion map class for Sequel's use of Amalgamite
     class SequelTypeMap < ::Amalgalite::TypeMaps::DefaultMap
@@ -32,7 +30,7 @@ module Sequel
       # Return numeric/decimal types as instances of BigDecimal
       # instead of Float
       def decimal(s)
-        BigDecimal.new(s)
+        BigDecimal(s)
       end
       
       # Return datetime types as instances of Sequel.datetime_class
@@ -50,15 +48,13 @@ module Sequel
         if value.is_a?(::Amalgalite::Blob)
           SQL::Blob.new(value.to_s)
         elsif value.is_a?(String) && declared_type
-          (meth = self.class.sql_to_method(declared_type.downcase)) ? send(meth, value) : value
+          (meth = self.class.sql_to_method(declared_type.downcase)) ? public_send(meth, value) : value
         else
           super
         end
       end
     end
     
-    # Database class for SQLite databases used with Sequel and the
-    # amalgalite driver.
     class Database < Sequel::Database
       include ::Sequel::SQLite::DatabaseMethods
       
@@ -85,28 +81,23 @@ module Sequel
         db
       end
       
-      # Amalgalite is just the SQLite database without a separate SQLite installation.
       def database_type
         :sqlite
       end
 
-      # Run the given SQL with the given arguments. Returns nil.
       def execute_ddl(sql, opts=OPTS)
         _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.execute_batch(sql)}}
         nil
       end
       
-      # Run the given SQL with the given arguments and return the number of changed rows.
       def execute_dui(sql, opts=OPTS)
         _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.execute_batch(sql)}; conn.row_changes}
       end
       
-      # Run the given SQL with the given arguments and return the last inserted row id.
       def execute_insert(sql, opts=OPTS)
         _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.execute_batch(sql)}; conn.last_insert_rowid}
       end
       
-      # Run the given SQL with the given arguments and yield each row.
       def execute(sql, opts=OPTS)
         _execute(sql, opts) do |conn|
           begin
@@ -127,11 +118,9 @@ module Sequel
       # Yield an available connection.  Rescue
       # any Amalgalite::Errors and turn them into DatabaseErrors.
       def _execute(sql, opts)
-        begin
-          synchronize(opts[:server]){|conn| yield conn}
-        rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
-          raise_error(e)
-        end
+        synchronize(opts[:server]){|conn| yield conn}
+      rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
+        raise_error(e)
       end
       
       # The Amagalite adapter does not need the pool to convert exceptions.
@@ -145,19 +134,18 @@ module Sequel
         o
       end
       
-      # Both main error classes that Amalgalite raises
+      def dataset_class_default
+        Dataset
+      end
+
       def database_error_classes
         [::Amalgalite::Error, ::Amalgalite::SQLite3::Error]
       end
     end
     
-    # Dataset class for SQLite datasets that use the amalgalite driver.
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
 
-      Database::DatasetClass = self
-      
-      # Yield a hash for each row in the dataset.
       def fetch_rows(sql)
         execute(sql) do |stmt|
           self.columns = cols = stmt.result_fields.map{|c| output_identifier(c)}
@@ -172,7 +160,7 @@ module Sequel
 
       private
       
-      # Quote the string using the adapter instance method.
+      # Quote the string using the connection instance method.
       def literal_string_append(sql, v)
         db.synchronize(@opts[:server]){|c| sql << c.quote(v)}
       end

data/lib/sequel/adapters/ibmdb.rb

@@ -1,19 +1,11 @@
 # frozen-string-literal: true
 
 require 'ibm_db'
-Sequel.require 'adapters/shared/db2'
+require_relative 'shared/db2'
 
 module Sequel
 
   module IBMDB
-    @convert_smallint_to_bool = true
-
-    class << self
-      # Whether to convert smallint values to bool, true by default.
-      # Can also be overridden per dataset.
-      attr_accessor :convert_smallint_to_bool
-    end
-
     tt = Class.new do
       def boolean(s) !s.to_i.zero? end
       def int(s) s.to_i end
@@ -26,13 +18,14 @@ module Sequel
       :blob => ::Sequel::SQL::Blob.method(:new),
       :time => ::Sequel.method(:string_to_time),
       :date => ::Sequel.method(:string_to_date)
-    }
+    }.freeze
 
-    # Wraps an underlying connection to DB2 using IBM_DB.
+    # Wraps an underlying connection to DB2 using IBM_DB, to provide a more
+    # rubyish API.
     class Connection
       # A hash with prepared statement name symbol keys, where each value is 
       # a two element array with an sql string and cached Statement value.
-      attr_accessor :prepared_statements
+      attr_reader :prepared_statements
 
       # Error class for exceptions raised by the connection.
       class Error < StandardError
@@ -187,6 +180,9 @@ module Sequel
 
       # Hash of connection procs for converting
       attr_reader :conversion_procs
+
+      # Whether to convert smallint values to bool for this Database instance
+      attr_accessor :convert_smallint_to_bool
     
       # Create a new connection object for the given server.
       def connect(server)
@@ -209,7 +205,6 @@ module Sequel
         Connection.new(connection_params)
       end
 
-      # Execute the given SQL on the database.
       def execute(sql, opts=OPTS, &block)
         if sql.is_a?(Symbol)
           execute_prepared_statement(sql, opts, &block)
@@ -220,8 +215,6 @@ module Sequel
         raise_error(e)
       end
 
-      # Execute the given SQL on the database, returning the last inserted
-      # identity value.
       def execute_insert(sql, opts=OPTS)
         synchronize(opts[:server]) do |c|
           if sql.is_a?(Symbol)
@@ -253,7 +246,7 @@ module Sequel
           end
           begin
             stmt = log_connection_yield(log_sql, conn, args){conn.execute_prepared(ps_name, *args)}
-            if block_given?
+            if defined?(yield)
               yield(stmt)
             else  
               stmt.affected
@@ -264,12 +257,18 @@ module Sequel
         end
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       private
 
-      # Execute the given SQL on the database.
+      # Execute the given SQL on the database, yielding the related statement if a block
+      # is given or returning the number of affected rows if not, and ensuring the statement is freed.
       def _execute(conn, sql, opts)
         stmt = log_connection_yield(sql, conn){conn.execute(sql)}
-        if block_given?
+        if defined?(yield)
           yield(stmt)
         else  
           stmt.affected
@@ -279,6 +278,7 @@ module Sequel
       end
 
       def adapter_initialize
+        @convert_smallint_to_bool = typecast_value_boolean(opts.fetch(:convert_smallint_to_bool, true))
         @conversion_procs = DB2_TYPES.dup
         @conversion_procs[:timestamp] = method(:to_application_timestamp)
       end
@@ -286,14 +286,14 @@ module Sequel
       # IBM_DB uses an autocommit setting instead of sending SQL queries.
       # So starting a transaction just turns autocommit off.
       def begin_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_BEGIN, conn){conn.autocommit = false}
+        log_connection_yield('Transaction.begin', conn){conn.autocommit = false}
         set_transaction_isolation(conn, opts)
       end
 
       # This commits transaction in progress on the
       # connection and sets autocommit back on.
       def commit_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
+        log_connection_yield('Transaction.commit', conn){conn.commit}
       end
     
       def database_error_classes
@@ -304,14 +304,16 @@ module Sequel
         exception.sqlstate
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Don't convert smallint to boolean for the metadata
       # dataset, since the DB2 metadata does not use
       # boolean columns, and some smallint columns are
       # accidently treated as booleans.
-      def metadata_dataset
-        ds = super
-        ds.convert_smallint_to_bool = false
-        ds
+      def _metadata_dataset
+        super.with_convert_smallint_to_bool(false)
       end
 
       # Format Numeric, Date, and Time types specially for use
@@ -337,12 +339,12 @@ module Sequel
       # This rolls back the transaction in progress on the
       # connection and sets autocommit back on.
       def rollback_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
+        log_connection_yield('Transaction.rollback', conn){conn.rollback}
       end
 
       # Convert smallint type to boolean if convert_smallint_to_bool is true
       def schema_column_type(db_type)
-        if Sequel::IBMDB.convert_smallint_to_bool && db_type =~ /smallint/i 
+        if convert_smallint_to_bool && db_type =~ /smallint/i 
           :boolean
         else
           super
@@ -353,39 +355,31 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::DB2::DatasetMethods
 
-      Database::DatasetClass = self
-
       module CallableStatementMethods
         # Extend given dataset with this module so subselects inside subselects in
         # prepared statements work.
         def subselect_sql_append(sql, ds)
-          ps = ds.to_prepared_statement(:select).clone(:append_sql=>sql)
-          ps.extend(CallableStatementMethods)
+          ps = ds.to_prepared_statement(:select).
+            clone(:append_sql=>sql, :prepared_args=>prepared_args).
+            with_extend(CallableStatementMethods)
           ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-          ps.prepared_args = prepared_args
           ps.prepared_sql
         end
       end
       
       PreparedStatementMethods = prepared_statements_module(:prepare_bind, Sequel::Dataset::UnnumberedArgumentMapper)
 
-      # Emulate support of bind arguments in called statements.
-      def call(type, bind_arguments={}, *values, &block)
-        ps = to_prepared_statement(type, values)
-        ps.extend(CallableStatementMethods)
-        ps.call(bind_arguments, &block)
-      end
-
       # Whether to convert smallint to boolean arguments for this dataset.
-      # Defaults to the IBMDB module setting.
+      # Defaults to the Database setting.
       def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = IBMDB.convert_smallint_to_bool)
+        opts.has_key?(:convert_smallint_to_bool) ? opts[:convert_smallint_to_bool] : db.convert_smallint_to_bool
       end
 
-      # Override the default IBMDB.convert_smallint_to_bool setting for this dataset.
-      attr_writer :convert_smallint_to_bool
+      # Return a cloned dataset with the convert_smallint_to_bool option set.
+      def with_convert_smallint_to_bool(v)
+        clone(:convert_smallint_to_bool=>v)
+      end
 
-      # Fetch the rows from the database and yield plain hashes.
       def fetch_rows(sql)
         execute(sql) do |stmt|
           columns = []
@@ -397,10 +391,10 @@ module Sequel
             type = stmt.field_type(i).downcase.to_sym
             # decide if it is a smallint from precision
             type = :boolean  if type == :int && convert && stmt.field_precision(i) < 8
-            type = :blob if type == :clob && Sequel::DB2.use_clob_as_blob
+            type = :blob if type == :clob && db.use_clob_as_blob
             columns << [key, cps[type]]
           end
-          cols = columns.map{|c| c.at(0)}
+          cols = columns.map{|c| c[0]}
           self.columns = cols
 
           while res = stmt.fetch_array
@@ -414,16 +408,14 @@ module Sequel
         self
       end
 
-      # Store the given type of prepared statement in the associated database
-      # with the given name.
-      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
+      private
+
+      def bound_variable_modules
+        [CallableStatementMethods]
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
       end
     end
   end