sequel 5.60.1 → 5.81.0

data/lib/sequel/adapters/mysql.rb

@@ -29,6 +29,21 @@ module Sequel
     end
     MYSQL_TYPES.freeze
 
+    RUBY_MYSQL_3 = !Mysql.respond_to?(:init)
+    RUBY_MYSQL_4 = RUBY_MYSQL_3 && ::Mysql::VERSION.to_i >= 4
+
+    if RUBY_MYSQL_3
+      class Adapter < ::Mysql
+        alias real_connect connect
+        alias use_result store_result
+        if RUBY_MYSQL_4
+          def initialize(**opts)
+            super(**opts.merge(:cast=>false))
+          end
+        end
+      end
+    end
+
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
       include Sequel::MySQL::MysqlMysql2::DatabaseMethods
@@ -72,7 +87,7 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
 
-        if Mysql.respond_to?(:init)
+        if !RUBY_MYSQL_3
           conn = Mysql.init
           conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
           conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
@@ -88,8 +103,8 @@ module Sequel
             conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
           end
         else
-          # ruby-mysql 3 API
-          conn = Mysql.new
+          # ruby-mysql 3+ API
+          conn = Adapter.new
           # no support for default group
           conn.local_infile = opts[:config_local_infile] if opts.has_key?(:config_local_infile)
           if encoding = opts[:encoding] || opts[:charset]
@@ -101,10 +116,7 @@ module Sequel
           if connect_timeout = opts[:connect_timeout]
             conn.connect_timeout = connect_timeout
           end
-          conn.singleton_class.class_eval do
-            alias real_connect connect
-            alias use_result store_result
-          end
+          opts[:compress] = false
         end
 
         conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]

data/lib/sequel/adapters/mysql2.rb

@@ -182,8 +182,8 @@ module Sequel
             1
           when false
             0
-          when DateTime, Time
-            literal(arg)[1...-1]
+          when Time, Date
+            @default_dataset.literal_date_or_time(arg, true)
           else
             arg
           end

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

@@ -43,7 +43,7 @@ module Sequel
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation, but allow for millisecond precision.
         def default_timestamp_format
-          "{ts '%Y-%m-%d %H:%M:%S%N'}"
+          "{ts '%Y-%m-%d %H:%M:%S.%3N'}"
         end
 
         # Use ODBC format, not Microsoft format, as the ODBC layer does

data/lib/sequel/adapters/oracle.rb

@@ -312,6 +312,7 @@ module Sequel
               :char_used => column.char_used?,
               :char_size => column.char_size,
               :data_size => column.data_size,
+              :column_size => column.precision,
               :precision => column.precision,
               :scale => column.scale,
               :fsprecision => column.fsprecision,

data/lib/sequel/adapters/postgres.rb

@@ -185,8 +185,12 @@ module Sequel
         case arg
         when Sequel::SQL::Blob
           {:value=>arg, :type=>17, :format=>1}
-        when DateTime, Time
-          literal(arg)
+        # :nocov:
+        # Not covered by tests as tests use pg_extended_date_support
+        # extension, which has basically the same code.
+        when Time, DateTime
+          @default_dataset.literal_date_or_time(arg)
+        # :nocov:
         else
           arg
         end
@@ -668,6 +672,7 @@ module Sequel
       #          cursor usage.
       # :rows_per_fetch :: The number of rows per fetch (default 1000).  Higher
       #                    numbers result in fewer queries but greater memory use.
+      # :skip_transaction :: Same as :hold, but :hold takes priority.
       #
       # Usage:
       #
@@ -760,13 +765,13 @@ module Sequel
 
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
       def cursor_fetch_rows(sql)
-        server_opts = {:server=>@opts[:server] || :read_only}
         cursor = @opts[:cursor]
-        hold = cursor[:hold]
+        hold = cursor.fetch(:hold){cursor[:skip_transaction]}
+        server_opts = {:server=>@opts[:server] || :read_only, :skip_transaction=>hold}
         cursor_name = quote_identifier(cursor[:cursor_name] || 'sequel_cursor')
         rows_per_fetch = cursor[:rows_per_fetch].to_i
 
