sequel 4.44.0 → 4.45.0

data/lib/sequel/database/connecting.rb

@@ -9,12 +9,16 @@ 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)
+    # SEQUEL5: Remove cubrid do swift
 
-    @single_threaded = false
+    def self.single_threaded
+      Sequel::Deprecation.deprecate("Sequel::Database.single_threaded", "Use Sequel.single_threaded instead")
+      Sequel.single_threaded
+    end
 
-    class << self
-      # Whether to use the single threaded connection pool by default
-      attr_accessor :single_threaded
+    def self.single_threaded=(v)
+      Sequel::Deprecation.deprecate("Sequel::Database.single_threaded=", "Use Sequel.single_threaded= instead")
+      Sequel.single_threaded = v
     end
 
     # The Database subclass for the given adapter scheme.
@@ -37,6 +41,7 @@ module Sequel
     def self.connect(conn_string, opts = OPTS)
       case conn_string
       when String
+        # SEQUEL5: Remove do
         if match = /\A(jdbc|do):/o.match(conn_string)
           c = adapter_class(match[1].to_sym)
           opts = opts.merge(:orig_opts=>opts.dup)
@@ -65,6 +70,7 @@ module Sequel
       end
       begin
         db = c.new(opts)
+        # SEQUEL5: Default opts[:test] to true
         db.test_connection if opts[:test] && db.send(:typecast_value_boolean, opts[:test])
         if block_given?
           return yield(db)
@@ -183,10 +189,14 @@ module Sequel
     #
     #   DB.add_servers(:f=>{:host=>"hash_host_f"})
     def add_servers(servers)
-      if h = @opts[:servers]
-        Sequel.synchronize{h.merge!(servers)}
-        @pool.add_servers(servers.keys)
+      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.")
+        # raise Error, "cannot call Database#add_servers on a Database instance that does not use a sharded connection pool" # SEQUEL5
+        return
       end
+
+      Sequel.synchronize{h.merge!(servers)}
+      @pool.add_servers(servers.keys)
     end
 
     # The database type for this database object, the same as the adapter scheme
@@ -229,6 +239,7 @@ module Sequel
     #
     #   DB.each_server{|db| db.create_table(:users){primary_key :id; String :name}}
     def each_server(&block)
+      Sequel::Deprecation.deprecate("Database#each_server", "Switching to using Dataset#servers and Database#with_server from the server_block extension: \"DB.servers.each{|s| DB.with_server(s){}}\"")
       raise(Error, "Database#each_server must be passed a block") unless block
       servers.each{|s| self.class.connect(server_opts(s), &block)}
     end
@@ -244,10 +255,14 @@ module Sequel
     #
     #   DB.remove_servers(:f1, :f2)
     def remove_servers(*servers)
-      if h = @opts[:servers]
-        servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
-        @pool.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.")
+        # raise Error, "cannot call Database#remove_servers on a Database instance that does not use a sharded connection pool" # SEQUEL5
+        return
       end
+
+      servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
+      @pool.remove_servers(servers)
     end
     
     # An array of servers/shards for this Database object.

data/lib/sequel/database/dataset.rb

@@ -59,7 +59,12 @@ module Sequel
     #   DB.from(:items){id > 2} # SELECT * FROM items WHERE (id > 2)
     def from(*args, &block)
       ds = @default_dataset.from(*args)
-      block ? ds.where(&block) : ds
+      if block
+        Sequel::Deprecation.deprecate("Sequel::Database#from with a block", "Use .from(*args).where(&block) instead")
+        ds.where(&block)
+      else
+        ds
+      end
     end
     
     # Returns a new dataset with the select method invoked.

data/lib/sequel/database/dataset_defaults.rb

@@ -10,10 +10,10 @@ module Sequel
     # The default class to use for datasets
     DatasetClass = Sequel::Dataset
 
+    # SEQUEL5: Remove
     @identifier_input_method = nil
     @identifier_output_method = nil
     @quote_identifiers = nil
-
     class << self
       # The identifier input method to use by default for all databases (default: adapter default)
       attr_reader :identifier_input_method
@@ -22,19 +22,26 @@ module Sequel
       attr_reader :identifier_output_method
 
       # Whether to quote identifiers (columns and tables) by default for all databases (default: adapter default)
-      attr_accessor :quote_identifiers
+      attr_reader :quote_identifiers
     end
 
     # Change the default identifier input method to use for all databases,
     def self.identifier_input_method=(v)
