sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/odbc.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 require 'odbc'
 
 module Sequel
@@ -9,10 +11,6 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :odbc
 
-      GUARDED_DRV_NAME = /^\{.+\}$/.freeze
-      DRV_NAME_GUARDS = '{%s}'.freeze
-      DISCONNECT_ERRORS = /\A08S01/.freeze 
-
       def connect(server)
         opts = server_opts(server)
         conn = if opts.include?(:drvconnect)
@@ -21,8 +19,8 @@ module Sequel
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'
           opts.each do |param, value|
-            if :driver == param and not (value =~ GUARDED_DRV_NAME)
-              value = DRV_NAME_GUARDS % value
+            if :driver == param && value !~ /\A\{.+\}\z/
+              value = "{#{value}}"
             end
             drv.attrs[param.to_s.upcase] = value.to_s
           end
@@ -41,7 +39,7 @@ module Sequel
       def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            r = log_yield(sql){conn.run(sql)}
+            r = log_connection_yield(sql, conn){conn.run(sql)}
             yield(r) if block_given?
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
@@ -55,7 +53,7 @@ module Sequel
       def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.do(sql)}
+            log_connection_yield(sql, conn){conn.do(sql)}
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           end
@@ -78,31 +76,26 @@ module Sequel
         [::ODBC::Error]
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::ODBC::Error) && DISCONNECT_ERRORS.match(e.message))
+        super || (e.is_a?(::ODBC::Error) && /\A08S01/.match(e.message))
       end
     end
     
     class Dataset < Sequel::Dataset
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
-      TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S'}".freeze
-
-      Database::DatasetClass = self
-
       def fetch_rows(sql)
         execute(sql) do |s|
           i = -1
           cols = s.columns(true).map{|c| [output_identifier(c.name), c.type, i+=1]}
-          columns = cols.map{|c| c.at(0)}
-          @columns = columns
-          if rows = s.fetch_all
-            rows.each do |row|
-              hash = {}
-              cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
-              yield hash
-            end
+          columns = cols.map{|c| c[0]}
+          self.columns = columns
+          s.each do |row|
+            hash = {}
+            cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
+            yield hash
           end
         end
         self
@@ -134,19 +127,19 @@ module Sequel
       end
       
       def default_timestamp_format
-        TIMESTAMP_FORMAT
+        "{ts '%Y-%m-%d %H:%M:%S'}"
       end
 
       def literal_date(v)
-        v.strftime(ODBC_DATE_FORMAT)
+        v.strftime("{d '%Y-%m-%d'}")
       end
       
       def literal_false
-        BOOL_FALSE
+        '0'
       end
       
       def literal_true
-        BOOL_TRUE
+        '1'
       end
     end
   end

data/lib/sequel/adapters/odbc/db2.rb

@@ -1,4 +1,6 @@
-Sequel.require 'adapters/shared/db2'
+# frozen-string-literal: true
+
+require_relative '../shared/db2'
 
 Sequel.synchronize do
   Sequel::ODBC::DATABASE_SETUP[:db2] = proc do |db|

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

@@ -1,4 +1,6 @@
-Sequel.require 'adapters/shared/mssql'
+# frozen-string-literal: true
+
+require_relative '../shared/mssql'
 
 module Sequel
   module ODBC
@@ -10,21 +12,17 @@ module Sequel
       end
     end
 
-    # Database and Dataset instance methods for MSSQL specific
-    # support via ODBC.
     module MSSQL
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MSSQL::DatabaseMethods
-        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
-        
-        # Return the last inserted identity value.
+
         def execute_insert(sql, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             begin
-              log_yield(sql){conn.do(sql)}
+              log_connection_yield(sql, conn){conn.do(sql)}
               begin
-                s = log_yield(LAST_INSERT_ID_SQL){conn.run(LAST_INSERT_ID_SQL)}
+                last_insert_id_sql = 'SELECT SCOPE_IDENTITY()'
+                s = log_connection_yield(last_insert_id_sql, conn){conn.run(last_insert_id_sql)}
                 if (rows = s.fetch_all) and (row = rows.first) and (v = row.first)
                   Integer(v)
                 end
@@ -40,20 +38,18 @@ module Sequel
       class Dataset < ODBC::Dataset
         include Sequel::MSSQL::DatasetMethods
 
-        # Use ODBC format, not Microsoft format, as the ODBC layer does
-        # some translation.  MSSQL version is over-ridden to allow 3 millisecond decimal places        
-        TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S%N'}".freeze
-
         private
 
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation, but allow for millisecond precision.
         def default_timestamp_format
-          TIMESTAMP_FORMAT
+          "{ts '%Y-%m-%d %H:%M:%S%N'}"
         end
 
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation.
         def literal_date(v)
-          v.strftime(ODBC_DATE_FORMAT)
+          v.strftime("{d '%Y-%m-%d'}")
         end
       end
     end

data/lib/sequel/adapters/odbc/oracle.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+require_relative '../shared/oracle'
+
+Sequel.synchronize do
+  Sequel::ODBC::DATABASE_SETUP[:oracle] = proc do |db|
+    db.extend ::Sequel::Oracle::DatabaseMethods
+    db.extend_datasets ::Sequel::Oracle::DatasetMethods
+  end
+end
+

data/lib/sequel/adapters/oracle.rb

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 require 'oci8'
-Sequel.require 'adapters/shared/oracle'
+require_relative 'shared/oracle'
 
 module Sequel
   module Oracle
@@ -9,14 +11,16 @@ module Sequel
 
       # ORA-00028: your session has been killed
       # ORA-01012: not logged on
+      # ORA-02396: exceeded maximum idle time, please connect again
       # ORA-03113: end-of-file on communication channel
       # ORA-03114: not connected to ORACLE
-      CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]      
+      # ORA-03135: connection lost contact
+      CONNECTION_ERROR_CODES = [ 28, 1012, 2396, 3113, 3114, 3135 ].freeze
       
       ORACLE_TYPES = {
         :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},
