sequel 4.47.0 → 4.48.0

data/lib/sequel/core.rb

@@ -188,8 +188,8 @@ module Sequel
 
   # Convert given object to json and return the result.
   # This can be overridden to use an alternative json implementation.
-  def self.object_to_json(obj, *args)
-    obj.to_json(*args)
+  def self.object_to_json(obj, *args, &block)
+    obj.to_json(*args, &block)
   end
 
   # Parse the string as JSON and return the result.

data/lib/sequel/database/connecting.rb

@@ -8,7 +8,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid do ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
+    ADAPTERS = %w'ado amalgalite cubrid do ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.map(&:to_sym)
     # SEQUEL5: Remove cubrid do swift
 
     def self.single_threaded
@@ -49,7 +49,7 @@ module Sequel
       case conn_string
       when String
         # SEQUEL5: Remove do
-        if match = /\A(jdbc|do):/o.match(conn_string)
+        if match = /\A(jdbc|do):/.match(conn_string)
           c = adapter_class(match[1].to_sym)
           opts = opts.merge(:orig_opts=>opts.dup)
           opts = {:uri=>conn_string}.merge!(opts)
@@ -58,7 +58,7 @@ module Sequel
           scheme = uri.scheme
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
-          uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
+          uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
           uri_options.to_a.each{|k,v| uri_options[k] = (defined?(URI::DEFAULT_PARSER) ? URI::DEFAULT_PARSER : URI).unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
@@ -197,7 +197,7 @@ module Sequel
     #   DB.add_servers(:f=>{:host=>"hash_host_f"})
     def add_servers(servers)
       unless h = @opts[:servers]
-        Sequel::Deprecation.deprecate("Calling Database#add_servers on a database that does not use sharding", "This method should only be called if the database supports sharding.")
+        Sequel::Deprecation.deprecate("Calling Database#add_servers on a database that does not use sharding", "This method should only be called if the database supports sharding")
         # raise Error, "cannot call Database#add_servers on a Database instance that does not use a sharded connection pool" # SEQUEL5
         return
       end
@@ -262,7 +262,7 @@ module Sequel
     #   DB.remove_servers(:f1, :f2)
     def remove_servers(*servers)
       unless h = @opts[:servers]
-        Sequel::Deprecation.deprecate("Calling Database#add_servers on a database that does not use sharding", "This method should only be called if the database supports sharding.")
+        Sequel::Deprecation.deprecate("Calling Database#add_servers on a database that does not use sharding", "This method should only be called if the database supports sharding")
         # raise Error, "cannot call Database#remove_servers on a Database instance that does not use a sharded connection pool" # SEQUEL5
         return
       end

data/lib/sequel/database/dataset.rb

@@ -58,12 +58,15 @@ module Sequel
     #   DB.from(:items) # SELECT * FROM items
     #   DB.from(:items){id > 2} # SELECT * FROM items WHERE (id > 2)
     def from(*args, &block)
-      ds = @default_dataset.from(*args)
       if block
         Sequel::Deprecation.deprecate("Sequel::Database#from with a block", "Use .from(*args).where(&block) instead")
-        ds.where(&block)
+        @default_dataset.from(*args).where(&block)
+      #SEQUEL5
+      #  @default_dataset.from(*args, &block)
+      #elsif args.length == 1 && (table = args[0]).is_a?(Symbol)
+      #  @default_dataset.send(:cached_dataset, :"_from_#{table}_ds"){@default_dataset.from(table)}
       else
-        ds
+        @default_dataset.from(*args)
       end
     end
     

data/lib/sequel/database/misc.rb

@@ -31,7 +31,7 @@ module Sequel
     module ResetIdentifierMangling
       def self.extended(obj)
         # :nocov:
-        Sequel::Deprecation.deprecate("Sequel::Database::ResetIdentifierMangling is no longer needed and will be removed in Sequel 5.  Please update your adapter.")
+        Sequel::Deprecation.deprecate("Sequel::Database::ResetIdentifierMangling is no longer needed and will be removed in Sequel 5.  Please update your adapter")
         obj.send(:reset_identifier_mangling) if obj.respond_to?(:reset_identifier_mangling)
         # :nocov:
       end

data/lib/sequel/database/query.rb

@@ -310,6 +310,9 @@ module Sequel
 
     # Remove the cached schema for the given schema name
     def remove_cached_schema(table)
+      #SEQUEL5
+      #cache = @default_dataset.send(:cache)
+      #Sequel.synchronize{cache.clear}
       k = quote_schema_table(table)
       Sequel.synchronize{@schemas.delete(k)}
     end

data/lib/sequel/database/schema_methods.rb

@@ -707,7 +707,7 @@ module Sequel
       e = options[:ignore_index_errors] || options[:if_not_exists]
       generator.indexes.each do |index|
         begin
-          index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}
+          transaction(:savepoint=>:only){index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}}
         rescue Error
           raise unless e
         end

