sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/ado/access.rb

@@ -1,5 +1,7 @@
-Sequel.require 'adapters/shared/access'
-Sequel.require 'adapters/utils/split_alter_table'
+# frozen-string-literal: true
+
+require_relative '../shared/access'
+require_relative '../utils/split_alter_table'
 
 module Sequel
   module ADO
@@ -13,7 +15,7 @@ module Sequel
           :tables  => 20,
           :views   => 23,
           :foreign_keys => 27
-        }
+        }.freeze
         
         attr_reader :type, :criteria
 
@@ -40,7 +42,8 @@ module Sequel
             131 => "DECIMAL",
             201 => "TEXT",
             205 => "IMAGE"
-          }
+          }.freeze
+          DATA_TYPE.each_value(&:freeze)
           
           def initialize(row)
             @row = row
@@ -84,13 +87,9 @@ module Sequel
       end      
 
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Access::DatabaseMethods
         include Sequel::Database::SplitAlterTable
     
-        DECIMAL_TYPE_RE = /decimal/io
-        LAST_INSERT_ID = "SELECT @@IDENTITY".freeze
-
         # Remove cached schema after altering a table, since otherwise it can be cached
         # incorrectly in the rename column case.
         def alter_table(name, *)
@@ -109,9 +108,10 @@ module Sequel
         def execute_insert(sql, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             begin
-              log_yield(sql){conn.Execute(sql)}
-              res = log_yield(LAST_INSERT_ID){conn.Execute(LAST_INSERT_ID)}
-              res.getRows.transpose.each{|r| return r.shift}
+              log_connection_yield(sql, conn){conn.Execute(sql)}
+              last_insert_sql = "SELECT @@IDENTITY"
+              res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)}
+              res.GetRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end
@@ -129,7 +129,7 @@ module Sequel
           ado_schema_views.map {|tbl| m.call(tbl['TABLE_NAME'])}
         end
         
-        # Note OpenSchema returns compound indexes as multiple rows
+        # OpenSchema returns compound indexes as multiple rows
         def indexes(table_name,opts=OPTS)
           m = output_identifier_meth
           idxs = ado_schema_indexes(table_name).inject({}) do |memo, idx|
@@ -144,7 +144,7 @@ module Sequel
           idxs
         end
 
-        # Note OpenSchema returns compound foreign key relationships as multiple rows
+        # OpenSchema returns compound foreign key relationships as multiple rows
         def foreign_key_list(table, opts=OPTS)
           m = output_identifier_meth
           fks = ado_schema_foreign_keys(table).inject({}) do |memo, fk|
@@ -201,15 +201,15 @@ module Sequel
         end
 
         def begin_transaction(conn, opts=OPTS)
-          log_yield('Transaction.begin'){conn.BeginTrans}
+          log_connection_yield('Transaction.begin', conn){conn.BeginTrans}
         end
           
         def commit_transaction(conn, opts=OPTS)
-          log_yield('Transaction.commit'){conn.CommitTrans}
+          log_connection_yield('Transaction.commit', conn){conn.CommitTrans}
         end
           
         def rollback_transaction(conn, opts=OPTS)
-          log_yield('Transaction.rollback'){conn.RollbackTrans}
+          log_connection_yield('Transaction.rollback', conn){conn.RollbackTrans}
         end
           
         def schema_column_type(db_type)
@@ -239,7 +239,7 @@ module Sequel
                                 idx["COLUMN_NAME"] == row["COLUMN_NAME"] &&
                                 idx["PRIMARY_KEY"]
                               },
-              :type =>  if row.db_type =~ DECIMAL_TYPE_RE && row.scale == 0
+              :type =>  if row.db_type =~ /decimal/i && row.scale == 0
                           :integer
                         else
                           schema_column_type(row.db_type)
@@ -294,8 +294,9 @@ module Sequel
         
         def fetch_ado_schema(type, criteria=[])
           execute_open_ado_schema(type, criteria) do |s|
-            cols = s.Fields.extend(Enumerable).map(&:Name)
-            s.getRows.transpose.each do |r|
+            cols = []
+            s.Fields.each{|f| cols << f.Name}
+            s.GetRows.transpose.each do |r|
               row = {}
               cols.each{|c| row[c] = r.shift}
               yield row
@@ -306,12 +307,11 @@ module Sequel
         # This is like execute() in that it yields an ADO RecordSet, except
         # instead of an SQL interface there's this OpenSchema call
         # cf. http://msdn.microsoft.com/en-us/library/ee275721(v=bts.10)
-        #
         def execute_open_ado_schema(type, criteria=[])
           ado_schema = AdoSchema.new(type, criteria)
           synchronize(opts[:server]) do |conn|
             begin
