sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/schema_dumper.rb

@@ -6,6 +6,17 @@
 # the current database).  The main interface is through
 # Sequel::Database#dump_schema_migration.
 #
+# The schema_dumper extension is quite limited in what types of
+# database objects it supports.  In general, it only supports
+# dumping tables, columns, primary key and foreign key constraints,
+# and some indexes.  It does not support most table options, CHECK
+# constraints, partial indexes, database functions, triggers,
+# security grants/revokes, and a wide variety of other useful
+# database properties.  Be aware of the limitations when using the
+# schema_dumper extension. If you are dumping the schema to restore
+# to the same database type, it is recommended to use your database's
+# dump and restore programs instead of the schema_dumper extension.
+#
 # To load the extension:
 #
 #   DB.extension :schema_dumper
@@ -20,8 +31,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 +44,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+))?\))?(?: unsigned)?\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}
@@ -66,7 +81,7 @@ module Sequel
     end
 
     # Dump foreign key constraints for all tables as a migration. This complements
-    # the :foreign_keys=>false option to dump_schema_migration. This only dumps
+    # the foreign_keys: false option to dump_schema_migration. This only dumps
     # the constraints (not the columns) using alter_table/add_foreign_key with an
     # array of columns.
     #
@@ -77,14 +92,14 @@ 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.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
     # Dump indexes for all tables as a migration.  This complements
-    # the :indexes=>false option to dump_schema_migration. Options:
+    # the indexes: false option to dump_schema_migration. Options:
     # :same_db :: Create a dump for the same database type, so
     #             don't ignore errors if the index statements fail.
     # :index_names :: If set to false, don't record names of indexes. If
@@ -95,13 +110,13 @@ 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.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
-    # Return a string that contains a Sequel::Migration subclass that when
+    # Return a string that contains a Sequel migration that when
     # run would recreate the database structure. Options:
     # :same_db :: Don't attempt to translate database types to ruby types.
     #             If this isn't set to true, all database types will be translated to
@@ -128,14 +143,14 @@ END_MIG
         # Handle skipped foreign keys by adding them at the end via
         # 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 = sfk.sort.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
+        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 +161,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
@@ -163,13 +178,15 @@ END_MIG
       end
     end
 
-    # Recreate the column in the passed Schema::Generator from the given name and parsed database schema.
+    # Recreate the column in the passed Schema::CreateTableGenerator from the given name and parsed database schema.
     def recreate_column(name, schema, gen, options)
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
         type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
-        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
+        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"} || type_hash == {:type=>"INTEGER"}
           type_hash.delete(:type)
+        elsif options[:same_db] && type_hash == {:type=>type_literal_generic_bignum_symbol(type_hash).to_s}
+          type_hash[:type] = :Bignum
         end
 
         unless gen.columns.empty?
@@ -193,20 +210,26 @@ END_MIG
         end
         type = col_opts.delete(:type)
         col_opts.delete(:size) if col_opts[:size].nil?
-        col_opts[:default] = if schema[:ruby_default].nil?
-          column_schema_to_ruby_default_fallback(schema[:default], options)
+        if schema[:generated]
+          if options[:same_db] && database_type == :postgres
+            col_opts[:generated_always_as] = column_schema_to_ruby_default_fallback(schema[:default], options)
+          end
         else
-          schema[:ruby_default]
+          col_opts[:default] = if schema[:ruby_default].nil?
+            column_schema_to_ruby_default_fallback(schema[:default], options)
+          else
+            schema[:ruby_default]
+          end
+          col_opts.delete(:default) if col_opts[:default].nil?
         end
-        col_opts.delete(:default) if col_opts[:default].nil?
         col_opts[:null] = false if schema[:allow_null] == false
         if table = schema[:table]
           [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}
-          col_opts[:type] = type unless type == Integer || type == 'integer'
+          col_opts[:type] = type unless type == Integer || type == 'integer' || type == 'INTEGER'
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if [Integer, :Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, :Bignum, Float, BigDecimal].include?(type) && schema[:db_type] =~ / unsigned\z/io
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end
@@ -219,7 +242,7 @@ END_MIG
       sfks = String.new
       sfks << "alter_table(#{table.inspect}) do\n"
       sfks << create_table_generator do