data/lib/sequel/dataset/actions.rb

@@ -11,11 +11,12 @@ module Sequel
     
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
-      << [] all avg count columns columns! delete each
+      << [] all as_hash 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
       single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
     METHS
+    # SEQUEL5: Remove interval, range
 
     # The clone options to use when retriveing columns for a dataset.
     COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
@@ -410,6 +411,7 @@ module Sequel
     #   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))
+      Sequel::Deprecation.deprecate("Sequel::Dataset#interval", "Use #max - #min, or use the sequel_4_dataset_methods extension")
       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))
@@ -623,6 +625,7 @@ module Sequel
     #   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))
+      Sequel::Deprecation.deprecate("Sequel::Dataset#range", "Use #min..#max, or use the sequel_4_dataset_methods extension")
       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))
@@ -639,8 +642,8 @@ module Sequel
     end
     
     # Returns a hash with key_column values as keys and value_column values as
-    # values.  Similar to to_hash, but only selects the columns given.  Like
-    # to_hash, it accepts an optional :hash parameter, into which entries will
+    # values.  Similar to as_hash, but only selects the columns given.  Like
+    # as_hash, it accepts an optional :hash parameter, into which entries will
     # be merged. 
     #
     #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
@@ -656,7 +659,7 @@ module Sequel
     # that Sequel can determine.  Usually you can do this by calling the #as method
     # on the expression and providing an alias.
     def select_hash(key_column, value_column, opts = OPTS)
-      _select_hash(:to_hash, key_column, value_column, opts)
+      _select_hash(:as_hash, key_column, value_column, opts)
     end
     
     # Returns a hash with key_column values as keys and an array of value_column values.
@@ -786,19 +789,19 @@ module Sequel
     # will overwrite the value of the previous row(s). If the value_column
     # is not given or nil, uses the entire hash as the value.
     #
-    #   DB[:table].to_hash(:id, :name) # SELECT * FROM table
+    #   DB[:table].as_hash(:id, :name) # SELECT * FROM table
     #   # {1=>'Jim', 2=>'Bob', ...}
     #
-    #   DB[:table].to_hash(:id) # SELECT * FROM table
+    #   DB[:table].as_hash(:id) # SELECT * FROM table
     #   # {1=>{:id=>1, :name=>'Jim'}, 2=>{:id=>2, :name=>'Bob'}, ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].to_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
+    #   DB[:table].as_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
     #   # {[1, 3]=>['Jim', 'bo'], [2, 4]=>['Bob', 'be'], ...}
     #
-    #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
+    #   DB[:table].as_hash([:id, :name]) # SELECT * FROM table
     #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob']=>{:id=>2, :name=>'Bob'}, ...}
     #
     # Options:
@@ -806,11 +809,11 @@ module Sequel
     # :hash :: The object into which the values will be placed.  If this is not
     #          given, an empty hash is used.  This can be used to use a hash with
     #          a default value or default proc.
-    def to_hash(key_column, value_column = nil, opts = OPTS)
+    def as_hash(key_column, value_column = nil, opts = OPTS)
       h = opts[:hash] || {}
       meth = opts[:all] ? :all : :each
       if value_column
