sequel 4.21.0 → 4.22.0

data/lib/sequel/database/schema_methods.rb

@@ -119,7 +119,7 @@ module Sequel
     # :no_index :: Set to true not to create the second index.
     # :no_primary_key :: Set to true to not create the primary key.
     def create_join_table(hash, options=OPTS)
-      keys = hash.keys.sort_by{|k| k.to_s}
+      keys = hash.keys.sort_by(&:to_s)
       create_table(join_table_name(hash, options), options) do
         keys.each do |key|
           v = hash[key]
@@ -781,7 +781,7 @@ module Sequel
         options[:name]
       else
         table_names = entries.map{|e| join_table_name_extract(e)}
-        table_names.map{|t| t.to_s}.sort.join('_')
+        table_names.map(&:to_s).sort.join('_')
       end
     end
 

data/lib/sequel/database/transactions.rb

@@ -80,7 +80,7 @@ module Sequel
         tot_retries = opts.fetch(:num_retries, 5)
         num_retries = 0 unless tot_retries.nil?
         begin
-          transaction(opts.merge(:retry_on=>nil, :retrying=>true), &block)
+          transaction(Hash[opts].merge!(:retry_on=>nil, :retrying=>true), &block)
         rescue *retry_on => e
           if num_retries
             num_retries += 1
@@ -100,7 +100,7 @@ module Sequel
               raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
             end
             if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
-              _transaction(conn, opts.merge(:savepoint=>true), &block)
+              _transaction(conn, Hash[opts].merge!(:savepoint=>true), &block)
             else
               return yield(conn)
             end
@@ -277,7 +277,7 @@ module Sequel
         callbacks = _trans(conn)[committed ? :after_commit : :after_rollback]
         Sequel.synchronize{@transactions.delete(conn)}
         if callbacks
-          callbacks.each{|b| b.call}
+          callbacks.each(&:call)
         end
       end
     end

data/lib/sequel/dataset/actions.rb

@@ -8,7 +8,7 @@ module Sequel
     # ---------------------
     
     # Action methods defined by Sequel that execute code on the database.
-    ACTION_METHODS = (<<-METHS).split.map{|x| x.to_sym}
+    ACTION_METHODS = (<<-METHS).split.map(&:to_sym)
       << [] all avg count columns columns! delete each
       empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
@@ -493,7 +493,8 @@ module Sequel
       total_limit = @opts[:limit]
       offset = @opts[:offset]
       if server = @opts[:server]
-        opts = opts.merge(:server=>server)
+        opts = Hash[opts]
+        opts[:server] = server
       end
 
       rows_per_fetch = opts[:rows_per_fetch] || 1000
@@ -701,7 +702,7 @@ module Sequel
           end
         end
       elsif key_column.is_a?(Array)
-        each{|r| h[r.values_at(*key_column)] = r}
+        each{|r| h[key_column.map{|k| r[k]}] = r}
       else
         each{|r| h[r[key_column]] = r}
       end
@@ -744,7 +745,7 @@ module Sequel
           end
         end
       elsif key_column.is_a?(Array)