+      Sequel::Deprecation.deprecate("Sequel.identifier_input_method= and Sequel::Database.identifier_input_method=", "Call Sequel::Database#identifier_input_method= instead")
       @identifier_input_method = v.nil? ? false : v
     end
 
     # Change the default identifier output method to use for all databases,
     def self.identifier_output_method=(v)
+      Sequel::Deprecation.deprecate("Sequel.identifier_output_method= and Sequel::Database.identifier_output_method=", "Call Sequel::Database#identifier_output_method= instead")
       @identifier_output_method = v.nil? ? false : v
     end
 
+    def self.quote_identifiers=(v)
+      Sequel::Deprecation.deprecate("Sequel.quote_identifiers= and Sequel::Database.quote_identifiers=", "Call Sequel::Database#quote_identifiers= instead")
+      @quote_identifiers = v
+    end
+
     # The class to use for creating datasets.  Should respond to
     # new with the Database argument as the first argument, and
     # an optional options hash.

data/lib/sequel/database/misc.rb

@@ -29,13 +29,14 @@ module Sequel
     # Module to be included in shared adapters so that when the DatabaseMethods are
     # included in the database, the identifier mangling defaults are reset correctly.
     module ResetIdentifierMangling
-      def extended(obj)
+      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.")
         obj.send(:reset_identifier_mangling) if obj.respond_to?(:reset_identifier_mangling)
         # :nocov:
       end
     end
+    Sequel::Deprecation.deprecate_constant(self, :ResetIdentifierMangling)
 
     # Nested hook Proc; each new hook Proc just wraps the previous one.
     @initialize_hook = Proc.new {|db| }
@@ -125,7 +126,7 @@ module Sequel
       @opts[:servers] = {} if @opts[:servers].is_a?(String)
       @sharded = !!@opts[:servers]
       @opts[:adapter_class] = self.class
-      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Database.single_threaded))
+      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Sequel.single_threaded))
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
 
       @schemas = {}
@@ -150,7 +151,7 @@ module Sequel
       reset_default_dataset
       adapter_initialize
       if typecast_value_boolean(@opts.fetch(:identifier_mangling, true))
-        extension(:identifier_mangling)
+        extension(:_deprecated_identifier_mangling)
       end
 
       unless typecast_value_boolean(@opts[:keep_reference]) == false
@@ -180,6 +181,12 @@ module Sequel
       super
     end
 
+    def initialize_copy(_)
+      Sequel::Deprecation.deprecate("Database#dup and #clone", "Use Sequel.connect to create a new Database instance")
+      # raise(Error, "cannot dup/clone a Sequel::Database instance") # SEQUEL5
+      super
+    end
+
     # Cast the given type to a literal type
     #
     #   DB.cast_type_literal(Float) # double precision

data/lib/sequel/database/schema_methods.rb

@@ -808,6 +808,10 @@ module Sequel
 
     # Proxy the filter_expr call to the dataset, used for creating constraints.
     def filter_expr(*args, &block)
+      if args.length == 1 && args.first.is_a?(Proc) && !block
+        block = args.first
+        args = nil
+      end
       schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
     end
 

data/lib/sequel/dataset/mutation.rb

@@ -30,67 +30,55 @@ module Sequel
     
     # Like #extension, but modifies and returns the receiver instead of returning a modified clone.
     def extension!(*exts)
-      raise_if_frozen!
+      raise_if_frozen!("extension!")
       _extension!(exts)
     end
 
     # Avoid self-referential dataset by cloning.
     def from_self!(*args, &block)
-      raise_if_frozen!
+      raise_if_frozen!("from_self!")
       @opts = clone.from_self(*args, &block).opts
       self
     end
 
     # Remove the row_proc from the current dataset.
     def naked!
-      raise_if_frozen!
+      raise_if_frozen!("naked=")
       @opts[:row_proc] = nil
       self
     end
     
     # Set whether to quote identifiers for this dataset
     def quote_identifiers=(v)
-      raise_if_frozen!
+      raise_if_frozen!("quote_identifiers=")
       skip_symbol_cache!
       @opts[:quote_identifiers] = v
     end
 
     # Override the row_proc for this dataset
     def row_proc=(v)
-      raise_if_frozen!
+      raise_if_frozen!("row_proc=")
       @opts[:row_proc] = v
     end
     
     private
     
