sequel 5.19.0 → 5.24.0

data/lib/sequel/adapters/sqlite.rb

@@ -112,7 +112,7 @@ 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

data/lib/sequel/adapters/tinytds.rb

@@ -16,6 +16,18 @@ module Sequel
         c = TinyTds::Client.new(opts)
         c.query_options.merge!(:cache_rows=>false)
 
+        if opts[:ansi]
+          sql = %w(
+            ANSI_NULLS
+            ANSI_PADDING
+            ANSI_WARNINGS
+            ANSI_NULL_DFLT_ON
+            QUOTED_IDENTIFIER
+            CONCAT_NULL_YIELDS_NULL
+          ).map{|v| "SET #{v} ON"}.join(";")
+          log_connection_yield(sql, c){c.execute(sql)}
+        end
+
         if (ts = opts[:textsize])
           sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
           log_connection_yield(sql, c){c.execute(sql)}

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -59,6 +59,8 @@ module Sequel
             ForeignKeyConstraintViolation
           when 4025
             CheckConstraintViolation
+          when 1205
+            DatabaseLockTimeout
           else
             super
           end

data/lib/sequel/database/logging.rb

@@ -35,7 +35,7 @@ module Sequel
     # Yield to the block, logging any errors at error level to all loggers,
     # and all other queries with the duration at warn or info level.
     def log_connection_yield(sql, conn, args=nil)
-      return yield if @loggers.empty?
+      return yield if skip_logging?
       sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
       timer = Sequel.start_timer
 
@@ -58,6 +58,12 @@ module Sequel
 
     private
 
+    # Determine if logging should be skipped. Defaults to true if no loggers
+    # have been specified.
+    def skip_logging?
+      @loggers.empty?
+    end
+
     # String including information about the connection, for use when logging
     # connection info.
     def connection_info(conn)

data/lib/sequel/database/query.rb

@@ -331,7 +331,7 @@ module Sequel
         :time
       when /\A(bool(ean)?)\z/io
         :boolean
