sequel 5.8.0 → 5.9.0

data/lib/sequel/dataset/query.rb

@@ -113,6 +113,11 @@ module Sequel
     #  DB[:items].distinct # SQL: SELECT DISTINCT * FROM items
     #  DB[:items].order(:id).distinct(:id) # SQL: SELECT DISTINCT ON (id) * FROM items ORDER BY id
     #  DB[:items].order(:id).distinct{func(:id)} # SQL: SELECT DISTINCT ON (func(id)) * FROM items ORDER BY id
+    #
+    # There is support for emualting the DISTINCT ON support in MySQL, but it
+    # does not support the ORDER of the dataset, and also doesn't work in many
+    # cases if the ONLY_FULL_GROUP_BY sql_mode is used, which is the default on
+    # MySQL 5.7.5+.
     def distinct(*args, &block)
       virtual_row_columns(args, block)
       if args.empty?

data/lib/sequel/dataset/sql.rb

@@ -28,7 +28,7 @@ module Sequel
 
       case values.size
       when 0
-        return insert_sql({})
+        return insert_sql(OPTS)
       when 1
         case vals = values[0]
         when Hash
@@ -389,8 +389,10 @@ module Sequel
         literal_append(sql, args[0])
         sql << ' ' << op.to_s << ' '
         literal_append(sql, args[1])
-        sql << " ESCAPE "
-        literal_append(sql, "\\")
+        if requires_like_escape?
+          sql << " ESCAPE "
+          literal_append(sql, "\\")
+        end
         sql << ')'
       when :ILIKE, :'NOT ILIKE'
         complex_expression_sql_append(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|v| Sequel.function(:UPPER, v)})
@@ -577,7 +579,7 @@ module Sequel
           sql << str
         else
           re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
-          loop do
+          while true
             previous, q, str = str.partition(re)
             sql << previous
             literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
@@ -596,13 +598,13 @@ module Sequel
       else
         i = -1
         match_len = args.length - 1
-        loop do
+        while true
           previous, q, str = str.partition('?')
           sql << previous
           literal_append(sql, args.at(i+=1)) unless q.empty?
           if str.empty?
             unless i == match_len
-              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{args.length}) when using placeholder array"
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{args.length}) when using placeholder string"
             end
             break
           end

data/lib/sequel/extensions/escaped_like.rb

@@ -0,0 +1,100 @@
+# frozen-string-literal: true
+#
+# The escaped_like extension adds +escaped_like+ and +escaped_ilike+
+# methods to Sequel::SQL::StringMethods, which allow them to be easily
+# used with most of Sequel's expression objects.  Example:
+#
+#   DB[:table].where{string_column.escaped_like('?%', user_input)}
+#   # user_input is 'foo':
+#   #  SELECT * FROM table WHERE string_column LIKE 'foo%' ESCAPE '\'
+#   # user_input is '%foo':
+#   #  SELECT * FROM table WHERE string_column LIKE '\%foo%' ESCAPE '\'
+#
+# To load the extension:
+#
+#   Sequel.extension :escaped_like
+#
+# Related modules: Sequel::SQL::StringMethods, Sequel::SQL::EscapedLikeExpression
+
+#
+module Sequel
+  module SQL
+    # Represents an pattern match SQL expression, where the pattern can depend
+    # upon interpolated values in a database-dependent manner.
+    class EscapedLikeExpression < Expression
+      include AliasMethods
+      include BooleanMethods
+      include CastMethods
+      include OrderMethods
+
+      # Initialize the expression. Arguments:
+      # expr :: Right hand site of LIKE/ILIKE operator, what you are matching against the pattern
+      # case_insensitive :: Whether the match is case sensitive
+      # placeholder_pattern :: The pattern to match against, with +?+ for the placeholders
+      # placeholder_values :: The string values for each +?+ in the placeholder pattern.  Should be an
+      #                       array of strings, though it can be a single string if there is only
+      #                       a single placeholder.
+      def initialize(expr, case_sensitive, placeholder_pattern, placeholder_values)
+        @expr = expr
+        @method = case_sensitive ? :like : :ilike
+        @pattern = placeholder_pattern
+        unless placeholder_values.is_a?(Array)
+          placeholder_values = [placeholder_values].freeze
+        end
+        @values = placeholder_values
+        freeze
+      end
+
+      # Interpolate the pattern values into the placeholder pattern to get the final pattern,
+      # now that we have access to the dataset.  Use the expression and final pattern and
+      # add an appropriate LIKE/ILIKE expression to the SQL being built.
+      def to_s_append(ds, sql)
+        i = -1
+        match_len = @values.length - 1
+        like_pattern = String.new
+        pattern = @pattern
+        while true
+          previous, q, pattern = pattern.partition('?')
+          like_pattern << previous
+
+          unless q.empty?
+            if i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            like_pattern << ds.escape_like(@values.at(i+=1))
+          end
+
+          if pattern.empty?
+            unless i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            break
+          end
+        end
+        ds.literal_append(sql, Sequel.send(@method, @expr, like_pattern))
+      end
+    end
+
+    module StringMethods
+      # Create a +EscapedLikeExpression+ case insensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_ilike('?%', 'A') # "a" ILIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_ilike('?%', '%A') # "a" ILIKE '\%A%' ESCAPE '\'
+      def escaped_ilike(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, false, placeholder_pattern, placeholder_values)
+      end
+
+      # Create a +EscapedLikeExpression+ case sensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_like('?%', 'A') # "a" LIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_like('?%', '%A') # "a" LIKE '\%A%' ESCAPE '\'
+      def escaped_like(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, true, placeholder_pattern, placeholder_values)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/eval_inspect.rb

