sequel 4.46.0 → 4.49.0

data/lib/sequel/extensions/pg_row.rb

@@ -18,11 +18,14 @@
 # for HashRow and ArrayRow using the standard Sequel literalization callbacks, so
 # they work with on all adapters.
 #
-# The first thing you are going to want to do is to load the extension into
-# your Database object.  Make sure you load the :pg_array extension first
-# if you plan to use composite types in bound variables:
+# To use this extension, first load it into the Database instance:
+#
+#   DB.extension :pg_row
+#
+# If you plan to use arrays of composite types, make sure you load the
+# pg_array extension first:
 # 
-#   DB.extension(:pg_array, :pg_row)
+#   DB.extension :pg_array, :pg_row
 #
 # You can create an anonymous row type by calling the Sequel.pg_row with
 # an array:
@@ -85,13 +88,15 @@
 
 require 'delegate'
 require 'strscan'
-Sequel.require 'adapters/utils/pg_types'
+Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
     module PGRow
       ROW = 'ROW'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROW)
       CAST = '::'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CAST)
 
       # Class for row-valued/composite types that are treated as arrays. By default,
       # this is only used for generic PostgreSQL record types, as registered
@@ -130,10 +135,10 @@ module Sequel
 
         # Append SQL fragment related to this object to the sql.
         def sql_literal_append(ds, sql)
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, to_a)
           if db_type
-            sql << CAST
+            sql << '::'
             ds.quote_schema_table_append(sql, db_type)
           end
         end
@@ -202,16 +207,16 @@ module Sequel
         # Append SQL fragment related to this object to the sql.
         def sql_literal_append(ds, sql)
           check_columns!
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, values_at(*columns))
           if db_type
-            sql << CAST
+            sql << '::'
             ds.quote_schema_table_append(sql, db_type)
           end
         end
       end
 
-      ROW_TYPE_CLASSES = [HashRow, ArrayRow]
+      ROW_TYPE_CLASSES = [HashRow, ArrayRow]#.freeze # SEQUEL5
 
       # This parser-like class splits the PostgreSQL
       # row-valued/composite type output string format
@@ -221,32 +226,41 @@ module Sequel
       # PostgreSQL uses.
       class Splitter < StringScanner
         OPEN_PAREN = /\(/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :OPEN_PAREN)
         CLOSE_PAREN = /\)/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :CLOSE_PAREN)
         UNQUOTED_RE = /[^,)]*/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :UNQUOTED_RE)
         SEP_RE = /[,)]/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :SEP_RE)
         QUOTE_RE = /"/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :QUOTE_RE)
         QUOTE_SEP_RE = /"[,)]/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :QUOTE_SEP_RE)
         QUOTED_RE = /(\\.|""|[^"])*/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :QUOTED_RE)
         REPLACE_RE = /\\(.)|"(")/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :REPLACE_RE)
         REPLACE_WITH = '\1\2'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :REPLACE_WITH)
 
         # Split the stored string into an array of strings, handling
         # the different types of quoting.
         def parse
           return @result if @result
           values = []
-          skip(OPEN_PAREN)
-          if skip(CLOSE_PAREN)
+          skip(/\(/)
+          if skip(/\)/)
             values << nil
           else
             until eos?