-      when /\A(real|float|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
       when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal

data/lib/sequel/database/schema_generator.rb

@@ -110,6 +110,9 @@ module Sequel
       #                yet exist on referenced table (but will exist before the transaction commits).
       #                Basically it adds DEFERRABLE INITIALLY DEFERRED on key creation.
       #                If you use :immediate as the value, uses DEFERRABLE INITIALLY IMMEDIATE.
+      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
+      #                         if generated columns are supported (PostgreSQL 12+, MariaDB 5.2.0+,
+      #                         and MySQL 5.7.6+).
       # :index :: Create an index on this column.  If given a hash, use the hash as the
       #           options for the index.
       # :key :: For foreign key columns, the column in the associated table
@@ -126,15 +129,21 @@ module Sequel
       #                 be used if you have a single, nonautoincrementing primary key column
       #                 (use the primary_key method in that case).
       # :primary_key_constraint_name :: The name to give the primary key constraint
+      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
+      #                            if :primary_key is used.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
       # :unique_constraint_name :: The name to give the unique key constraint
+      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
+      #                       is used.
+      #
+      # PostgreSQL specific options:
+      #
+      # :identity :: Create an identity column.
       #
       # MySQL specific options:
-      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
-      #                         if generated columns are supported.
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
       def column(name, type, opts = OPTS)
@@ -634,7 +643,7 @@ module Sequel
 
       # Drop a composite foreign key constraint
       def drop_composite_foreign_key(columns, opts)
-        @operations << {:op => :drop_constraint, :type => :foreign_key, :columns => columns}.merge!(opts)
+        @operations << opts.merge(:op => :drop_constraint, :type => :foreign_key, :columns => columns)
         nil
       end
     end

data/lib/sequel/database/schema_methods.rb

@@ -586,6 +586,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' PRIMARY KEY'
+        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
       end
     end
     
@@ -606,6 +607,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' UNIQUE'
+        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
       end
     end
     

data/lib/sequel/database/transactions.rb

@@ -25,13 +25,19 @@ module Sequel
     # Otherwise, add the block to the list of blocks to call after the currently
     # in progress transaction commits (and only if it commits).
     # Options:
+    # :savepoint :: If currently inside a savepoint, only run this hook on transaction
+    #               commit if all enclosing savepoints have been released.
     # :server :: The server/shard to use.
     def after_commit(opts=OPTS, &block)
       raise Error, "must provide block to after_commit" unless block
       synchronize(opts[:server]) do |conn|
         if h = _trans(conn)
           raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
-          add_transaction_hook(conn, :after_commit, block)
+          if opts[:savepoint] && in_savepoint?(conn)
+            add_savepoint_hook(conn, :after_commit, block)
+          else
+            add_transaction_hook(conn, :after_commit, block)
+          end
         else
           yield
         end
@@ -42,13 +48,20 @@ module Sequel
     # Otherwise, add the block to the list of the blocks to call after the currently
     # in progress transaction rolls back (and only if it rolls back).
     # Options:
+    # :savepoint :: If currently inside a savepoint, run this hook immediately when
+    #               any enclosing savepoint is rolled back, which may be before the transaction
+    #               commits or rollsback.
     # :server :: The server/shard to use.
     def after_rollback(opts=OPTS, &block)
       raise Error, "must provide block to after_rollback" unless block
       synchronize(opts[:server]) do |conn|
         if h = _trans(conn)
           raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
-          add_transaction_hook(conn, :after_rollback, block)
+          if opts[:savepoint] && in_savepoint?(conn)
+            add_savepoint_hook(conn, :after_rollback, block)
+          else
+            add_transaction_hook(conn, :after_rollback, block)
+          end
         end
       end
     end
@@ -298,6 +311,13 @@ module Sequel
       Sequel.synchronize{@transactions[conn] = hash}
     end    
 
+    # Set the given callable as a hook to be called. Type should be either
+    # :after_commit or :after_rollback.
+    def add_savepoint_hook(conn, type, block)
+      savepoint = _trans(conn)[:savepoints].last
+      (savepoint[type] ||= []) << block
+    end
+
     # Set the given callable as a hook to be called. Type should be either
     # :after_commit or :after_rollback.
     def add_transaction_hook(conn, type, block)
@@ -401,6 +421,14 @@ module Sequel
       supports_savepoints? && savepoint_level(conn) > 1
     end
 
+    # Retrieve the savepoint hooks that should be run for the given
+    # connection and commit status.
+    def savepoint_hooks(conn, committed)
+      if in_savepoint?(conn)
+        _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
+      end
+    end
+
     # Retrieve the transaction hooks that should be run for the given
     # connection and commit status.
     def transaction_hooks(conn, committed)
@@ -411,16 +439,40 @@ module Sequel
 
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
-      callbacks = transaction_hooks(conn, committed)
+      if in_savepoint?(conn)
+        savepoint_callbacks = savepoint_hooks(conn, committed)
+        if committed
+          savepoint_rollback_callbacks = savepoint_hooks(conn, false)
+        end
+      else
+        callbacks = transaction_hooks(conn, committed)
+      end
 
       if transaction_finished?(conn)
         h = _trans(conn)
         rolled_back = !committed
         Sequel.synchronize{h[:rolled_back] = rolled_back}
         Sequel.synchronize{@transactions.delete(conn)}
+        callbacks.each(&:call) if callbacks
+      elsif savepoint_callbacks || savepoint_rollback_callbacks
+        if committed
+          meth = in_savepoint?(conn) ? :add_savepoint_hook : :add_transaction_hook 
+
+          if savepoint_callbacks
+            savepoint_callbacks.each do |block|
+              send(meth, conn, :after_commit, block)
+            end
+          end
+          
+          if savepoint_rollback_callbacks
+            savepoint_rollback_callbacks.each do |block|
+              send(meth, conn, :after_rollback, block)
+            end
+          end
+        else
+          savepoint_callbacks.each(&:call)
+        end
       end
-
-      callbacks.each(&:call) if callbacks
     end
 
     # SQL to rollback to a savepoint

data/lib/sequel/dataset.rb

@@ -20,8 +20,10 @@ module Sequel
   #   old_posts = posts.where{stamp < Date.today - 7}
   #   davids_old_posts = davids_posts.where{stamp < Date.today - 7}
   #
-  # Datasets are Enumerable objects, so they can be manipulated using any
-  # of the Enumerable methods, such as map, inject, etc.
+  # Datasets are Enumerable objects, so they can be manipulated using many
+  # of the Enumerable methods, such as +map+ and +inject+.  Note that there are some methods
+  # that Dataset defines that override methods defined in Enumerable and result in different
+  # behavior, such as +select+ and +group_by+.
   #
   # For more information, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].
   class Dataset

data/lib/sequel/dataset/actions.rb

@@ -333,6 +333,7 @@ module Sequel
     #                  after every 50 records.
     # :return :: When this is set to :primary_key, returns an array of
     #            autoincremented primary key values for the rows inserted.
+    #            This does not have an effect if +values+ is a Dataset.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.
@@ -1069,7 +1070,7 @@ module Sequel
 
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
-      if @db.sharded?
+      if @db.sharded? && !opts.has_key?(:server)
         opts = Hash[opts]
         opts[:server] = @opts[:server] || :default
       end
@@ -1080,7 +1081,7 @@ module Sequel
     # :read_only server unless a specific server is set.
     def execute(sql, opts=OPTS, &block)
       db = @db
-      if db.sharded?
+      if db.sharded? && !opts.has_key?(:server)
         opts = Hash[opts]
         opts[:server] = @opts[:server] || (@opts[:lock] ? :default : :read_only)
         opts

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -170,7 +170,10 @@ module Sequel
       # receiver's dataset to the block, and the block should return the new dataset
       # to use.
       def with_dataset
-        dup.instance_exec{@dataset = yield @dataset; self}.freeze
+        dataset = yield @dataset
+        other = dup
+        other.instance_variable_set(:@dataset, dataset)
+        other.freeze
       end
 
       # Return an array of all objects by running the SQL query for the given arguments.

data/lib/sequel/dataset/query.rb

@@ -1062,6 +1062,10 @@ module Sequel
     # :args :: Specify the arguments/columns for the CTE, should be an array of symbols.
     # :recursive :: Specify that this is a recursive CTE
     #
+    # PostgreSQL Specific Options:
+    # :materialized :: Set to false to force inlining of the CTE, or true to force not inlining
+    #                  the CTE (PostgreSQL 12+).
+    #
     #   DB[:items].with(:items, DB[:syx].where(Sequel[:name].like('A%')))
     #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%' ESCAPE '\')) SELECT * FROM items
     def with(name, dataset, opts=OPTS)
@@ -1091,7 +1095,7 @@ module Sequel
     #   #   SELECT i1.id, i1.parent_id FROM i1 INNER JOIN t ON (t.id = i1.parent_id)
     #   # ) SELECT * FROM t
     def with_recursive(name, nonrecursive, recursive, opts=OPTS)
-      raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
+      raise(Error, 'This dataset does not support common table expressions') unless supports_cte?
       if hoist_cte?(nonrecursive)
         s, ds = hoist_cte(nonrecursive)
         s.with_recursive(name, ds, recursive, opts)

data/lib/sequel/dataset/sql.rb

@@ -1510,13 +1510,7 @@ module Sequel
       comma = ', '
       ws.each do |w|
         sql << comma if c
-        quote_identifier_append(sql, w[:name])
-        if args = w[:args]
-         sql << '('
-         identifier_list_append(sql, args)
-         sql << ')'
-        end
-        sql << ' AS '
+        select_with_sql_prefix(sql, w)
         literal_dataset_append(sql, w[:dataset])
         c ||= true
       end
@@ -1530,6 +1524,16 @@ module Sequel
       "WITH "
     end
 
+    def select_with_sql_prefix(sql, w)
+      quote_identifier_append(sql, w[:name])
+      if args = w[:args]
+       sql << '('
+       identifier_list_append(sql, args)
+       sql << ')'
+      end
+      sql << ' AS '
+    end
+
     # Whether the symbol cache should be skipped when literalizing the dataset
     def skip_symbol_cache?
       @opts[:skip_symbol_cache]

data/lib/sequel/extensions/named_timezones.rb

@@ -2,18 +2,21 @@
 #
 # Allows the use of named timezones via TZInfo (requires tzinfo).
 # Forces the use of DateTime as Sequel's datetime_class, since
-# ruby's Time class doesn't support timezones other than local
-# and UTC.
+# historically, Ruby's Time class doesn't support timezones other
+# than local and UTC. To continue using Ruby's Time class when using
+# the named_timezones extension:
+#
+#   # Load the extension
+#   Sequel.extension :named_timezones
+#
+#   # Set Sequel.datetime_class back to Time
+#   Sequel.datetime_class = Time
 #
 # This allows you to either pass strings or TZInfo::Timezone
 # instance to Sequel.database_timezone=, application_timezone=, and
 # typecast_timezone=.  If a string is passed, it is converted to a
 # TZInfo::Timezone using TZInfo::Timezone.get.
 #
-# To load the extension:
-#
-#   Sequel.extension :named_timezones
-#
 # Let's say you have the database server in New York and the
 # application server in Los Angeles.  For historical reasons, data
 # is stored in local New York time, but the application server only
@@ -37,7 +40,8 @@
 # Note that typecasting from the database timezone to the application
 # timezone when fetching rows is dependent on the database adapter,
 # and only works on adapters where Sequel itself does the conversion.
-# It should work on mysql, postgres, sqlite, ibmdb, and jdbc.
+# It should work with the mysql, postgres, sqlite, ibmdb, and jdbc
+# adapters.
 #
 # Related module: Sequel::NamedTimezones
 
@@ -63,9 +67,48 @@ module Sequel
 
     private 
     
+    if RUBY_VERSION >= '2.6'
+      # Convert the given input Time (which must be in UTC) to the given input timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_input_time_other(v, input_timezone)
+        Time.new(v.year, v.mon, v.day, v.hour, v.min, (v.sec + Rational(v.nsec, 1000000000)), input_timezone)
+      rescue TZInfo::AmbiguousTime
+        raise unless disamb = tzinfo_disambiguator_for(v)
+        period = input_timezone.period_for_local(v, &disamb)
+        offset = period.utc_total_offset
+        Time.at(v.to_i - offset, :in => input_timezone)
+      end
+
+      # Convert the given input Time to the given output timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_output_time_other(v, output_timezone)
+        Time.at(v.to_i, :in => output_timezone)
+      end
+    else
+      # :nodoc:
+      # :nocov:
+      def convert_input_time_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+      end
+
+      if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + local_offset
+        end
+      else
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+        end
+      end
+    end
+
     # Handle both TZInfo 1 and TZInfo 2
     if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
-      # :nodoc:
       def convert_input_datetime_other(v, input_timezone)
         local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
         (v - local_offset).new_offset(local_offset)
@@ -78,6 +121,7 @@ module Sequel
         DateTime.jd(v.jd, v.hour, v.minute, v.second + v.sec_fraction, v.offset, v.start)
       end
       # :nodoc:
+      # :nocov:
     else
       # Assume the given DateTime has a correct time but a wrong timezone.  It is
       # currently in UTC timezone, but it should be converted to the input_timezone.

data/lib/sequel/extensions/pg_array.rb

@@ -340,14 +340,18 @@ module Sequel
             raise Sequel::Error, "invalid array, empty string" if eos?
             raise Sequel::Error, "invalid array, doesn't start with {" unless scan(/((\[\d+:\d+\])+=)?\{/)
 
+            # :nocov:
             while !eos?
+            # :nocov:
               char = scan(/[{}",]|[^{}",]+/)
               if char == ','
                 # Comma outside quoted string indicates end of current entry
                 new_entry
               elsif char == '"'
                 raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
+                # :nocov:
                 while true
+                # :nocov:
                   char = scan(/["\\]|[^"\\]+/)
                   if char == '\\'
                     @recorded << getch