-              r = log_yield("OpenSchema #{type.inspect}, #{criteria.inspect}") { 
+              r = log_connection_yield("OpenSchema #{type.inspect}, #{criteria.inspect}", conn) { 
                 if ado_schema.criteria.empty?
                   conn.OpenSchema(ado_schema.type) 
                 else

data/lib/sequel/adapters/ado/mssql.rb

@@ -1,27 +1,20 @@
-Sequel.require 'adapters/shared/mssql'
+# frozen-string-literal: true
+
+require_relative '../shared/mssql'
 
 module Sequel
   module ADO
-    # Database and Dataset instance methods for MSSQL specific
-    # support via ADO.
     module MSSQL
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MSSQL::DatabaseMethods
-        # Query to use to get the number of rows affected by an update or
-        # delete query.
-        ROWS_AFFECTED = "SELECT @@ROWCOUNT AS AffectedRows"
-        
-        # Issue a separate query to get the rows modified.  ADO appears to
-        # use pass by reference with an integer variable, which is obviously
-        # not supported directly in ruby, and I'm not aware of a workaround.
+
         def execute_dui(sql, opts=OPTS)
           return super unless @opts[:provider]
           synchronize(opts[:server]) do |conn|
             begin
-              log_yield(sql){conn.Execute(sql)}
-              res = log_yield(ROWS_AFFECTED){conn.Execute(ROWS_AFFECTED)}
-              res.getRows.transpose.each{|r| return r.shift}
+              sql = "SET NOCOUNT ON; #{sql}; SELECT @@ROWCOUNT"
+              rst = log_connection_yield(sql, conn){conn.Execute(sql)}
+              rst.GetRows[0][0]
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end
@@ -54,7 +47,7 @@ module Sequel
         # is necessary as ADO's default :provider uses a separate native
         # connection for each query.
         def insert(*values)
-          return super if @opts[:sql]
+          return super if (@opts[:sql] && !@opts[:prepared_sql]) || @opts[:returning]
           with_sql("SET NOCOUNT ON; #{insert_sql(*values)}; SELECT CAST(SCOPE_IDENTITY() AS INTEGER)").single_value
         end
         

data/lib/sequel/adapters/amalgalite.rb

@@ -1,9 +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
@@ -30,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
@@ -48,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
       
@@ -79,36 +77,31 @@ module Sequel
         db = ::Amalgalite::Database.new(opts[:database])
         db.busy_handler(::Amalgalite::BusyTimeout.new(opts.fetch(:timeout, 5000)/50, 50))
         db.type_map = SequelTypeMap.new(self)
-        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
+        connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
         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_yield(sql){conn.execute_batch(sql)}}
+        _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_yield(sql){conn.execute_batch(sql)}; conn.row_changes}
+        _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_yield(sql){conn.execute_batch(sql)}; conn.last_insert_rowid}
+        _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
-            yield(stmt = log_yield(sql){conn.prepare(sql)})
+            yield(stmt = log_connection_yield(sql, conn){conn.prepare(sql)})
           ensure
             stmt.close if stmt
           end
@@ -117,7 +110,7 @@ module Sequel
       
       # Run the given SQL with the given arguments and return the first value of the first row.
       def single_value(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.first_value_from(sql)}}
+        _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.first_value_from(sql)}}
       end
       
       private
@@ -143,22 +136,21 @@ 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|
-          @columns = cols = stmt.result_fields.map{|c| output_identifier(c)}
+          self.columns = cols = stmt.result_fields.map{|c| output_identifier(c)}
           col_count = cols.size
           stmt.each do |result|
             row = {}
@@ -170,7 +162,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,17 +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
@@ -24,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
@@ -185,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)
@@ -207,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)
@@ -218,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)
@@ -240,17 +235,17 @@ module Sequel
         sql = ps.prepared_sql
         synchronize(opts[:server]) do |conn|
           unless conn.prepared_statements.fetch(ps_name, []).first == sql
-            log_yield("PREPARE #{ps_name}: #{sql}"){conn.prepare(sql, ps_name)}
+            log_connection_yield("PREPARE #{ps_name}: #{sql}", conn){conn.prepare(sql, ps_name)}
           end
           args = args.map{|v| v.nil? ? nil : prepared_statement_arg(v)}
           log_sql = "EXECUTE #{ps_name}"
           if ps.log_sql
-            log_sql << " ("
+            log_sql += " ("
             log_sql << sql
             log_sql << ")"
           end
           begin
-            stmt = log_yield(log_sql, args){conn.execute_prepared(ps_name, *args)}
+            stmt = log_connection_yield(log_sql, conn, args){conn.execute_prepared(ps_name, *args)}
             if block_given?
               yield(stmt)
             else  
@@ -262,11 +257,17 @@ 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_yield(sql){conn.execute(sql)}
+        stmt = log_connection_yield(sql, conn){conn.execute(sql)}
         if block_given?
           yield(stmt)
         else  
@@ -277,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
@@ -284,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_yield(TRANSACTION_BEGIN){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_yield(TRANSACTION_COMMIT){conn.commit}
+        log_connection_yield('Transaction.commit', conn){conn.commit}
       end
     
       def database_error_classes
@@ -302,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
@@ -335,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_yield(TRANSACTION_ROLLBACK){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
@@ -351,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 = []
@@ -395,11 +391,11 @@ 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)}
-          @columns = cols
+          cols = columns.map{|c| c[0]}
+          self.columns = cols
 
           while res = stmt.fetch_array
             row = {}
@@ -412,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