-        :clob=>lambda(&:read)
-      }
+        :clob=>:read.to_proc
+      }.freeze
 
       # Hash of conversion procs for this database.
       attr_reader :conversion_procs
@@ -38,8 +42,8 @@ module Sequel
         
         # The ruby-oci8 gem which retrieves oracle columns with a type of
         # DATE, TIMESTAMP, TIMESTAMP WITH TIME ZONE is complex based on the
-        # ruby version (1.9.2 or later) and Oracle version (9 or later)
-        # In the now standard case of 1.9.2 and Oracle 9 or later, the timezone
+        # ruby version and Oracle version (9 or later)
+        # In the now standard case of Oracle 9 or later, the timezone
         # is determined by the Oracle session timezone. Thus if the user
         # requests Sequel provide UTC timezone to the application,
         # we need to alter the session timezone to be UTC
@@ -57,7 +61,7 @@ module Sequel
 
       def disconnect_connection(c)
         c.logoff
-      rescue OCIInvalidHandle
+      rescue OCIException
         nil
       end
 
@@ -69,6 +73,11 @@ module Sequel
         _execute(:insert, sql, opts)
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       private
 
       def _execute(type, sql, opts=OPTS, &block)
@@ -78,17 +87,13 @@ module Sequel
             if args = opts[:arguments]
               r = conn.parse(sql)
               args = cursor_bind_params(conn, r, args)
-              nr = log_yield(sql, args){r.exec}
+              nr = log_connection_yield(sql, conn, args){r.exec}
               r = nr unless block_given?
             else
-              r = log_yield(sql){conn.exec(sql)}
+              r = log_connection_yield(sql, conn){conn.exec(sql)}
             end
             if block_given?
-              begin
-                yield(r)
-              ensure
-                r.close
-              end
+              yield(r)
             elsif type == :insert
               last_insert_id(conn, opts)
             else
@@ -97,6 +102,8 @@ module Sequel
           rescue OCIException, RuntimeError => e
             # ruby-oci8 is naughty and raises strings in some places
             raise_error(e)
+          ensure
+            r.close if r.is_a?(::OCI8::Cursor)
           end
         end
       end
@@ -107,9 +114,9 @@ module Sequel
         @conversion_procs = ORACLE_TYPES.dup
       end
 
-      PS_TYPES = {'string'.freeze=>String, 'integer'.freeze=>Integer, 'float'.freeze=>Float,
-        'decimal'.freeze=>Float, 'date'.freeze=>Time, 'datetime'.freeze=>Time,
-        'time'.freeze=>Time, 'boolean'.freeze=>String, 'blob'.freeze=>OCI8::BLOB}
+      PS_TYPES = {'string'=>String, 'integer'=>Integer, 'float'=>Float,
+        'decimal'=>Float, 'date'=>Time, 'datetime'=>Time,
+        'time'=>Time, 'boolean'=>String, 'blob'=>OCI8::BLOB, 'clob'=>OCI8::CLOB}.freeze
       def cursor_bind_params(conn, cursor, args)
         i = 0
         args.map do |arg, type|
@@ -122,13 +129,13 @@ module Sequel
           when BigDecimal
             arg = arg.to_f
           when ::Sequel::SQL::Blob
-            raise Error, "Sequel's oracle adapter does not currently support using a blob in a bound variable"
-          end
-          if t = PS_TYPES[type]
-            cursor.bind_param(i, arg, t)
-          else
-            cursor.bind_param(i, arg, arg.class)
+            arg = ::OCI8::BLOB.new(conn, arg)
+          when String
+            if type == 'clob'
+              arg = ::OCI8::CLOB.new(conn, arg)
+            end
           end
+          cursor.bind_param(i, arg, PS_TYPES[type] || arg.class)
           arg
         end
       end