-        fks.sort_by{|fk| fk[:columns].map(&:to_s)}.each do |fk|
+        fks.sort_by{|fk| fk[:columns]}.each do |fk|
           foreign_key fk[:columns], fk
         end
       end.dump_constraints.gsub(/^foreign_key /, '  add_foreign_key ')
@@ -230,7 +253,7 @@ END_MIG
     # string that would add the foreign keys if run in a migration.
     def dump_table_foreign_keys(table, options=OPTS)
       if supports_foreign_key_parsing?
-        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map(&:to_s)}
+        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns]}
       end
 
       if fks.nil? || fks.empty?
@@ -240,17 +263,17 @@ END_MIG
       end
     end
 
-    # Return a Schema::Generator object that will recreate the
+    # Return a Schema::CreateTableGenerator object that will recreate the
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_generator(table, options=OPTS)
-      s = schema(table).dup
+      s = schema(table, options).dup
       pks = s.find_all{|x| x.last[:primary_key] == true}.map(&:first)
       options = options.merge(:single_pk=>true) if pks.length == 1
       m = method(:recreate_column)
       im = method(:index_to_generator_opts)
 
       if options[:indexes] != false && supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       end
 
       if options[:foreign_keys] != false && supports_foreign_key_parsing?
@@ -290,7 +313,7 @@ END_MIG
     # creating the index migration.
     def dump_table_indexes(table, meth, options=OPTS)
       if supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       else
         return ''
       end
@@ -302,7 +325,7 @@ END_MIG
       gen.dump_indexes(meth=>table, :ignore_errors=>!options[:same_db])
     end
 
-    # Convert the parsed index information into options to the Generators index method. 
+    # Convert the parsed index information into options to the CreateTableGenerator's index method. 
     def index_to_generator_opts(table, name, index_opts, options=OPTS)
       h = {}
       if options[:index_names] != false && default_index_name(table, index_opts[:columns]) != name.to_s
@@ -329,7 +352,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort_by(&:to_s)
+        tables.sort
       end
     end
 
@@ -354,14 +377,14 @@ END_MIG
           # outstanding foreign keys and skipping those foreign keys.
           # The skipped foreign keys will be added at the end of the
           # migration.
-          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table.to_s]}.first
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table]}.first
           skip_fks_hash = skipped_foreign_keys[skip_table] = {}
           skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
           this_loop << skip_table
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort_by(&:to_s))
+        sorted_tables.concat(this_loop.sort)
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}
@@ -378,7 +401,7 @@ END_MIG
   end
 
   module Schema
-    class Generator
+    class CreateTableGenerator
       # Dump this generator's columns to a string that could be evaled inside
       # another instance to represent the same columns
       def dump_columns
@@ -452,11 +475,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/select_remove.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 #
-# The select_remove extension adds Sequel::Dataset#select_remove for removing existing selected
+# The select_remove extension adds select_remove for removing existing selected
 # columns from a dataset.  It's not part of Sequel core as it is rarely needed and has
 # some corner cases where it can't work correctly.
 #
@@ -26,8 +26,8 @@ module Sequel
     #   # Assume columns a, b, and c in items table
     #   DB[:items] # SELECT * FROM items
     #   DB[:items].select_remove(:c) # SELECT a, b FROM items
-    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c) # SELECT a, c AS b FROM items
-    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c___b) # SELECT a, b AS c FROM items
+    #   DB[:items].select(:a, Sequel[:b].as(:c), Sequel[:c].as(:b)).select_remove(:c) # SELECT a, c AS b FROM items
+    #   DB[:items].select(:a, Sequel[:b][:c], Sequel[:c][:b]).select_remove(Sequel[:c][:b]) # SELECT a, b AS c FROM items
     #
     # Note that there are a few cases where this method may not work correctly:
     #
@@ -35,7 +35,7 @@ module Sequel
     #   In this case, the code will currently use unqualified column names for all columns
     #   the dataset returns, except for the columns given.
     # * This dataset has an existing explicit selection containing an item that returns