@@ -26,7 +26,9 @@ module Sequel
     # for eval.
     def eval_inspect(obj)
       case obj
-      when Sequel::SQL::Blob, Sequel::LiteralString, BigDecimal
+      when BigDecimal
+        "BigDecimal(#{obj.to_s.inspect})"
+      when Sequel::SQL::Blob, Sequel::LiteralString
         "#{obj.class}.new(#{obj.to_s.inspect})"
       when Sequel::SQL::ValueList
         "#{obj.class}.new(#{obj.to_a.inspect})"

data/lib/sequel/extensions/looser_typecasting.rb

@@ -36,14 +36,14 @@ module Sequel
 
     if RUBY_VERSION >= '2.4'
       def _typecast_value_string_to_decimal(value)
-        BigDecimal.new(value)
+        BigDecimal(value)
       rescue
-        BigDecimal.new('0.0')
+        BigDecimal('0.0')
       end
     else
       # :nocov:
       def _typecast_value_string_to_decimal(value)
-        BigDecimal.new(value)
+        BigDecimal(value)
       end
       # :nocov:
     end

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -86,9 +86,19 @@ module Sequel
         if value.is_a?(String) && (m = value.match(/(?:(?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[1] || m[2])
           if m[2]
             value = value.sub(' BC', '').sub(' ', ' BC ')
+            conv = defined?(JRUBY_VERSION) && JRUBY_VERSION == '9.2.0.0'
           end
-          if m[1]
+          if m[1] || conv
             dt = DateTime.parse(value)
+            if conv
+              # :nocov:
+              if Sequel.datetime_class == DateTime
+                dt >>= 12
+              else
+                dt >>= 24
+              end
+              # :nocov:
+            end
             dt = dt.to_time unless Sequel.datetime_class == DateTime
             Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
           else
@@ -191,15 +201,6 @@ module Sequel
         if RUBY_ENGINE == 'jruby'
           # :nocov:
 
-          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
-          def literal_time(time)
-            if time < TIME_YEAR_1
-              literal_datetime(DateTime.parse(super))
-            else
-              super
-            end
-          end
-
           ExtendedDateSupport::CONVERT_TYPES = [Java::JavaSQL::Types::DATE, Java::JavaSQL::Types::TIMESTAMP]
 
           # Use non-JDBC parsing as JDBC parsing doesn't work for BC dates/timestamps.
@@ -211,6 +212,18 @@ module Sequel
               super
             end
           end
+
+          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              dt = DateTime.parse(super)
+              # Work around JRuby bug #5191
+              dt >>= 12 if JRUBY_VERSION == '9.2.0.0'
+              literal_datetime(dt)
+            else
+              super
+            end
+          end
           # :nocov:
         else
           # Handle BC Time objects.

data/lib/sequel/model/associations.rb

@@ -2751,7 +2751,7 @@ module Sequel
           opts = @opts[:eager]
           association_opts = eager_options_for_associations(associations)
           opts = opts ? Hash[opts].merge!(association_opts) : association_opts
-          clone(:eager=>opts)
+          clone(:eager=>opts.freeze)
         end
 
         # The secondary eager loading method.  Loads all associations in a single query. This
@@ -2800,8 +2800,9 @@ module Sequel
         #                    significantly slower in some cases (perhaps even the majority of cases), so you should
         #                    only use this if you have benchmarked that it is faster for your use cases.
         def eager_graph_with_options(associations, opts=OPTS)
+          opts = opts.dup unless opts.frozen?
           associations = [associations] unless associations.is_a?(Array)
-          if eg = @opts[:eager_graph]
+          ds = if eg = @opts[:eager_graph]
             eg = eg.dup
             [:requirements, :reflections, :reciprocals, :limits].each{|k| eg[k] = eg[k].dup}
             eg[:local] = opts
@@ -2815,8 +2816,12 @@ module Sequel
             # :limits :: Any limit/offset array slicing that need to be handled in ruby land after loading
             opts = {:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :limits=>{}, :local=>opts, :cartesian_product_number=>0, :row_proc=>row_proc}
             ds = clone(:eager_graph=>opts)
-            ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
+            ds = ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
           end
+
+          ds.opts[:eager_graph].freeze
+          ds.opts[:eager_graph].each_value{|v| v.freeze if v.is_a?(Hash)}
+          ds
         end
 
         # If the dataset is being eagerly loaded, default to calling all
@@ -3081,7 +3086,7 @@ module Sequel
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
-              associations = {}
+              associations = OPTS
             elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
               eager_block, associations = pr_assoc
             end
@@ -3353,6 +3358,15 @@ module Sequel
               key = hkey(ta_h)
             end
             rm, rp, assoc_name, tm, rcm = @ta_map[ta]
+
+            # Check type map for all dependencies, and use a unique
+            # object if any are dependencies for multiple objects,
+            # to prevent duplicate objects from showing up in the case
+            # the normal duplicate removal code is not being used.
+            if !@unique && !deps.empty? && deps.any?{|dep_key,_| @ta_map[dep_key][3]}
+              key = [current.object_id, key]
+            end
+
             unless rec = rm[key]
               rec = rm[key] = rp.call(hfor(ta, h))
             end

data/lib/sequel/model/base.rb

@@ -250,7 +250,7 @@ module Sequel
       #   Artist.create do |a|
       #     a.name = 'Jim'
       #   end # INSERT INTO artists (name) VALUES ('Jim')
-      def create(values = {}, &block)
+      def create(values = OPTS, &block)
         new(values, &block).save
       end
   
@@ -446,6 +446,13 @@ module Sequel
         super
       end
 
+      # Whether the model has a dataset.  True for most model classes,
+      # but can be false if the model class is an abstract model class
+      # designed for subclassing, such as Sequel::Model itself.
+      def has_dataset?
+        !@dataset.nil?
+      end
+
       # Clear the setter_methods cache when a module is included, as it
       # may contain setter methods.
       def include(*mods)
@@ -1055,7 +1062,7 @@ module Sequel
       #   Artist.new do |a|
       #     a.name = 'Bob'
       #   end
-      def initialize(values = {})
+      def initialize(values = OPTS)
         @values = {}
         @new = true
         @modified = true

data/lib/sequel/plugins/defaults_setter.rb

@@ -95,7 +95,7 @@ module Sequel
               end
             end
           end
-          @default_values = h.merge!(@default_values || {})
+          @default_values = h.merge!(@default_values || OPTS)
         end
 
         # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or

data/lib/sequel/plugins/many_through_many.rb

@@ -144,7 +144,7 @@ module Sequel
             table_alias = e[:table]
             if aliases.include?(table_alias)
               i = 0
-              table_alias = loop do
+              table_alias = while true
                 ta = :"#{table_alias}_#{i}"
                 break ta unless aliases.include?(ta)
                 i += 1

data/lib/sequel/plugins/nested_attributes.rb

@@ -114,10 +114,10 @@ module Sequel
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
           include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
-          opts = associations.last.is_a?(Hash) ? associations.pop : {}
+          opts = associations.last.is_a?(Hash) ? associations.pop : OPTS
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
-            r[:nested_attributes] = opts
+            r[:nested_attributes] = opts.dup
             r[:nested_attributes][:unmatched_pk] ||= :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -64,7 +64,7 @@ module Sequel
       def self.configure(model, opts=OPTS)
         model.instance_exec do
           setup_pg_auto_constraint_validations
-          @pg_auto_constraint_validations_messages = (@pg_auto_constraint_validations_messages || DEFAULT_ERROR_MESSAGES).merge(opts[:messages] || {}).freeze
+          @pg_auto_constraint_validations_messages = (@pg_auto_constraint_validations_messages || DEFAULT_ERROR_MESSAGES).merge(opts[:messages] || OPTS).freeze
         end
       end
 
@@ -195,7 +195,7 @@ module Sequel
                 end
               end
             end
-          rescue => e2
+          rescue
             # If there is an error trying to conver the constraint violation
             # into a validation failure, it's best to just raise the constraint
             # violation.  This can make debugging the above block of code more

data/lib/sequel/plugins/rcte_tree.rb

@@ -105,7 +105,6 @@ module Sequel
           key_present = lambda{|m| key_conv[m].all?}
           prkey_conv = lambda{|m| prkey_array.map{|k| m[k]}}
           key_aliases = (0...key_array.length).map{|i| :"#{ka}_#{i}"}
-          ka_conv = lambda{|m| key_aliases.map{|k| m[k]}}
           ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
@@ -114,18 +113,17 @@ module Sequel
           key_present = key_conv = lambda{|m| m[key]}
           prkey_conv = lambda{|m| m[prkey]}
           key_aliases = [ka]
-          ka_conv = lambda{|m| m[ka]}
           ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
           descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
           recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
           extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
         end
         
-        parent = opts.merge(opts.fetch(:parent, {})).fetch(:name, :parent)
-        childrena = opts.merge(opts.fetch(:children, {})).fetch(:name, :children)
+        parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
+        childrena = opts.merge(opts.fetch(:children, OPTS)).fetch(:name, :children)
         
         opts[:reciprocal] = nil
-        a = opts.merge(opts.fetch(:ancestors, {}))
+        a = opts.merge(opts.fetch(:ancestors, OPTS))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
         a[:eager_loader_key] = key
@@ -220,7 +218,7 @@ module Sequel
         end
         model.one_to_many ancestors, a
         
-        d = opts.merge(opts.fetch(:descendants, {}))
+        d = opts.merge(opts.fetch(:descendants, OPTS))
         descendants = d.fetch(:name, :descendants)
         d[:read_only] = true unless d.has_key?(:read_only)
         la = d[:level_alias] ||= :x_level_x
@@ -296,7 +294,7 @@ module Sequel
               :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>{})) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end

data/lib/sequel/plugins/sharding.rb

@@ -21,7 +21,7 @@ module Sequel
     module Sharding
       module ClassMethods
         # Create a new object on the given shard s.
-        def create_using_server(s, values={}, &block)
+        def create_using_server(s, values=OPTS, &block)
           new_using_server(s, values, &block).save
         end
 
@@ -45,7 +45,7 @@ module Sequel
         # Return a newly instantiated object that is tied to the given
         # shard s.  When the object is saved, a record will be inserted
         # on shard s.
-        def new_using_server(s, values={}, &block)
+        def new_using_server(s, values=OPTS, &block)
           new(values, &block).set_server(s)
         end