-        each{|r| (h[r.values_at(*key_column)] ||= []) << r}
+        each{|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
       else
         each{|r| (h[r[key_column]] ||= []) << r}
       end
@@ -833,7 +834,7 @@ module Sequel
     # separate insert commands for each row.  Otherwise, call #multi_insert_sql
     # and execute each statement it gives separately.
     def _import(columns, values, opts)
-      trans_opts = opts.merge(:server=>@opts[:server])
+      trans_opts = Hash[opts].merge!(:server=>@opts[:server])
       if opts[:return] == :primary_key
         @db.transaction(trans_opts){values.map{|v| insert(columns, v)}}
       else
@@ -901,14 +902,23 @@ module Sequel
 
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
-      @db.sharded? ? {:server=>@opts[:server] || :default}.merge(opts) : opts
+      if @db.sharded?
+        opts = Hash[opts]
+        opts[:server] = @opts[:server] || :default
+      end
+      opts
     end
 
     # Execute the given select SQL on the database using execute. Use the
     # :read_only server unless a specific server is set.
     def execute(sql, opts=OPTS, &block)
       db = @db
-      db.execute(sql, db.sharded? ? {:server=>@opts[:server] || :read_only}.merge(opts) : opts, &block)
+      if db.sharded?
+        opts = Hash[opts]
+        opts[:server] = @opts[:server] || :read_only
+        opts
+      end
+      db.execute(sql, opts, &block)
     end
     
     # Execute the given SQL on the database using execute_ddl.
@@ -982,7 +992,7 @@ module Sequel
         [v, descending]
       end
 
-      row_values = yield(row, order_exprs.map{|e| e.first})
+      row_values = yield(row, order_exprs.map(&:first))
 
       last_expr = []
       cond = order_exprs.zip(row_values).map do |(v, descending), value|

data/lib/sequel/dataset/graph.rb

@@ -18,7 +18,7 @@ module Sequel
         raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
       end
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select_more(*columns).clone(:graph_aliases => ga.merge(graph_aliases))
+      select_more(*columns).clone(:graph_aliases => Hash[ga].merge!(graph_aliases))
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -72,7 +72,7 @@ module Sequel
       when SQL::QualifiedIdentifier
         table_alias ||= split_qualifiers(table).last
       when SQL::AliasedExpression
-        return graph(table.expression, join_conditions, {:table_alias=>table.alias}.merge(options), &block)
+        return graph(table.expression, join_conditions, {:table_alias=>table.alias}.merge!(options), &block)
       else
         raise Error, "The dataset argument should be a symbol or dataset"
       end

data/lib/sequel/dataset/prepared_statements.rb

@@ -7,6 +7,33 @@ module Sequel
     # ---------------------
     
     PREPARED_ARG_PLACEHOLDER = LiteralString.new('?').freeze
+
+    DEFAULT_PREPARED_STATEMENT_MODULE_METHODS = %w'execute execute_dui execute_insert'.freeze.each(&:freeze)
+    PREPARED_STATEMENT_MODULE_CODE = {
+      :bind => "opts = Hash[opts]; opts[:arguments] = bind_arguments".freeze,
+      :prepare => "sql = prepared_statement_name".freeze,
+      :prepare_bind => "sql = prepared_statement_name; opts = Hash[opts]; opts[:arguments] = bind_arguments".freeze
+    }.freeze
+
+    def self.prepared_statements_module(code, mods, meths=DEFAULT_PREPARED_STATEMENT_MODULE_METHODS, &block)
+      code = PREPARED_STATEMENT_MODULE_CODE[code] || code
+
+      Module.new do
+        Array(mods).each do |mod|
+          include mod
+        end
+
+        if block
+          module_eval(&block)
+        end
+
+        meths.each do |meth|
+          module_eval("def #{meth}(sql, opts=Sequel::OPTS) #{code}; super end", __FILE__, __LINE__)
+        end
+        private *meths
+      end
+    end
+    private_class_method :prepared_statements_module
     
     # Default implementation of the argument mapper to allow
     # native database support for bind variables and prepared
@@ -221,7 +248,7 @@ module Sequel
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
     def bind(bind_vars={})
-      clone(:bind_vars=>@opts[:bind_vars] ? @opts[:bind_vars].merge(bind_vars) : bind_vars)
+      clone(:bind_vars=>@opts[:bind_vars] ? Hash[@opts[:bind_vars]].merge!(bind_vars) : bind_vars)
     end
     
     # For the given type (:select, :first, :insert, :insert_select, :update, or :delete),

data/lib/sequel/dataset/query.rb

@@ -32,7 +32,7 @@ module Sequel
     JOIN_METHODS = (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES).map{|x| "#{x}_join".to_sym} + [:join, :join_table]
     
     # Methods that return modified datasets
-    QUERY_METHODS = (<<-METHS).split.map{|x| x.to_sym} + JOIN_METHODS
+    QUERY_METHODS = (<<-METHS).split.map(&:to_sym) + JOIN_METHODS
       add_graph_aliases and distinct except exclude exclude_having exclude_where
       filter for_update from from_self graph grep group group_and_count group_by having intersect invert
       limit lock_style naked offset or order order_append order_by order_more order_prepend qualify
@@ -74,10 +74,10 @@ module Sequel
     def clone(opts = nil)
       c = super()
       if opts
-        c.instance_variable_set(:@opts, @opts.merge(opts))
+        c.instance_variable_set(:@opts, Hash[@opts].merge!(opts))
         c.instance_variable_set(:@columns, nil) if @columns && !opts.each_key{|o| break if COLUMN_CHANGE_OPTS.include?(o)}
       else
-        c.instance_variable_set(:@opts, @opts.dup)
+        c.instance_variable_set(:@opts, Hash[@opts])
       end
       c
     end
@@ -584,7 +584,7 @@ module Sequel
     # Returns a cloned dataset without a row_proc.
     #
     #   ds = DB[:items]
-    #   ds.row_proc = proc{|r| r.invert}
+    #   ds.row_proc = proc(&:invert)
     #   ds.all # => [{2=>:id}]
     #   ds.naked.all # => [{:id=>2}]
     def naked
@@ -939,7 +939,7 @@ module Sequel
         s, ds = hoist_cte(dataset)
         s.with(name, ds, opts)
       else
-        clone(:with=>(@opts[:with]||[]) + [opts.merge(:name=>name, :dataset=>dataset)])
+        clone(:with=>(@opts[:with]||[]) + [Hash[opts].merge!(:name=>name, :dataset=>dataset)])
       end
     end
 
@@ -968,7 +968,7 @@ module Sequel
         s, ds = hoist_cte(recursive)
         s.with_recursive(name, nonrecursive, ds, opts)
       else
-        clone(:with=>(@opts[:with]||[]) + [opts.merge(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))])
+        clone(:with=>(@opts[:with]||[]) + [Hash[opts].merge!(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))])
       end
     end
     