-        db.public_send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
+        db.transaction(server_opts) do 
           begin
             execute_ddl("DECLARE #{cursor_name} NO SCROLL CURSOR WITH#{'OUT' unless hold} HOLD FOR #{sql}", server_opts)
             rows_per_fetch = 1000 if rows_per_fetch <= 0

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

@@ -17,7 +17,7 @@ module Sequel
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).where(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
+      #  from(:MSysObjects).where(Type: 1, Flags: 0).select_map(:Name).map(&:to_sym)
       #end
       
       # Access doesn't support renaming tables from an SQL query,
@@ -57,6 +57,14 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      # Access's Byte type will accept much larger values,
+      # even though it only stores 0-255.  Do not set min/max
+      # values for the Byte type.
+      def column_schema_integer_min_max_values(column)
+        return if /byte/i =~ column[:db_type]
+        super
+      end
+
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end

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

@@ -215,6 +215,18 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      DISCONNECT_SQL_STATES = %w'40003 08001 08003'.freeze
+      def disconnect_error?(exception, opts)
+        sqlstate = database_exception_sqlstate(exception, opts)
+
+        case sqlstate
+        when *DISCONNECT_SQL_STATES
+          true
+        else
+          super
+        end
+      end
+
       # DB2 has issues with quoted identifiers, so
       # turn off database quoting by default.
       def quote_identifiers_default

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

@@ -32,7 +32,7 @@ module Sequel
       #
       # Options:
       # :args :: Arguments to stored procedure.  For named arguments, this should be a
-      #          hash keyed by argument named.  For unnamed arguments, this should be an
+      #          hash keyed by argument name.  For unnamed arguments, this should be an
       #          array.  Output parameters to the function are specified using :output.
       #          You can also name output parameters and provide a type by using an
       #          array containing :output, the type name, and the parameter name.
@@ -246,6 +246,34 @@ module Sequel
         information_schema_tables('VIEW', opts)
       end
       
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which will
+      # be converted to a string). If successful, yield to the block, then release the advisory lock
+      # when the block exits.  If unsuccessful, raise a Sequel::AdvisoryLockError.
+      #
+      # Options:
+      # :wait :: Do not raise an error, instead, wait until the advisory lock can be acquired.
+      def with_advisory_lock(lock_id, opts=OPTS)
+        lock_id = lock_id.to_s
+        timeout = opts[:wait] ? -1 : 0
+        server = opts[:server]
+      
+        synchronize(server) do
+          begin
+            res = call_mssql_sproc(:sp_getapplock, :server=>server, :args=>{'Resource'=>lock_id, 'LockTimeout'=>timeout, 'LockMode'=>'Exclusive', 'LockOwner'=>'Session'})
+
+            unless locked = res[:result] >= 0
+                raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+            end
+
+            yield
+          ensure
+            if locked
+              call_mssql_sproc(:sp_releaseapplock, :server=>server, :args=>{'Resource'=>lock_id, 'LockOwner'=>'Session'})
+            end
+          end
+        end
+      end
+
       private
       
       # Add CLUSTERED or NONCLUSTERED as needed
@@ -325,6 +353,11 @@ module Sequel
         false
       end
 
+      # MSSQL tinyint types are unsigned.
+      def column_schema_tinyint_type_is_unsigned?
+        true
+      end
+
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/.match(default)
@@ -399,10 +432,15 @@ module Sequel
       # Backbone of the tables and views support.
       def information_schema_tables(type, opts)
         m = output_identifier_meth
-        metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
+        schema = opts[:schema]||'dbo'
+        tables = metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
           select(:table_name).
-          where(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
+          where(:table_type=>type, :table_schema=>schema.to_s).
           map{|x| m.call(x[:table_name])}
+
+        tables.map!{|t| Sequel.qualify(m.call(schema).to_s, m.call(t).to_s)} if opts[:qualify]
+
+        tables
       end
 
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
@@ -586,6 +624,18 @@ module Sequel
         end
       end
       
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Load entire query in this case to get
+      # the number of rows. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def count(*a, &block)
+        if (@opts[:sql] && a.empty? && !block)
+          naked.to_a.length
+        else
+          super
+        end
+      end
+
       # Uses CROSS APPLY to join the given table into the current dataset.
       def cross_apply(table)
         join_table(:cross_apply, table)
@@ -596,6 +646,19 @@ module Sequel
         clone(:disable_insert_output=>true)
       end
 
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Run query, and if it returns any
+      # records, return true. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def empty?
+        if @opts[:sql]
+          naked.each{return false}
+          true
+        else
+          super
+        end
+      end
+
       # MSSQL treats [] as a metacharacter in LIKE expresions.
       def escape_like(string)
         string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}
@@ -800,11 +863,10 @@ module Sequel
         if opts[:return] == :primary_key && !@opts[:output]
           output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
         elsif @opts[:output]
-          statements = multi_insert_sql(columns, values)
-          ds = naked
-          @db.transaction(opts.merge(:server=>@opts[:server])) do
-            statements.map{|st| ds.with_sql(st)}
-          end.first.map{|v| v.length == 1 ? v.values.first : v}
+          # no transaction: our multi_insert_sql_strategy should guarantee
+          # that there's only ever a single statement.
+          sql = multi_insert_sql(columns, values)[0]
+          naked.with_sql(sql).map{|v| v.length == 1 ? v.values.first : v}
         else
           super
         end
@@ -898,7 +960,7 @@ module Sequel
       # since that is the format that is multilanguage and not
       # DATEFORMAT dependent.
       def default_timestamp_format
-        "'%Y-%m-%dT%H:%M:%S%N%z'"
+        "'%Y-%m-%dT%H:%M:%S.%3N'"
       end
 
       # Only include the primary table in the main delete clause

data/lib/sequel/adapters/shared/mysql.rb

@@ -197,6 +197,41 @@ module Sequel
         renames.each{|from,| remove_cached_schema(from)}
       end
       
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which will be
+      # converted to a string).  If successful, yield to the block, then release the advisory lock
+      # when the block exits.  If unsuccessful, raise a Sequel::AdvisoryLockError.
+      #
+      #   DB.with_advisory_lock(1357){DB.get(1)}
+      #   # SELECT GET_LOCK('1357', 0) LIMIT 1
+      #   # SELECT 1 AS v LIMIT 1
+      #   # SELECT RELEASE_LOCK('1357') LIMIT 1
+      #
+      # Options:
+      # :wait :: Do not raise an error, instead, wait until the advisory lock can be acquired.
+      def with_advisory_lock(lock_id, opts=OPTS)
+        lock_id = lock_id.to_s
+        ds = dataset
+        if server = opts[:server]
+          ds = ds.server(server)
+        end
+
+        # MariaDB doesn't support negative values for infinite wait.  A wait of 34 years
+        # should be reasonably similar to infinity for this case.
+        timeout = opts[:wait] ? 1073741823 : 0
+      
+        synchronize(server) do |c|
+          begin
+            unless locked = ds.get{GET_LOCK(lock_id, timeout)} == 1
+              raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+            end
+
+            yield
+          ensure
+            ds.get{RELEASE_LOCK(lock_id)} if locked
+          end
+        end
+      end
+
       private
       
       def alter_table_add_column_sql(table, op)
@@ -550,6 +585,20 @@ module Sequel
         end
       end
 
+      # Return nil if CHECK constraints are not supported, because
+      # versions that don't support check constraints don't raise
+      # errors for values outside of range.
+      def column_schema_integer_min_max_values(column)
+        super if supports_check_constraints?
+      end
+
+      # Return nil if CHECK constraints are not supported, because
+      # versions that don't support check constraints don't raise
+      # errors for values outside of range.
+      def column_schema_decimal_min_max_values(column)
+        super if supports_check_constraints?
+      end
+
       # Split DROP INDEX ops on MySQL 5.6+, as dropping them in the same
       # statement as dropping a related foreign key causes an error.
       def split_alter_table_op?(op)
@@ -632,7 +681,7 @@ module Sequel
       MATCH_AGAINST_BOOLEAN = ["MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE)".freeze].freeze
 
       Dataset.def_sql_method(self, :delete, %w'with delete from where order limit')
-      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
+      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update returning')
       Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having window compounds order limit lock')
       Dataset.def_sql_method(self, :update, %w'with update ignore table set where order limit')
 
@@ -760,6 +809,21 @@ module Sequel
         clone(:insert_ignore=>true)
       end
 
+      # Support insert select for associations, so that the model code can use
+      # returning instead of a separate query.
+      def insert_select(*values)
+        return unless supports_insert_select?
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
+      end
+
       # Sets up the insert methods to use ON DUPLICATE KEY UPDATE
       # If you pass no arguments, ALL fields will be
       # updated with the new values.  If you pass the fields you
@@ -857,9 +921,14 @@ module Sequel
         true
       end
 
-      # MySQL 8+ supports SKIP LOCKED.
+      # MariaDB 10.5.0 supports INSERT RETURNING.
+      def supports_returning?(type)
+        (type == :insert && db.mariadb? && db.adapter_scheme != :jdbc) ? (db.server_version >= 100500) : false
+      end
+
+      # MySQL 8+ and MariaDB 10.6+ support SKIP LOCKED.
       def supports_skip_locked?
-        !db.mariadb? && db.server_version >= 80000
+        db.server_version >= (db.mariadb? ? 100600 : 80000)
       end
 
       # Check the database setting for whether fractional timestamps
@@ -895,6 +964,16 @@ module Sequel
         super if type == :truncate || @opts[:offset]
       end
 
+      # The strftime format to use when literalizing time (Sequel::SQLTime) values.
+      def default_time_format
+        db.supports_timestamp_usecs? ? super : "'%H:%M:%S'"
+      end
+
+      # The strftime format to use when literalizing timestamp (Time/DateTime) values.
+      def default_timestamp_format
+        db.supports_timestamp_usecs? ? super : "'%Y-%m-%d %H:%M:%S'"
+      end
+
       # Consider the first table in the joined dataset is the table to delete
       # from, but include the others for the purposes of selecting rows.
       def delete_from_sql(sql)

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

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
 require_relative '../utils/emulate_offset_with_row_number'
+require_relative '../../extensions/auto_cast_date_and_time'
 
 module Sequel
   module Oracle
@@ -178,6 +179,13 @@ module Sequel
         ''
       end
 
+      # Support min/max integer values on Oracle only if
+      # they use a NUMBER column with a fixed precision
+      # and no scale.
+      def column_schema_integer_min_max_values(column)
+        super if column[:db_type] =~ /NUMBER\(\d+\)/i || (column[:db_type] == 'NUMBER' && column[:column_size].is_a?(Integer) && column[:scale] == 0)
+      end
+
       def create_sequence_sql(name, opts=OPTS)
         "CREATE SEQUENCE #{quote_identifier(name)} start with #{opts [:start_with]||1} increment by #{opts[:increment_by]||1} nomaxvalue"
       end
@@ -319,6 +327,8 @@ module Sequel
     end
 
     module DatasetMethods
+      include AutoCastDateAndTime
+
       ROW_NUMBER_EXPRESSION = LiteralString.new('ROWNUM').freeze
       BITAND_PROC = lambda{|a, b| Sequel.lit(["CAST(BITAND(", ", ", ") AS INTEGER)"], a, b)}
 
@@ -378,7 +388,12 @@ module Sequel
       # Use a custom expression with EXISTS to determine whether a dataset
       # is empty.
       def empty?
-        db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
+        if @opts[:sql]
+          naked.each{return false}
+          true
+        else
+          db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
+        end
       end
 
       # Oracle requires SQL standard datetimes
@@ -611,7 +626,7 @@ module Sequel
 
       # The strftime format to use when literalizing the time.
       def default_timestamp_format
-        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'"
+        "'%Y-%m-%d %H:%M:%S.%6N %:z'"
       end
 
       def empty_from_sql
@@ -648,11 +663,6 @@ module Sequel
         super
       end
 
-      # Use a colon for the timestamp offset, since Oracle appears to require it.
-      def format_timestamp_offset(hour, minute)
-        sprintf("%+03i:%02i", hour, minute)
-      end
-
       # Oracle doesn't support empty values when inserting.
       def insert_supports_empty_values?
         false