-              if skip(QUOTE_RE)
-                values << scan(QUOTED_RE).gsub(REPLACE_RE, REPLACE_WITH)
-                skip(QUOTE_SEP_RE)
+              if skip(/"/)
+                values << scan(/(\\.|""|[^"])*/).gsub(/\\(.)|"(")/, '\1\2')
+                skip(/"[,)]/)
               else
-                v = scan(UNQUOTED_RE)
+                v = scan(/[^,)]*/)
                 values << (v unless v.empty?)
-                skip(SEP_RE)
+                skip(/[,)]/)
               end
             end
           end
@@ -374,8 +388,11 @@ module Sequel
 
       module DatabaseMethods
         ESCAPE_RE = /("|\\)/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
         ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
         COMMA = ','.freeze
+        Sequel::Deprecation.deprecate_constant(self, :COMMA)
 
         # A hash mapping row type keys (usually symbols), to option
         # hashes.  At the least, the values will contain the :parser
@@ -384,17 +401,14 @@ module Sequel
 
         # Do some setup for the data structures the module uses.
         def self.extended(db)
-          # Return right away if row_types has already been set. This
-          # makes things not break if a user extends the database with
-          # this module more than once (since extended is called every
-          # time).
-          return if db.row_types
-
           db.instance_eval do
             @row_types = {}
             @row_schema_types = {}
             extend(@row_type_method_module = Module.new)
-            copy_conversion_procs([2249, 2287])
+            add_conversion_proc(2249, PGRow::Parser.new(:converter=>PGRow::ArrayRow))
+            if respond_to?(:register_array_type)
+              register_array_type('record', :oid=>2287, :scalar_oid=>2249)
+            end
           end
         end
 
@@ -402,10 +416,10 @@ module Sequel
         def bound_variable_arg(arg, conn)
           case arg
           when ArrayRow
-            "(#{arg.map{|v| bound_variable_array(v) if v}.join(COMMA)})"
+            "(#{arg.map{|v| bound_variable_array(v) if v}.join(',')})"
           when HashRow
             arg.check_columns!
-            "(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(COMMA)})"
+            "(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',')})"
           else
             super
           end
@@ -419,6 +433,8 @@ module Sequel
           super
         end
 
+        STRING_TYPES = [18, 19, 25, 1042, 1043].freeze
+
         # Register a new row type for the Database instance. db_type should be the type
         # symbol.  This parses the PostgreSQL system tables to get information the
         # composite type, and by default has the type return instances of a subclass
@@ -471,12 +487,22 @@ module Sequel
 
           # Using the conversion_procs, lookup converters for each member of the composite type
           parser_opts[:column_converters] = parser_opts[:column_oids].map do |oid|
+            # procs[oid] # SEQUEL5
+
+            # SEQUEL5: Remove
             if pr = procs[oid]
               pr
-            elsif !Sequel::Postgres::STRING_TYPES.include?(oid)
+            elsif !STRING_TYPES.include?(oid)
               # It's not a string type, and it's possible a conversion proc for this
               # oid will be added later, so do a runtime check for it.
-              lambda{|s| (pr = procs[oid]) ? pr.call(s) : s}
+              lambda do |s|
+                if (pr = procs[oid])
+                  Sequel::Deprecation.deprecate("Calling conversion proc for subtype (oid: #{oid}) of composite type (oid: #{parser_opts[:oid]}) not added until after composite type registration", "Register subtype conversion procs before registering composite type")
+                  pr.call(s)
+                else
+                  s
+                end
+              end
             end
           end
 
@@ -485,15 +511,15 @@ module Sequel
           parser_opts[:typecaster] = opts.fetch(:typecaster, parser_opts[:converter])
 
           parser = Parser.new(parser_opts)
-          @conversion_procs[parser.oid] = parser
+          add_conversion_proc(parser.oid, parser)
 
-          if defined?(PGArray) && PGArray.respond_to?(:register) && array_oid && array_oid > 0
+          if respond_to?(:register_array_type) && array_oid && array_oid > 0
             array_type_name = if type_schema
               "#{type_schema}.#{type_name}"
             else
               type_name
             end
-            PGArray.register(array_type_name, :oid=>array_oid, :converter=>parser, :type_procs=>@conversion_procs, :scalar_typecast=>schema_type_symbol)
+            register_array_type(array_type_name, :oid=>array_oid, :converter=>parser, :scalar_typecast=>schema_type_symbol)
           end
 
           @row_types[literal(db_type)] = opts.merge(:parser=>parser, :type=>db_type)
@@ -507,12 +533,11 @@ module Sequel
             private meth
           end
 
-          conversion_procs_updated
+          conversion_procs_updated # SEQUEL5: Remove
           nil
         end
 
-        # When reseting conversion procs, reregister all the row types so that
-        # the system tables are introspected again, picking up database changes.
+        # SEQUEL5: Remove
         def reset_conversion_procs
           procs = super
 
@@ -558,10 +583,10 @@ module Sequel
         def bound_variable_array(arg)
           case arg
           when ArrayRow
-            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
           when HashRow
             arg.check_columns!
-            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
           else
             super
           end
@@ -578,10 +603,14 @@ module Sequel
       end
     end
 
-    # Register the default anonymous record type
-    PG_TYPES[2249] = PGRow::Parser.new(:converter=>PGRow::ArrayRow)
+    # SEQUEL5: Remove
+    parser = PGRow::Parser.new(:converter=>PGRow::ArrayRow)
+    PG__TYPES[2249] = lambda do |s|
+      Sequel::Deprecation.deprecate("Conversion proc for record added globally by pg_row extension", "Load the pg_row extension into the Database instance")
+      parser.call(s)
+    end
     if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('record', :oid=>2287, :scalar_oid=>2249)
+      PGArray.register('record', :oid=>2287, :scalar_oid=>2249, :skip_deprecation_warning=>true)
     end
   end
 

data/lib/sequel/extensions/pg_row_ops.rb

@@ -70,7 +70,7 @@
 #
 # By casting the expression, you can get a composite type returned:
 #
-#   DB[:a].select(a.splat).first # SELECT (a.*)::a FROM a
+#   DB[:a].select(a.splat(:a)).first # SELECT (a.*)::a FROM a
 #   # => {:a=>"(1,2)"} # or {:a=>{:a=>1, :b=>2}} if the "a" type has been registered
 #                      # with the pg_row extension
 #
@@ -89,14 +89,20 @@ module Sequel
     # This class represents a composite type expression reference.
     class PGRowOp < SQL::PlaceholderLiteralString
       OPEN = '('.freeze
+      Sequel::Deprecation.deprecate_constant(self, :OPEN)
       CLOSE_DOT = ').'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CLOSE_DOT)
       CLOSE_STAR = '.*)'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CLOSE_STAR)
       CLOSE_STAR_CAST = '.*)::'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CLOSE_STAR_CAST)
       EMPTY = "".freeze
-      ROW = [OPEN, CLOSE_STAR].freeze
-      ROW_CAST = [OPEN, CLOSE_STAR_CAST].freeze
-      QUALIFY = [OPEN, CLOSE_DOT].freeze
-      WRAP = [EMPTY].freeze
+      Sequel::Deprecation.deprecate_constant(self, :EMPTY)
+
+      ROW = ['(', '.*)'].freeze.each(&:freeze)
+      ROW_CAST = ['(', '.*)::'].freeze.each(&:freeze)
+      QUALIFY = ['(', ').'].freeze.each(&:freeze)
+      WRAP = [""].freeze.each(&:freeze)
 
       # Wrap the expression in a PGRowOp, without changing the
       # SQL it would use.

data/lib/sequel/extensions/query_literals.rb

@@ -35,6 +35,8 @@
 #
 # Related module: Sequel::QueryLiterals
 
+Sequel::Deprecation.deprecate("The query_literals extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   # The QueryLiterals module can be used to make select, group, and

data/lib/sequel/extensions/ruby18_symbol_extensions.rb

@@ -22,3 +22,5 @@ class Symbol
     Sequel::SQL::Function.new(self, *args)
   end
 end
+
+# SEQUEL5: Remove extension

data/lib/sequel/extensions/s.rb

@@ -27,7 +27,7 @@
 #
 # or just into Object if you want it available everywhere:
 #
-#   Object.send(:include, Sequel::SQL)
+#   Object.send(:include, Sequel::S)
 #
 # If you are using Ruby 2+, and you would like to use refinements, you
 # can use Sequel::S as a refinement, in which case the private #S method

data/lib/sequel/extensions/schema_dumper.rb

@@ -20,8 +20,12 @@ module Sequel
     # be :type.  The other options added should modify that type (e.g. :size).  If a
     # database type is not recognized, return it as a String type.
     def column_schema_to_ruby_type(schema)
-      case schema[:db_type].downcase
-      when /\A(medium|small)?int(?:eger)?(?:\((\d+)\))?( unsigned)?\z/o
+      type = schema[:db_type].downcase
+      if database_type == :oracle
+        type = type.sub(/ not null\z/, '')
+      end
+      case type
+      when /\A(medium|small)?int(?:eger)?(?:\((\d+)\))?( unsigned)?\z/
         if !$1 && $2 && $2.to_i >= 10 && $3
           # Unsigned integer type with 10 digits can potentially contain values which
           # don't fit signed integer type, so use bigint type in target database.
@@ -29,36 +33,36 @@ module Sequel
         else
           {:type=>Integer}
         end
-      when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/o
+      when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
-      when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
+      when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/
         {:type=>:Bignum}
-      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
         {:type=>Float}
       when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}
-      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
+      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/
         {:type=>String, :text=>true}
       when 'date'
         {:type=>Date}
-      when /\A(?:small)?datetime\z/o
+      when /\A(?:small)?datetime\z/
         {:type=>DateTime}
-      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/o
+      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/
         {:type=>DateTime, :size=>($1.to_i if $1)}
-      when /\Atime(?: with(?:out)? time zone)?\z/o
+      when /\Atime(?: with(?:out)? time zone)?\z/
         {:type=>Time, :only_time=>true}
-      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
+      when /\An?char(?:acter)?(?:\((\d+)\))?\z/
         {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
-      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+      when /\A(?:n?varchar2?|character varying|bpchar|string)(?:\((\d+)\))?\z/
         {:type=>String, :size=>($1.to_i if $1)}
-      when /\A(?:small)?money\z/o
+      when /\A(?:small)?money\z/
         {:type=>BigDecimal, :size=>[19,2]}
-      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/
         s = [($1.to_i if $1), ($2.to_i if $2)].compact
         {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
-      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
+      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/
         {:type=>File, :size=>($1.to_i if $1)}
-      when /\A(?:year|(?:int )?identity)\z/o
+      when /\A(?:year|(?:int )?identity)\z/
         {:type=>Integer}
       else
         {:type=>String}
@@ -77,7 +81,7 @@ module Sequel
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+#{ts.sort_by(&:to_s).map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
@@ -95,7 +99,7 @@ END_MIG
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+#{ts.sort_by(&:to_s).map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
@@ -129,13 +133,13 @@ END_MIG
         # alter_table/add_foreign_key.  Note that skipped foreign keys
         # probably result in a broken down migration.
         sfka = sfk.sort_by{|table, fks| table.to_s}.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
-        sfka.join("\n\n").gsub(/^/o, '    ') unless sfka.empty?
+        sfka.join("\n\n").gsub(/^/, '    ') unless sfka.empty?
       end
 
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}#{"\n    \n" if skipped_fks}#{skipped_fks}
+#{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/, '    ')}#{"\n    \n" if skipped_fks}#{skipped_fks}
   end
 end
 END_MIG
@@ -146,7 +150,7 @@ END_MIG
     def dump_table_schema(table, options=OPTS)
       gen = dump_table_generator(table, options)
       commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
-      "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && !gen.indexes.empty?}) do\n#{commands.gsub(/^/o, '  ')}\nend"
+      "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && !gen.indexes.empty?}) do\n#{commands.gsub(/^/, '  ')}\nend"
     end
 
     private
@@ -454,11 +458,11 @@ END_MIG
 
       # Dump this generator's indexes to a string that could be evaled inside
       # another instance to represent the same indexes. Options:
-      # * :add_index - Use add_index instead of index, so the methods
-      #   can be called outside of a generator but inside a migration.
-      #   The value of this option should be the table name to use.
-      # * :drop_index - Same as add_index, but create drop_index statements.
-      # * :ignore_errors - Add the ignore_errors option to the outputted indexes
+      # :add_index :: Use add_index instead of index, so the methods
+      #               can be called outside of a generator but inside a migration.
+      #               The value of this option should be the table name to use.
+      # :drop_index :: Same as add_index, but create drop_index statements.
+      # :ignore_errors :: Add the ignore_errors option to the outputted indexes
       def dump_indexes(options=OPTS)
         is = indexes.map do |c|
           c = c.dup

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -23,6 +23,8 @@
 #
 # Related module: Sequel::Sequel3DatasetMethods
 
+Sequel::Deprecation.deprecate("The sequel_3_dataset_methods extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   module Sequel3DatasetMethods
@@ -122,7 +124,7 @@ module Sequel
       cols = n.columns
       csv = String.new
       csv << "#{cols.join(', ')}\r\n" if include_column_titles
-      n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(', ')}\r\n"}
+      n.each{|r| csv << "#{cols.map{|c| r[c]}.join(', ')}\r\n"}
       csv
     end
   end

data/lib/sequel/extensions/sequel_4_dataset_methods.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+#
+# This adds the following dataset methods:
+#
+# and :: alias for where
+# exclude_where :: alias for exclude
+# interval :: Returns max - min, using a single query
+# range :: Returns min..max, using a single query
+#
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:sequel_4_dataset_methods)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:sequel_4_dataset_methods)
+#
+# Related module: Sequel::Sequel4DatasetMethods
+
+#
+module Sequel
+  module Sequel4DatasetMethods
+    # Alias for where.
+    def and(*cond, &block)
+      where(*cond, &block)
+    end
+    
+    # Alias for exclude.
+    def exclude_where(*cond, &block)
+      exclude(*cond, &block)
+    end
+
+    # Returns the interval between minimum and maximum values for the given 
+    # column/expression. Uses a virtual row block if no argument is given.
+    #
+    #   DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
+    #   # => 6
+    #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
+    #   # => 7
+    def interval(column=Sequel.virtual_row(&Proc.new))
+      if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
+          arg = pl.arg
+          aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
+        end
+
+        loader.get(column)
+      else
+        aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
+      end
+    end
+
+    # Returns a +Range+ instance made from the minimum and maximum values for the
+    # given column/expression.  Uses a virtual row block if no argument is given.
+    #
+    #   DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
+    #   # => 1..10
+    #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
+    #   # => 0..7
+    def range(column=Sequel.virtual_row(&Proc.new))
+      r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
+            arg = pl.arg
+            aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
+          end
+
+        loader.first(column)
+      else
+        aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
+      end
+
+      if r
+        (r[:v1]..r[:v2])
+      end
+    end
+    
+  end
+
+  Dataset.register_extension(:sequel_4_dataset_methods, Sequel4DatasetMethods)
+end
+

data/lib/sequel/extensions/server_block.rb

@@ -16,7 +16,7 @@
 #   end
 #   DB[:a].all # Uses default
 #
-# You can even nest calls to with_server:
+# You can nest calls to with_server:
 #
 #   DB.with_server(:shard1) do
 #     DB[:a].all # Uses shard1
@@ -39,6 +39,19 @@
 #     DB[:a].server(:read_only).all # Uses shard1
 #   end
 #
+# If you pass two separate shards to with_server, the second shard will
+# be used instead of the :read_only shard, and the first shard will be
+# used instead of the :default shard:
+#
+#   DB.with_server(:shard1, :shard2) do
+#     DB[:a].all # Uses shard2
+#     DB[:a].delete # Uses shard1
+#     DB[:a].server(:shard3).all # Uses shard3
+#     DB[:a].server(:shard3).delete # Uses shard3
+#     DB[:a].server(:default).all # Uses shard1
+#     DB[:a].server(:read_only).delete # Uses shard2
+#   end
+#
 # Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
 # Sequel::ThreadedServerBlock
 
@@ -60,17 +73,17 @@ module Sequel
     end
 
     # Delegate to the connection pool
-    def with_server(server, &block)
-      pool.with_server(server, &block)
+    def with_server(default_server, read_only_server=default_server, &block)
+      pool.with_server(default_server, read_only_server, &block)
     end
   end
 
   # Adds with_server support for the sharded single connection pool.
   module UnthreadedServerBlock
     # Set a default server/shard to use inside the block.
-    def with_server(server)
+    def with_server(default_server, read_only_server=default_server)
       begin
-        set_default_server(server)
+        set_default_server(default_server, read_only_server)
         yield
       ensure
         clear_default_server
@@ -80,8 +93,8 @@ module Sequel
     private
 
     # Make the given server the new default server.
-    def set_default_server(server)
-      @default_servers << server
+    def set_default_server(default_server, read_only_server=default_server)
+      @default_servers << [default_server, read_only_server]
     end
 
     # Remove the current default server, restoring the
@@ -96,8 +109,10 @@ module Sequel
         super
       else
         case server
-        when :default, nil, :read_only
-          @default_servers.last
+        when :default, nil
+          @default_servers[-1][0]
+        when :read_only
+          @default_servers[-1][1]
         else
           super
         end
@@ -109,9 +124,9 @@ module Sequel
   module ThreadedServerBlock
     # Set a default server/shard to use inside the block for the current
     # thread.
-    def with_server(server)
+    def with_server(default_server, read_only_server=default_server)
       begin
-        set_default_server(server)
+        set_default_server(default_server, read_only_server)
         yield
       ensure
         clear_default_server
@@ -121,8 +136,8 @@ module Sequel
     private
 
     # Make the given server the new default server for the current thread.
-    def set_default_server(server)
-      sync{(@default_servers[Thread.current] ||= [])} << server
+    def set_default_server(default_server, read_only_server=default_server)
+      sync{(@default_servers[Thread.current] ||= [])} << [default_server, read_only_server]
     end
 
     # Remove the current default server for the current thread, restoring the
@@ -141,8 +156,10 @@ module Sequel
         super
       else
         case server
-        when :default, nil, :read_only
-          a.last
+        when :default, nil
+          a[-1][0]
+        when :read_only
+          a[-1][1]
         else
           super
         end

data/lib/sequel/extensions/set_overrides.rb

@@ -73,8 +73,8 @@ module Sequel
     end
 
     # Dataset options that do not affect the generated SQL.
-    def non_sql_options
-      super + [:defaults, :overrides]
+    def non_sql_option?(key)
+      super || key == :defaults || key == :overrides
     end
   end