-    #   multiple database columns (e.g. Sequel.expr(:table).*, Sequel.lit('column1, column2')).  In this case,
+    #   multiple database columns (e.g. Sequel[:table].*, Sequel.lit('column1, column2')).  In this case,
     #   the behavior is undefined and this method should not be used.
     #
     # There may be other cases where this method does not work correctly, use it with caution.

data/lib/sequel/extensions/sequel_4_dataset_methods.rb

@@ -0,0 +1,85 @@
+# 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=(no_arg = true), &block)
+      column = Sequel.virtual_row(&block) if no_arg
+      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=(no_arg = true), &block)
+      column = Sequel.virtual_row(&block) if no_arg
+      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,25 @@
 #     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
+#
+# If you use an invalid server when calling with_server, it will be
+# treated the same way as if you called Dataset#server with an invalid
+# server.  By default, the default server will be used in such cases.
+# If you would like a different server to be used, or an exception to
+# be raised, then use the :servers_hash Database option.
+#
 # Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
 # Sequel::ThreadedServerBlock
 
@@ -60,28 +79,26 @@ 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)
-      begin
-        set_default_server(server)
-        yield
-      ensure
-        clear_default_server
-      end
+    def with_server(default_server, read_only_server=default_server)
+      set_default_server(default_server, read_only_server)
+      yield
+    ensure
+      clear_default_server
     end
 
     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 +113,10 @@ module Sequel
         super
       else
         case server
-        when :default, nil, :read_only
-          @default_servers.last
+        when :default, nil
+          @servers[@default_servers[-1][0]]
+        when :read_only
+          @servers[@default_servers[-1][1]]
         else
           super
         end
@@ -109,26 +128,24 @@ module Sequel
   module ThreadedServerBlock
     # Set a default server/shard to use inside the block for the current
     # thread.
-    def with_server(server)
-      begin
-        set_default_server(server)
-        yield
-      ensure
-        clear_default_server
-      end
+    def with_server(default_server, read_only_server=default_server)
+      set_default_server(default_server, read_only_server)
+      yield
+    ensure
+      clear_default_server
     end
 
     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[Sequel.current] ||= [])} << [default_server, read_only_server]
     end
 
     # Remove the current default server for the current thread, restoring the
     # previous default server.
     def clear_default_server
-      t = Thread.current
+      t = Sequel.current
       a = sync{@default_servers[t]}
       a.pop
       sync{@default_servers.delete(t)} if a.empty?
@@ -136,13 +153,20 @@ module Sequel
 
     # Use the server given to with_server for the given thread, if appropriate.
     def pick_server(server)
-      a = sync{@default_servers[Thread.current]}
+      a = sync{@default_servers[Sequel.current]}
       if !a || a.empty?
         super
       else
+        # Hash handling required to work when loaded after arbitrary servers plugin.
         case server
-        when :default, nil, :read_only
-          a.last
+        when :default, nil
+          v = a[-1][0]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
+        when :read_only
+          v = a[-1][1]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
         else
           super
         end

data/lib/sequel/extensions/split_array_nil.rb

@@ -3,7 +3,7 @@
 # The split_array_nil extension overrides Sequel's default handling of
 # IN/NOT IN with arrays of values to do specific nil checking.  For example,
 #
-#   ds = DB[:table].where(:column=>[1, nil])
+#   ds = DB[:table].where(column: [1, nil])
 # 
 # By default, that produces the following SQL:
 #
@@ -19,7 +19,7 @@
 #
 # Similarly, for NOT IN queries:
 #
-#   ds = DB[:table].exclude(:column=>[1, nil])
+#   ds = DB[:table].exclude(column: [1, nil])
 #   # Default:
 #   #   SELECT * FROM table WHERE (column NOT IN (1, NULL))
 #   # with split_array_nils extension:
@@ -46,9 +46,9 @@ module Sequel
       def complex_expression_sql_append(sql, op, args)
       case op
       when :IN, :"NOT IN"
-        vals = args.at(1)
+        vals = args[1]
         if vals.is_a?(Array) && vals.any?(&:nil?)
-          cols = args.at(0)
+          cols = args[0]
           vals = vals.compact
           c = Sequel::SQL::BooleanExpression
           if op == :IN