-    # Load the extensions into the receiver, without checking if the receiver is frozen.
-    def _extension!(exts)
-      Sequel.extension(*exts)
-      exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
-        else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
-        end
-      end
-      self
-    end
-
     # Modify the receiver with the results of sending the meth, args, and block
     # to the receiver and merging the options of the resulting dataset into
     # the receiver's options.
     def mutation_method(meth, *args, &block)
-      raise_if_frozen!
+      raise_if_frozen!("#{meth}!")
       @opts = send(meth, *args, &block).opts
       @cache = {}
       self
     end
 
     # Raise a RuntimeError if the receiver is frozen
-    def raise_if_frozen!
+    def raise_if_frozen!(meth = nil)
       if frozen?
         raise RuntimeError, "can't modify frozen #{visible_class_name}"
       end
+      Sequel::Deprecation.deprecate("Dataset mutation is deprecated and will be removed in Sequel 5#{" (method called: #{meth})" if meth}")
     end
 
     # Set the dataset to skip the symbol cache

data/lib/sequel/dataset/prepared_statements.rb

@@ -217,6 +217,7 @@ module Sequel
             send(*prepared_type, &block) 
           end
         else
+          Sequel::Deprecation.deprecate("Using an unsupported prepared statement type (#{prepared_type.inspect})", 'Switch to using :select as the prepared statement type')
           all(&block)
         end
       end
@@ -338,6 +339,7 @@ module Sequel
         db.set_prepared_statement(name, ps)
       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
         # :nocov:
       end

data/lib/sequel/dataset/query.rb

@@ -581,8 +581,8 @@ module Sequel
             when false
               nil # Do no qualification
             when :deep
-              k = Sequel::Qualifier.new(self, table_name).transform(k)
-              v = Sequel::Qualifier.new(self, last_alias).transform(v)
+              k = Sequel::Qualifier.new(table_name).transform(k)
+              v = Sequel::Qualifier.new(last_alias).transform(v)
             else
               k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
               v = qualified_column_name(v, last_alias) if v.is_a?(Symbol)
@@ -897,6 +897,13 @@ module Sequel
       end
     end
 
+    # Specify that the check for limits/offsets when updating/deleting be skipped for the dataset.
+    def skip_limit_check
+      cached_dataset(:_skip_limit_check_ds) do
+        clone(:skip_limit_check=>true)
+      end
+    end
+
     # Skip locked rows when returning results from this dataset.
     def skip_locked
       cached_dataset(:_skip_locked_ds) do
@@ -916,6 +923,7 @@ module Sequel
     #   bv #  {:a => 1}
     #   ds.call(:select, bv)
     def unbind
+      Sequel::Deprecation.deprecate("Dataset#unbind", "Switch to using placeholders manually instead of unbinding them")
       u = Unbinder.new
       ds = clone(:where=>u.transform(opts[:where]), :join=>u.transform(opts[:join]))
       [ds, u.binds]
@@ -1186,6 +1194,19 @@ module Sequel
 
     private
 
+    # Load the extensions into the receiver, without checking if the receiver is frozen.
+    def _extension!(exts)
+      Sequel.extension(*exts)
+      exts.each do |ext|
+        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          pr.call(self)
+        else
+          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+        end
+      end
+      self
+    end
+
     # Internal filtering method so it works on either the WHERE or HAVING clauses, with or
     # without inversion.
     def _filter_or_exclude(invert, clause, *cond, &block)
@@ -1214,10 +1235,12 @@ module Sequel
     def filter_expr(expr = nil, &block)
       expr = nil if expr == []
 
-      if expr && block
-        return SQL::BooleanExpression.new(:AND, filter_expr(expr), filter_expr(block))
-      elsif block
-        expr = block
+      if block
+        if expr
+          return SQL::BooleanExpression.new(:AND, filter_expr(expr), filter_expr(Sequel.virtual_row(&block)))
+        else
+          return filter_expr(Sequel.virtual_row(&block))
+        end
       end
 
       case expr
@@ -1229,11 +1252,13 @@ module Sequel
         elsif Sequel.condition_specifier?(expr)
           SQL::BooleanExpression.from_value_pairs(expr)
         else
+          Sequel::Deprecation.deprecate("Passing multiple arguments as filter arguments when not using a conditions specifier (#{expr.inspect})", "Pass the arguments to separate filter methods or use Sequel.& to combine them")
           SQL::BooleanExpression.new(:AND, *expr.map{|x| filter_expr(x)})
         end
       when Proc
+        Sequel::Deprecation.deprecate("Passing Proc objects as filter arguments", "Pass them as blocks to the filtering methods or to Sequel.expr")
         filter_expr(Sequel.virtual_row(&expr))
-      when Numeric, SQL::NumericExpression, SQL::StringExpression
+      when Numeric, SQL::NumericExpression, SQL::StringExpression #, Proc # SEQUEL5
         raise(Error, "Invalid filter expression: #{expr.inspect}") 
       when TrueClass, FalseClass
         if supports_where_true?

data/lib/sequel/dataset/sql.rb

@@ -155,6 +155,7 @@ module Sequel
         static_sql(opts[:sql])
       else
         check_truncation_allowed!
+        check_not_limited!(:truncate)
         raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where] || opts[:having]
         t = String.new
         source_list_append(t, opts[:from])
@@ -172,6 +173,7 @@ module Sequel
     def update_sql(values = OPTS)
       return static_sql(opts[:sql]) if opts[:sql]
       check_modification_allowed!
+      check_not_limited!(:update)
       clone(:values=>values).send(:_update_sql)
     end
     
@@ -205,7 +207,7 @@ module Sequel
       lines << "def #{'_' if priv}#{type}_sql"
       lines << 'if sql = opts[:sql]; return static_sql(sql) end' unless priv
       lines << "if sql = cache_get(:_#{type}_sql); return sql end" if cacheable
-      lines << 'check_modification_allowed!' if type == :delete
+      lines << 'check_modification_allowed!' << 'check_not_limited!(:delete)' if type == :delete
       lines << 'sql = @opts[:append_sql] || sql_string_origin'
 
       if clauses.all?{|c| c.is_a?(Array)}
@@ -843,7 +845,7 @@ module Sequel
     # Return a from_self dataset if an order or limit is specified, so it works as expected
     # with UNION, EXCEPT, and INTERSECT clauses.
     def compound_from_self
-      (@opts[:sql] || @opts[:limit] || @opts[:order]) ? from_self : self
+      (@opts[:sql] || @opts[:limit] || @opts[:order] || @opts[:offset]) ? from_self : self
     end
     
     private
@@ -922,6 +924,14 @@ module Sequel
       raise(InvalidOperation, "Joined datasets cannot be modified") if !supports_modifying_joins? && joined_dataset?
     end
 
+    # Emit deprecation warning if the dataset uses limits or offsets.
+    def check_not_limited!(type)
+      return if @opts[:skip_limit_check] && type != :truncate
+      # SEQUEL5
+      #raise InvalidOperation, "Dataset##{type} not supported on datasets with limits or offsets" if opts[:limit] || opts[:offset]
+      Sequel::Deprecation.deprecate("Dataset##{type} on datasets with limits or offsets", "Call unlimited to remove the limit #{'or skip_limit_check to ignore the limit ' unless type == :truncate}before calling #{type}") if @opts[:limit] || @opts[:offset]
+    end
+
     # Alias of check_modification_allowed!
     def check_truncation_allowed!
       check_modification_allowed!
@@ -1358,7 +1368,7 @@ module Sequel
     
     # Qualify the given expression e to the given table.
     def qualified_expression(e, table)
-      Qualifier.new(self, table).transform(e)
+      Qualifier.new(table).transform(e)
     end
 
     def select_columns_sql(sql)

data/lib/sequel/deprecated.rb

@@ -39,7 +39,7 @@ module Sequel
     # Print the message and possibly backtrace to the output.
     def self.deprecate(method, instead=nil)
       return unless output
-      message = instead ? "#{method} is deprecated and will be removed in a future version of Sequel.  #{instead}." : method
+      message = instead ? "#{method} is deprecated and will be removed in Sequel 5.  #{instead}." : method
       message = "#{prefix}#{message}" if prefix
       output.puts(message)
       case b = backtrace_filter
@@ -56,5 +56,13 @@ module Sequel
       end
       nil
     end
+
+    # If using ruby 2.3+, use Module#deprecate_constant to deprecate the constant,
+    # otherwise do nothing as the ruby implementation does not support constant deprecation.
+    def self.deprecate_constant(mod, constant)
+      if RUBY_VERSION > '2.3'
+        mod.deprecate_constant(constant)
+      end
+    end
   end
 end