@@ -159,6 +166,10 @@ module Sequel
         end
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def execute_prepared_statement(conn, type, name, opts)
         ps = prepared_statement(name)
         sql = ps.prepared_sql
@@ -170,17 +181,17 @@ module Sequel
           end
         end
         unless cursor
-          cursor = log_yield("PREPARE #{name}: #{sql}"){conn.parse(sql)}
+          cursor = log_connection_yield("PREPARE #{name}: #{sql}", conn){conn.parse(sql)}
           conn.prepared_statements[name] = [cursor, sql]
         end
         args = cursor_bind_params(conn, cursor, opts[:arguments])
         log_sql = "EXECUTE #{name}"
         if ps.log_sql
-          log_sql << " ("
+          log_sql += " ("
           log_sql << sql
           log_sql << ")"
         end
-        r = log_yield(log_sql, args){cursor.exec}
+        r = log_connection_yield(log_sql, conn, args){cursor.exec}
         if block_given?
           yield(cursor)
         elsif type == :insert
@@ -199,7 +210,7 @@ module Sequel
         if sequence
           sql = "SELECT #{literal(sequence)}.currval FROM dual"
           begin
-            cursor = log_yield(sql){conn.exec(sql)}
+            cursor = log_connection_yield(sql, conn){conn.exec(sql)}
             row = cursor.fetch
             row.each{|v| return (v.to_i if v)}
           rescue OCIError
@@ -211,12 +222,12 @@ module Sequel
       end
 
       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
       
       def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){conn.commit}
+        log_connection_yield('Transaction.commit', conn){conn.commit}
       end
 
       def disconnect_error?(e, opts)
@@ -248,7 +259,7 @@ module Sequel
       end
       
       def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        log_connection_yield('Transaction.rollback', conn){conn.rollback}
       end
 
       def schema_parse_table(table, opts=OPTS)
@@ -264,24 +275,28 @@ module Sequel
         im = input_identifier_meth(ds)
 
         # Primary Keys
-        ds = metadata_dataset.from(:all_constraints___cons, :all_cons_columns___cols).
-          where(:cols__table_name=>im.call(table), :cons__constraint_type=>'P',
-                :cons__constraint_name=>:cols__constraint_name, :cons__owner=>:cols__owner)
-        ds = ds.where(:cons__owner=>im.call(schema)) if schema
-        pks = ds.select_map(:cols__column_name)
+        ds = metadata_dataset.
+          from{[all_constraints.as(:cons), all_cons_columns.as(:cols)]}.
+          where{{
+           cols[:table_name]=>im.call(table),
+           cons[:constraint_type]=>'P',
+           cons[:constraint_name]=>cols[:constraint_name],
+           cons[:owner]=>cols[:owner]}}
+        ds = ds.where{{cons[:owner]=>im.call(schema)}} if schema
+        pks = ds.select_map{cols[:column_name]}
 
         # Default values
         defaults = begin
           metadata_dataset.from(:all_tab_cols).
             where(:table_name=>im.call(table)).
-            to_hash(:column_name, :data_default)
+            as_hash(:column_name, :data_default)
         rescue DatabaseError
           {}
         end
 
         metadata = synchronize(opts[:server]) do |conn|
           begin
-          log_yield("Connection.describe_table"){conn.describe_table(schema_and_table)}
+            log_connection_yield("Connection.describe_table", conn){conn.describe_table(schema_and_table)}
           rescue OCIError => e
             raise_error(e)
           end
@@ -315,10 +330,6 @@ module Sequel
     class Dataset < Sequel::Dataset
       include DatasetMethods
 
-      Database::DatasetClass = self
-
-      PREPARED_ARG_PLACEHOLDER = ':'.freeze
-      
       # Oracle already supports named bind arguments, so use directly.
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
@@ -341,30 +352,18 @@ module Sequel
           i = prepared_args.length
           LiteralString.new(":#{i}")
         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
-      
       def fetch_rows(sql)
         execute(sql) do |cursor|
           cps = db.conversion_procs
           cols = columns = cursor.get_col_names.map{|c| output_identifier(c)}
           metadata = cursor.column_metadata
           cm = cols.zip(metadata).map{|c, m| [c, cps[m.data_type]]}
-          @columns = columns
+          self.columns = columns
           while r = cursor.fetch
             row = {}
             r.zip(cm).each{|v, (c, cp)| row[c] = ((v && cp) ? cp.call(v) : v)}
@@ -374,19 +373,6 @@ module Sequel
         self
       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
-      
       # Oracle requires type specifiers for placeholders, at least
       # if you ever want to use a nil/NULL value as the value for
       # the placeholder.
@@ -409,7 +395,15 @@ module Sequel
       end
 
       def prepared_arg_placeholder
-        PREPARED_ARG_PLACEHOLDER
+        ':'
+      end
+
+      def bound_variable_modules
+        [BindArgumentMethods]
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
       end
     end
   end