@@ -1001,7 +1001,7 @@ module Sequel
         s, ds = hoist_cte(dataset)
         return s.compound_clone(type, ds, opts)
       end
-      ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, opts[:all]]])
+      ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map(&:dup) + [[type, dataset.compound_from_self, opts[:all]]])
       opts[:from_self] == false ? ds : ds.from_self(opts)
     end
 

data/lib/sequel/exceptions.rb

@@ -8,70 +8,73 @@ module Sequel
   end  
     
   # Error raised when the adapter requested doesn't exist or can't be loaded.
-  class AdapterNotFound < Error; end
+  AdapterNotFound = Class.new(Error)
 
   # Generic error raised by the database adapters, indicating a
   # problem originating from the database server.  Usually raised
   # because incorrect SQL syntax is used.
-  class DatabaseError < Error; end
+  DatabaseError = Class.new(Error)
   
   # Error raised when the Sequel is unable to connect to the database with the
   # connection parameters it was given.
-  class DatabaseConnectionError < DatabaseError; end
+  DatabaseConnectionError = Class.new(DatabaseError)
 
   # Error raised by adapters when they determine that the connection
   # to the database has been lost.  Instructs the connection pool code to 
   # remove that connection from the pool so that other connections can be acquired
   # automatically.
-  class DatabaseDisconnectError < DatabaseError; end
+  DatabaseDisconnectError = Class.new(DatabaseError)
 
   # Generic error raised when Sequel determines a database constraint has been violated.
-  class ConstraintViolation < DatabaseError; end
+  ConstraintViolation = Class.new(DatabaseError)
 
   # Error raised when Sequel determines a database check constraint has been violated.
-  class CheckConstraintViolation < ConstraintViolation; end
+  CheckConstraintViolation = Class.new(ConstraintViolation)
 
   # Error raised when Sequel determines a database foreign key constraint has been violated.
-  class ForeignKeyConstraintViolation < ConstraintViolation; end
+  ForeignKeyConstraintViolation = Class.new(ConstraintViolation)
 
   # Error raised when Sequel determines a database NOT NULL constraint has been violated.
-  class NotNullConstraintViolation < ConstraintViolation; end
+  NotNullConstraintViolation = Class.new(ConstraintViolation)
 
   # Error raised when Sequel determines a database unique constraint has been violated.
