sequel 3.47.0 → 3.48.0

data/lib/sequel/dataset/sql.rb

@@ -336,6 +336,7 @@ module Sequel
     # Do not call this method with untrusted input, as that can result in
     # arbitrary code execution.
     def self.def_append_methods(meths)
+      Sequel::Deprecation.deprecate('Dataset.def_append_methods', "There is no replacement planned")
       meths.each do |meth|
         class_eval(<<-END, __FILE__, __LINE__ + 1)
           def #{meth}(*args, &block)
@@ -346,9 +347,28 @@ module Sequel
         END
       end
     end
-    def_append_methods(PUBLIC_APPEND_METHODS + PRIVATE_APPEND_METHODS)
+    (PUBLIC_APPEND_METHODS + PRIVATE_APPEND_METHODS - [:literal, :quote_identifier, :quote_schema_table]).each do |meth|
+      class_eval(<<-END, __FILE__, __LINE__ + 1)
+        def #{meth}(*args, &block)
+          Sequel::Deprecation.deprecate('Dataset##{meth}', "Please switch to Dataset##{meth}_append")
+          s = ''
+          #{meth}_append(s, *args, &block)
+          s
+        end
+      END
+    end
     private(*PRIVATE_APPEND_METHODS)
 
+    [:literal, :quote_identifier, :quote_schema_table].each do |meth|
+      class_eval(<<-END, __FILE__, __LINE__ + 1)
+        def #{meth}(*args, &block)
+          s = ''
+          #{meth}_append(s, *args, &block)
+          s
+        end
+      END
+    end
+
     # SQL fragment for AliasedExpression
     def aliased_expression_sql_append(sql, ae)
       literal_append(sql, ae.expression)
@@ -601,13 +621,21 @@ module Sequel
           sql << s
           literal_append(sql, args[i]) unless i == len
         end
+        unless str.length == args.length || str.length == args.length + 1
+          Sequel::Deprecation.deprecate("Using a mismatched number of placeholders (#{str.length}) and placeholder arguments (#{args.length}) is deprecated and will raise an Error in Sequel 4.")
+        end
       else
         i = -1
         loop do
           previous, q, str = str.partition(QUESTION_MARK)
           sql << previous
-           literal_append(sql, args.at(i+=1)) unless q.empty?
-          break if str.empty?
+          literal_append(sql, args.at(i+=1)) unless q.empty?
+          if str.empty?
+            unless i + 1 == args.length
+              Sequel::Deprecation.deprecate("Using a mismatched number of placeholders (#{i+1}) and placeholder arguments (#{args.length}) is deprecated and will raise an Error in Sequel 4.")
+            end
+            break
+          end
         end
       end
       sql << PAREN_CLOSE if pls.parens
@@ -665,7 +693,7 @@ module Sequel
     # Note that this function does not handle tables with more than one
     # level of qualification (e.g. database.schema.table on Microsoft
     # SQL Server).
-    def schema_and_table(table_name, sch=(db.default_schema if db))
+    def schema_and_table(table_name, sch=(db._default_schema if db))
       sch = sch.to_s if sch
       case table_name
       when Symbol
@@ -921,6 +949,7 @@ module Sequel
       end
     end
 
+    # An expression for how to handle an empty array lookup
     def empty_array_value(op, cols)
       if Sequel.empty_array_handle_nulls
         c = Array(cols)
@@ -978,7 +1007,12 @@ module Sequel
         literal_append(sql, v)
       end
     end
-    alias table_ref_append identifier_append 
+
+    # REMOVE40
+    def table_ref_append(sql, v)
+      Sequel::Deprecation.deprecate('Dataset#table_ref_append', "Please switch to Dataset#identifier_append")
+      identifier_append(sql, v)
+    end
     
     # Append all identifiers in args interspersed by commas.
     def identifier_list_append(sql, args)
@@ -1196,7 +1230,7 @@ module Sequel
     # Returns a qualified column name (including a table name) if the column
     # name isn't already qualified.
     def qualified_column_name(column, table)
-      if Symbol === column 
+      if column.is_a?(Symbol)
         c_table, column, _ = split_symbol(column)
         unless c_table
           case table

data/lib/sequel/deprecated.rb