-        return naked.to_hash(key_column, value_column, opts) if row_proc
+        return naked.as_hash(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
             send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
@@ -832,6 +835,11 @@ module Sequel
       h
     end
 
+    # Alias of as_hash for backwards compatibility.
+    def to_hash(*a)
+      as_hash(*a)
+    end
+
     # Returns a hash with one column used as key and the values being an
     # array of column values. If the value_column is not given or nil, uses
     # the entire hash as the value.

data/lib/sequel/dataset/graph.rb

@@ -275,7 +275,7 @@ module Sequel
     # a select method, and the second is a new hash of preprocessed graph aliases.
     def graph_alias_columns(graph_aliases)
       gas = {}
-      identifiers = graph_aliases.collect do |col_alias, tc| 
+      identifiers = graph_aliases.map do |col_alias, tc| 
         table, column, value = Array(tc)
         column ||= col_alias
         gas[col_alias] = [table, column].freeze

data/lib/sequel/dataset/misc.rb

@@ -35,6 +35,7 @@ module Sequel
       @db = db
       @opts = {} # OPTS # SEQUEL5
       @cache = {}
+      # freeze # SEQUEL5
     end
 
     # Define a hash value such that datasets with the same class, DB, and opts

data/lib/sequel/dataset/prepared_statements.rb

@@ -41,7 +41,7 @@ module Sequel
       meths.each do |meth|
         mod.send(:define_method, :"#{meth}=") do |v|
           # :nocov:
-          Sequel::Deprecation.deprecate("Dataset##{meth}=", "The API has changed, and this value should now be passed in as an option via Dataset#clone.")
+          Sequel::Deprecation.deprecate("Dataset##{meth}=", "The API has changed, and this value should now be passed in as an option via Dataset#clone")
           @opts[meth] = v
           # :nocov:
         end
@@ -214,7 +214,7 @@ module Sequel
           fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
           case prepared_type[0]
-          when :map, :to_hash, :to_hash_groups
+          when :map, :as_hash, :to_hash, :to_hash_groups
             send(*prepared_type, &block) 
           end
         else
@@ -341,7 +341,7 @@ module Sequel
       else
         # :nocov:
         # SEQUEL5: Add coverage
-        Sequel::Deprecation.deprecate("Dataset#prepare will change to requiring a name argument in Sequel 5, please update your code.") unless name
+        Sequel::Deprecation.deprecate("Dataset#prepare will change to requiring a name argument in Sequel 5, please update your code") unless name
         # :nocov:
       end
 

data/lib/sequel/dataset/query.rb

@@ -20,7 +20,7 @@ module Sequel
 
     # Which options don't affect the SQL generation.  Used by simple_select_all?
     # to determine if this is a simple SELECT * FROM table.
-    NON_SQL_OPTIONS = [:server, :graph, :eager, :eager_graph, :graph_aliases, :row_proc, :quote_identifiers, :identifier_input_method, :identifier_output_method, :skip_symbol_cache, :model, :model_object, :association_reflection, :fetch, :numrows, :autoid].freeze # SEQUEL5: Remove graph_aliases
+    NON_SQL_OPTIONS = [:server, :graph, :graph_aliases, :row_proc, :quote_identifiers, :identifier_input_method, :identifier_output_method, :skip_symbol_cache].freeze # SEQUEL5: Remove graph_aliases
     
     # These symbols have _join methods created (e.g. inner_join) that
     # call join_table with the symbol, passing along the arguments and
@@ -44,6 +44,7 @@ module Sequel
       set_graph_aliases unfiltered ungraphed ungrouped union
       unlimited unordered where with with_recursive with_sql
     METHS
+    # SEQUEL5: Remove and, exclude_where
 
     # Register an extension callback for Dataset objects.  ext should be the
     # extension name symbol, and mod should either be a Module that the
@@ -68,6 +69,7 @@ module Sequel
 
     # Alias for where.
     def and(*cond, &block)
+      Sequel::Deprecation.deprecate("Sequel::Dataset#and", "Use #where, or use the sequel_4_dataset_methods extension")
       where(*cond, &block)
     end
     
@@ -190,6 +192,7 @@ module Sequel
 
     # Alias for exclude.
     def exclude_where(*cond, &block)
+      Sequel::Deprecation.deprecate("Sequel::Dataset#exclude_where", "Use #exclude, or use the sequel_4_dataset_methods extension")
       exclude(*cond, &block)
     end
 
@@ -281,8 +284,7 @@ module Sequel
     #   # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo(c1, c2)
     def from_self(opts=OPTS)
       fs = {}
-      non_sql = non_sql_options
-      @opts.keys.each{|k| fs[k] = nil unless non_sql.include?(k)}
+      @opts.keys.each{|k| fs[k] = nil unless non_sql_option?(k)}
       c = clone(fs).from(opts[:alias] ? as(opts[:alias], opts[:column_aliases]) : self)
       if cols = _columns
         c.send(:columns=, cols)
@@ -576,7 +578,7 @@ module Sequel
         last_alias = options[:implicit_qualifier] || @opts[:last_joined_table] || first_source_alias
         qualify_type = options[:qualify]
         if Sequel.condition_specifier?(expr)
-          expr = expr.collect do |k, v|
+          expr = expr.map do |k, v|
             qualify_type = default_join_table_qualification if qualify_type.nil?
             case qualify_type
             when false
@@ -1137,7 +1139,9 @@ module Sequel
     # * single_record (if only one record could be returned)
     # * single_value (if only one record could be returned, and a single column is selected)
     # * map
+    # * as_hash
     # * to_hash
+    # * to_hash_groups
     # * delete (if a DELETE statement)
     # * update (if an UPDATE statement, with no arguments)
     # * insert (if an INSERT statement, with no arguments)
@@ -1169,7 +1173,7 @@ module Sequel
 
     # Return true if the dataset has a non-nil value for any key in opts.
     def options_overlap(opts)
-      !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
+      !(@opts.map{|k,v| k unless v.nil?}.compact & opts).empty?
     end
 
     # From types allowed to be considered a simple_select_all
@@ -1181,8 +1185,7 @@ module Sequel
     #   SELECT table.* FROM table
     def simple_select_all?
       return false unless (f = @opts[:from]) && f.length == 1
-      non_sql = non_sql_options
-      o = @opts.reject{|k,v| v.nil? || non_sql.include?(k)}
+      o = @opts.reject{|k,v| v.nil? || non_sql_option?(k)}
       from = f.first
       from = from.expression if from.is_a?(SQL::AliasedExpression)
 
@@ -1358,9 +1361,17 @@ module Sequel
       server?(:default)
     end
 
-    # Dataset options that do not affect the generated SQL.
+    # SEQUEL5: Remove
     def non_sql_options
+      # :nocov:
+      Sequel::Deprecation.deprecate("Dataset#non_sql_options (private method)", "Convert the related code to use the non_sql_option? method")
       NON_SQL_OPTIONS
+      # :nocov:
+    end
+
+    # Whether the given option key does not affect the generated SQL.
+    def non_sql_option?(key)
+      NON_SQL_OPTIONS.include?(key)
     end
 
     # Treat the +block+ as a virtual_row block if not +nil+ and

data/lib/sequel/extensions/core_extensions.rb

@@ -48,7 +48,10 @@ class Array
   def sql_value_list
     ::Sequel::SQL::ValueList.new(self)
   end
-  alias sql_array sql_value_list
+  def sql_array
+    Sequel::Deprecation.deprecate("Array#sql_array in the core_extensions extension", "Use Array#sql_value_list instead")
+    sql_value_list
+  end
 
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
   # conditions.  Rarely do you need to call this explicitly, as Sequel generally

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -35,7 +35,7 @@
 
 module Sequel
   module DuplicateColumnsHandler
-    CALLER_ARGS = RUBY_VERSION >= '2.0' ? [0,1] : [0]
+    CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
 
     # Customize handling of duplicate columns for this dataset.
     def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -2,4 +2,7 @@
 #
 # This only exists for backwards compatibility, as the behavior
 # added by this extension is now the default Sequel behavior. 
+
+Sequel::Deprecation.deprecate("The empty_array_ignore_nulls", "It has been a no-op since 4.25.0")
+
 Sequel::Dataset.register_extension(:empty_array_ignore_nulls){}

data/lib/sequel/extensions/filter_having.rb

@@ -18,6 +18,8 @@
 #
 # Related module: Sequel::FilterHaving
 
+Sequel::Deprecation.deprecate("The filter_having extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   module FilterHaving

data/lib/sequel/extensions/freeze_datasets.rb

@@ -67,3 +67,5 @@ module Sequel
     register_extension(:freeze_datasets, FreezeDatasets)
   end
 end
+
+# Sequel::Database.register_extension(:freeze_datasets){} # SEQUEL5

data/lib/sequel/extensions/from_block.rb

@@ -29,9 +29,9 @@ module Sequel
         super
       end
     end
-    # SEQUEL5: Make this an empty module, since it will be the default behavior
   end
 
   Database.register_extension(:from_block, Database::FromBlock)
 end
 
+# Sequel::Database.register_extension(:from_block){} # SEQUEL5

data/lib/sequel/extensions/graph_each.rb

@@ -50,10 +50,10 @@ module Sequel
       # the result set
       datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
       # Get just the list of table aliases into a local variable, for speed
-      table_aliases = datasets.collect{|ta,ds| ta}
+      table_aliases = datasets.map{|ta,ds| ta}
       # Get an array of arrays, one for each dataset, with
       # the necessary information about each dataset, for speed
-      datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
+      datasets = datasets.map{|ta, ds| [ta, ds, ds.row_proc]}
       # Use the manually set graph aliases, if any, otherwise
       # use the ones automatically created by .graph
       column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases] # SEQUEL5: Remove :graph_aliases support

data/lib/sequel/extensions/hash_aliases.rb

@@ -18,6 +18,8 @@
 #
 # Related module: Sequel::HashAliases
 
+Sequel::Deprecation.deprecate("The hash_aliases extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
+
 #
 module Sequel
   module HashAliases

data/lib/sequel/extensions/identifier_mangling.rb

@@ -34,13 +34,6 @@
 #
 #   DB.extension :identifier_mangling
 #
-# Historically, Sequel supported these methods by default on
-# Databases and Datasets.  Sequel 4 will continue to support
-# the methods for backwards compatibility, by loading this
-# extension automatically for databases unless the
-# <tt>:identifier_mangling=>false</tt> Database option is
-# used.
-#
 # Related modules: Sequel::IdentifierMangling::DatabaseMethods,
 # Sequel::IdentifierMangling::DatasetMethods
 

data/lib/sequel/extensions/meta_def.rb

@@ -9,6 +9,8 @@
 #
 # Related module: Sequel::Metaprogramming
 
+Sequel::Deprecation.deprecate("The meta_def extension", "Replace meta_def usage with define_singleton_method")
+
 #
 module Sequel
   # Contains meta_def method for adding methods to objects via blocks.