-  class UniqueConstraintViolation < ConstraintViolation; end
+  UniqueConstraintViolation = Class.new(ConstraintViolation)
 
   # Error raised when Sequel determines a serialization failure/deadlock in the database.
-  class SerializationFailure < DatabaseError; end
+  SerializationFailure = Class.new(DatabaseError)
 
   # Error raised on an invalid operation, such as trying to update or delete
   # a joined or grouped dataset.
-  class InvalidOperation < Error; end
+  InvalidOperation = Class.new(Error)
 
   # Error raised when attempting an invalid type conversion.
-  class InvalidValue < Error; end
+  InvalidValue = Class.new(Error)
 
   # Error raised when the user requests a record via the first! or similar
   # method, and the dataset does not yield any rows.
-  class NoMatchingRow < Error; end
+  NoMatchingRow = Class.new(Error)
 
   # Error raised when the connection pool cannot acquire a database connection
   # before the timeout.
-  class PoolTimeout < Error; end
+  PoolTimeout = Class.new(Error)
 
   # Error that you should raise to signal a rollback of the current transaction.
   # The transaction block will catch this exception, rollback the current transaction,
   # and won't reraise it (unless a reraise is requested).
-  class Rollback < Error; end
+  Rollback = Class.new(Error)
 
   # Error raised when unbinding a dataset that has multiple different values
   # for a given variable.
-  class UnbindDuplicate < Error; end
-
-  class Error
-    AdapterNotFound = Sequel::AdapterNotFound
-    InvalidOperation = Sequel::InvalidOperation
-    InvalidValue = Sequel::InvalidValue
-    PoolTimeoutError = Sequel::PoolTimeout
-    Rollback = Sequel::Rollback
-  end  
+  UnbindDuplicate = Class.new(Error)
+
+  # Call name on each class to set the name for the class, so it gets cached.
+  constants.map{|c| const_get(c)}.each do |c|
+    Class === c && c.name
+  end
+
+  Error::AdapterNotFound = AdapterNotFound
+  Error::InvalidOperation = InvalidOperation
+  Error::InvalidValue = InvalidValue
+  Error::PoolTimeoutError = PoolTimeout
+  Error::Rollback = Rollback
 end

data/lib/sequel/extensions/_pretty_table.rb

@@ -23,7 +23,7 @@ module Sequel
 
     # Return the string that #print will print via puts.
     def self.string(records, columns = nil) # records is an array of hashes
-      columns ||= records.first.keys.sort_by{|x|x.to_s}
+      columns ||= records.first.keys.sort_by(&:to_s)
       sizes = column_sizes(records, columns)
       sep_line = separator_line(columns, sizes)
 

data/lib/sequel/extensions/constraint_validations.rb

@@ -146,7 +146,7 @@ module Sequel
       %w'presence unique'.each do |v|
         class_eval(<<-END, __FILE__, __LINE__+1)
           def #{v}(columns, opts=OPTS)