@@ -0,0 +1,74 @@
+module Sequel
+  # This module makes it easy to print deprecation warnings with optional backtraces to a given stream.
+  # There are a two accessors you can use to change how/where the deprecation methods are printed
+  # and whether/how backtraces should be included:
+  #
+  #   Sequel::Deprecation.output = $stderr # print deprecation messages to standard error (default)
+  #   Sequel::Deprecation.output = File.open('deprecated_calls.txt', 'wb') # use a file instead
+  #   Sequel::Deprecation.output = false # do not output deprecation messages
+  #
+  #   Sequel::Deprecation.prefix = "SEQUEL DEPRECATION WARNING: " # prefix deprecation messages with a given string (default)
+  #   Sequel::Deprecation.prefix = false # do not prefix deprecation messages
+  #
+  #   Sequel::Deprecation.backtrace_filter = false # don't include backtraces
+  #   Sequel::Deprecation.backtrace_filter = true # include full backtraces
+  #   Sequel::Deprecation.backtrace_filter = 10 # include 10 backtrace lines (default)
+  #   Sequel::Deprecation.backtrace_filter = 1 # include 1 backtrace line
+  #   Sequel::Deprecation.backtrace_filter = lambda{|line, line_no| line_no < 3 || line =~ /my_app/} # select backtrace lines to output
+  module Deprecation
+    @backtrace_filter = 10
+    @output = $stderr
+    @prefix = "SEQUEL DEPRECATION WARNING: "
+
+    class << self
+      # How to filter backtraces.  +false+ does not include backtraces, +true+ includes
+      # full backtraces, an Integer includes that number of backtrace lines, and
+      # a proc is called with the backtrace line and line number to select the backtrace
+      # lines to include.  The default is 10 backtrace lines.
+      attr_accessor :backtrace_filter
+
+      # Where deprecation messages should be output, must respond to puts.  $stderr by default.
+      attr_accessor :output
+
+      # Where deprecation messages should be prefixed with ("SEQUEL DEPRECATION WARNING: " by default).
+      attr_accessor :prefix
+    end
+
+    # 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 Sequel 4.0.  #{instead}." : method
+      message = "#{prefix}#{message}" if prefix
+      output.puts(message)
+      case b = backtrace_filter
+      when Integer
+        caller.each do |c|
+          b -= 1
+          output.puts(c)
+          break if b <= 0
+        end
+      when true
+        caller.each{|c| output.puts(c)}
+      when Proc
+        caller.each_with_index{|line, line_no| output.puts(line) if b.call(line, line_no)}
+      end
+      nil
+    end
+
+    # Return a module that includes deprecation warnings for all public
+    # instance methods in the given module, such that including the returned
+    # module will not result in the given module being included.
+    def self.deprecated_module(mod, &block)
+      Module.new do
+        include mod.dup
+        mod.public_instance_methods.each do |meth|
+          msg = block.call(meth)
+          define_method(meth) do |*a, &blk|
+            Sequel::Deprecation.deprecate(*msg)
+            super(*a, &blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/deprecated_core_extensions.rb

@@ -0,0 +1,135 @@
+def Sequel.core_extensions?
+  true
+end
+
+class Array
+  def ~
+    Sequel::Deprecation.deprecate('Array#~', 'Please use Sequel.~ instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel.~(self)
+  end
+
+  def case(*args)
+    Sequel::Deprecation.deprecate('Array#case', 'Please use Sequel.case instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::CaseExpression.new(self, *args)
+  end
+
+  def sql_value_list
+    Sequel::Deprecation.deprecate('Array#sql_value_list/Array#sql_array', 'Please use Sequel.value_list instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::ValueList.new(self)
+  end
+  alias sql_array sql_value_list
+
+  def sql_expr
+    Sequel::Deprecation.deprecate('Array#sql_expr', 'Please use Sequel.expr instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel.expr(self)
+  end
+
+  def sql_negate
+    Sequel::Deprecation.deprecate('Array#sql_negate', 'Please use Sequel.negate instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel.negate(self)
+  end
+
+  def sql_or
+    Sequel::Deprecation.deprecate('Array#sql_or', 'Please use Sequel.or instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel.or(self)
+  end
+
+  def sql_string_join(joiner=nil)
+    Sequel::Deprecation.deprecate('Array#sql_string_join', 'Please use Sequel.join instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel.join(self, joiner)
+  end
+end
+
+class Hash
+  def &(ce)
+    Sequel::Deprecation.deprecate('Hash#&', 'Please use Sequel.& instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
+  end
+
+  def |(ce)
+    Sequel::Deprecation.deprecate('Hash#|', 'Please use Sequel.| instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
+  end
+
+  def ~
+    Sequel::Deprecation.deprecate('Hash#~', 'Please use Sequel.~ instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
+  end
+
+  def case(*args)
+    Sequel::Deprecation.deprecate('Hash#case', 'Please use Sequel.case instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::CaseExpression.new(to_a, *args)
+  end
+
+  def sql_expr
+    Sequel::Deprecation.deprecate('Hash#sql_expr', 'Please use Sequel.expr instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
+  end
+
+  def sql_negate
+    Sequel::Deprecation.deprecate('Hash#sql_negate', 'Please use Sequel.negate instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
+  end
+
+  def sql_or
+    Sequel::Deprecation.deprecate('Hash#sql_or', 'Please use Sequel.or instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
+  end
+end
+
+class String
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::AliasMethods){|meth| ["String#as", 'Please use Sequel.as instead, or Sequel.extension(:core_extensions) to continue using it']}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::CastMethods){|meth| ["String##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+
+  def lit(*args)
+    Sequel::Deprecation.deprecate('String#lit', 'Please use Sequel.lit instead, or Sequel.extension(:core_extensions) to continue using it')
+    args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
+  end
+  
+  def to_sequel_blob
+    Sequel::Deprecation.deprecate('String#to_sequel_blob', 'Please use Sequel.blob instead, or Sequel.extension(:core_extensions) to continue using it')
+    ::Sequel::SQL::Blob.new(self)
+  end
+end
+
+class Symbol
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::AliasMethods){|meth| ["Symbol#as", 'Please use Sequel.as instead, or Sequel.extension(:core_extensions) to continue using it']}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::CastMethods){|meth| ["Symbol##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::OrderMethods){|meth| ["Symbol##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::BooleanMethods){|meth| ["Symbol##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::NumericMethods){|meth| ["Symbol##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+  include(Sequel::Deprecation.deprecated_module(Sequel::SQL::QualifyingMethods){|meth| ["Symbol##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}.module_eval do
+    def *(ce=(arg=false;nil))
+      if arg == false
+        Sequel::Deprecation.deprecate('Symbol#*', "Please use Sequel.expr(symbol).* instead, or Sequel.extension(:core_extensions) to continue using it")
+        Sequel::SQL::ColumnAll.new(self)
+      else
+        super(ce)
+      end
+    end
+    self
+  end)
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::StringMethods){|meth| ["Symbol##{meth}", "Please use Sequel.#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::SubscriptMethods){["Symbol#sql_subscript", "Please use Sequel.subscript instead, or Sequel.extension(:core_extensions) to continue using it"]}
+  include Sequel::Deprecation.deprecated_module(Sequel::SQL::ComplexExpressionMethods){|meth| ["Symbol##{meth}", "Please use Sequel.expr(symbol).#{meth} instead, or Sequel.extension(:core_extensions) to continue using it"]}
+
+  if RUBY_VERSION < '1.9.0'
+    include Sequel::Deprecation.deprecated_module(Sequel::SQL::InequalityMethods){|meth| ["Symbol##{meth}", "Please use Sequel.expr(symbol).#{meth} instead, or Sequel.extension(:ruby18_symbol_extensions) to continue using it"]}
+  end
+
+  def identifier
+    Sequel::Deprecation.deprecate('Symbol#identifier', 'Please use Sequel.identifier instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel::SQL::Identifier.new(self)
+  end
+
+  def sql_function(*args)
+    Sequel::Deprecation.deprecate('Symbol#sql_function', 'Please use Sequel.function instead, or Sequel.extension(:core_extensions) to continue using it')
+    Sequel::SQL::Function.new(self, *args)
+  end
+  if RUBY_VERSION < '1.9.0'
+    def [](*args)
+      Sequel::Deprecation.deprecate('Symbol#[]', 'Please use Sequel.function instead, or Sequel.extension(:ruby18_symbol_extensions) to continue using it')
+      Sequel::SQL::Function.new(self, *args)
+    end
+  end
+end

data/lib/sequel/extensions/columns_introspection.rb

@@ -14,11 +14,6 @@
 # To attempt to introspect columns for all datasets on a single database:
 #
 #   DB.extension(:columns_introspection)
-#
-# To attempt to introspect columns for all datasets on all databases:
-#
-#   Sequel.extension :columns_introspection
-#   Sequel::Dataset.introspect_all_columns
 
 module Sequel
   module ColumnsIntrospection
@@ -87,6 +82,7 @@ module Sequel
 
     # Enable column introspection for every dataset.
     def self.introspect_all_columns
+      Sequel::Deprecation.deprecate('Sequel::Dataset.introspect_all_columns', "Please use Database.extension :columns_introspection to load the extension into all databases")
       include ColumnsIntrospection
       remove_method(:columns) if instance_methods(false).map{|x| x.to_s}.include?('columns')
     end

data/lib/sequel/extensions/core_extensions.rb

@@ -4,7 +4,7 @@
 # expression objects.
 #
 # This extension is currently loaded by default, but that will no
-# longer be true in a future version.  In a future version, you will
+# longer be true in Sequel 4.  Starting in Sequel 4, you will
 # need to load it manually via:
 #
 #   Sequel.extension :core_extensions
@@ -208,7 +208,9 @@ class Symbol
   include Sequel::SQL::StringMethods
   include Sequel::SQL::SubscriptMethods
   include Sequel::SQL::ComplexExpressionMethods
-  include Sequel::SQL::InequalityMethods if RUBY_VERSION < '1.9.0'
+  if RUBY_VERSION < '1.9.0'
+    include Sequel::Deprecation.deprecated_module(Sequel::SQL::InequalityMethods){|meth| ["Symbol##{meth}", "Please use Sequel.expr(symbol).#{meth} instead, or Sequel.extension(:ruby18_symbol_extensions) to continue using it"]}
+  end
 
   # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.  Usually used to
   # prevent splitting the symbol.
@@ -230,5 +232,10 @@ class Symbol
   def sql_function(*args)
     Sequel::SQL::Function.new(self, *args)
   end
-  alias_method(:[], :sql_function) if RUBY_VERSION < '1.9.0'
+  if RUBY_VERSION < '1.9.0'
+    def [](*args)
+      Sequel::Deprecation.deprecate('Symbol#[]', 'Please use Sequel.function instead, or Sequel.extension(:ruby18_symbol_extensions) to continue using it')
+      Sequel::SQL::Function.new(self, *args)
+    end
+  end
 end

data/lib/sequel/extensions/date_arithmetic.rb

@@ -122,6 +122,7 @@ module Sequel
             end
             false
           else
+            Sequel::Deprecation.deprecate('Sequel::NotImplemented', 'Sequel 4 will just raise Error if date_arithmetic is not supported on the database')
             raise NotImplemented, "date arithmetic is not implemented on #{db.database_type}"
           end
 

data/lib/sequel/extensions/empty_array_ignore_nulls.rb

@@ -0,0 +1,33 @@
+# This changes Sequel's literalization of IN/NOT IN with an empty
+# array value to not return NULL even if one of the referenced
+# columns is NULL:
+#
+#   DB[:test].where(:name=>[])
+#   # SELECT * FROM test WHERE (1 = 0)
+#   DB[:test].exclude(:name=>[])
+#   # SELECT * FROM test WHERE (1 = 1)
+#
+# The default Sequel behavior is to respect NULLs, so that when
+# name is NULL, the expression returns NULL.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds.extension(:empty_array_ignore_nulls)
+#
+# 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(:empty_array_ignore_nulls)
+
+module Sequel
+  module EmptyArrayIgnoreNulls
+    # Use a simple expression that is always true or false, never NULL.
+    def empty_array_value(op, cols)
+      {1 => ((op == :IN) ? 0 : 1)}
+    end
+    
+  end
+
+  Dataset.register_extension(:empty_array_ignore_nulls, EmptyArrayIgnoreNulls)
+end

data/lib/sequel/extensions/filter_having.rb

@@ -0,0 +1,58 @@
+# The filter_having extension allows Dataset#filter, #and, #or
+# and #exclude to operate on the HAVING clause if the dataset
+# already has a HAVING clause, which was the historical behavior
+# before Sequel 4.  It is only recommended to use this for
+# backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds.extension(:filter_having)
+#
+# 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(:filter_having)
+
+module Sequel
+  module FilterHaving
+    # Operate on HAVING clause if HAVING clause already present.
+    def and(*cond, &block)
+      if @opts[:having]
+        having(*cond, &block)
+      else
+        super
+      end
+    end
+
+    # Operate on HAVING clause if HAVING clause already present.
+    def exclude(*cond, &block)
+      if @opts[:having]
+        exclude_having(*cond, &block)
+      else
+        super
+      end
+    end
+
+    # Operate on HAVING clause if HAVING clause already present.
+    def filter(*cond, &block)
+      if @opts[:having]
+        having(*cond, &block)
+      else
+        super
+      end
+    end
+
+    # Operate on HAVING clause if HAVING clause already present.
+    def or(*cond, &block)
+      if having = @opts[:having]
+        cond = cond.first if cond.size == 1
+        clone(:having => SQL::BooleanExpression.new(:OR, having, filter_expr(cond, &block)))
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:filter_having, FilterHaving)
+end