-            @generator.validation({:type=>:#{v}, :columns=>Array(columns)}.merge(opts))
+            @generator.validation({:type=>:#{v}, :columns=>Array(columns)}.merge!(opts))
           end
         END
       end
@@ -155,7 +155,7 @@ module Sequel
       %w'exact_length min_length max_length length_range format like ilike includes'.each do |v|
         class_eval(<<-END, __FILE__, __LINE__+1)
           def #{v}(arg, columns, opts=OPTS)
-            @generator.validation({:type=>:#{v}, :columns=>Array(columns), :arg=>arg}.merge(opts))
+            @generator.validation({:type=>:#{v}, :columns=>Array(columns), :arg=>arg}.merge!(opts))
           end
         END
       end

data/lib/sequel/extensions/date_arithmetic.rb

@@ -60,7 +60,7 @@ module Sequel
         MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
         DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
-        ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map{|s| s.freeze}).freeze
+        ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
         FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
 
@@ -180,7 +180,7 @@ module Sequel
         else
           h = Hash.new(0)
           interval.parts.each{|unit, value| h[unit] += value}
-          {}.merge(h)
+          Hash[h]
         end
       end
 

data/lib/sequel/extensions/pg_array.rb

@@ -227,7 +227,7 @@ module Sequel
         # affect global state, unlike PGArray.register.  See PGArray.register for
         # possible options.
         def register_array_type(db_type, opts=OPTS, &block)
-          opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_array_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge(opts)
+          opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_array_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge!(opts)
           unless (opts.has_key?(:scalar_oid) || block) && opts.has_key?(:oid)
             array_oid, scalar_oid = from(:pg_type).where(:typname=>db_type.to_s).get([:typarray, :oid])
             opts[:scalar_oid] = scalar_oid unless opts.has_key?(:scalar_oid) || block
@@ -300,6 +300,15 @@ module Sequel
           end
         end
 
+        # Convert ruby arrays to PostgreSQL arrays when used as default values.
+        def column_definition_default_sql(sql, column)
+          if (d = column[:default]) && d.is_a?(Array) && !Sequel.condition_specifier?(d)
+            sql << " DEFAULT (#{literal(Sequel.pg_array(d))}::#{type_literal(column)})"
+          else
+            super
+          end
+        end
+
         # Given a value to typecast and the type of PGArray subclass:
         # * If given a PGArray with a matching array_type, use it directly.
         # * If given a PGArray with a different array_type, return a PGArray

data/lib/sequel/extensions/pg_row.rb

@@ -445,7 +445,7 @@ module Sequel
           end
           # Manually cast to integer using to_i, because adapter may not cast oid type
           # correctly (e.g. swift)
-          parser_opts[:oid], rel_oid, array_oid = row.values_at(:oid, :typrelid, :typarray).map{|i| i.to_i}
+          parser_opts[:oid], rel_oid, array_oid = row.values_at(:oid, :typrelid, :typarray).map(&:to_i)
 
           # Get column names and oids for each of the members of the composite type.
           res = from(:pg_attribute).

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -123,7 +123,7 @@ SQL
 
         Thread.new do
           begin
-            listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge(opts)) do |_, _, oid|
+            listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge!(opts)) do |_, _, oid|
               if model = oid_map[oid.to_i]
                 model.send(:load_cache)
               end

data/lib/sequel/extensions/schema_dumper.rb

@@ -73,7 +73,7 @@ module Sequel
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by{|t| t.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(/^/o, '    ')}
   end
 end
 END_MIG
@@ -91,7 +91,7 @@ END_MIG
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by{|t| t.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(/^/o, '    ')}
   end
 end
 END_MIG
@@ -207,7 +207,7 @@ END_MIG
     def dump_add_fk_constraints(table, fks)
       sfks = "alter_table(#{table.inspect}) do\n"
       sfks << create_table_generator do
-        fks.sort_by{|fk| fk[:columns].map{|c| c.to_s}}.each do |fk|
+        fks.sort_by{|fk| fk[:columns].map(&:to_s)}.each do |fk|
           foreign_key fk[:columns], fk
         end
       end.dump_constraints.gsub(/^foreign_key /, '  add_foreign_key ')
@@ -218,7 +218,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{|c| c.to_s}}
+        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map(&:to_s)}
       end
 
       if fks.nil? || fks.empty?
@@ -234,7 +234,7 @@ END_MIG
       table = table.value.to_s if table.is_a?(SQL::Identifier)
       raise(Error, "must provide table as a Symbol, String, or Sequel::SQL::Identifier") unless [String, Symbol].any?{|c| table.is_a?(c)}
       s = schema(table).dup
-      pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
+      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)
@@ -319,7 +319,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort_by{|t| t.to_s}
+        tables.sort_by(&:to_s)
       end
     end
 
@@ -351,7 +351,7 @@ END_MIG
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort_by{|t| t.to_s})
+        sorted_tables.concat(this_loop.sort_by(&:to_s))
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}
@@ -417,7 +417,7 @@ END_MIG
             if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
               "check #{c[:check].first.inspect[1...-1]}"
             else
-              "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
+              "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map(&:inspect).join(', ')}"
             end
           when :foreign_key
             c.delete(:on_delete) if c[:on_delete] == :no_action