sequel 5.13.0 → 5.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc4068290931cd51d12ec42e40a1e383ffa9cc8448501970230ec0863fc1cc21
-  data.tar.gz: 16c549d0adcd8700bfb498bc2a459437a37c57a85d9048099336105efff376ad
+  metadata.gz: a950f8be723b867d5ecc782005c2374fa84a05a6b54c4ba55652f5442de1c90b
+  data.tar.gz: c5b2c92ee3580933b9fcd0525fdb67a79f5915f8b8e337e4731b9046f771dbf0
 SHA512:
-  metadata.gz: 3f6acb6af9670774bf87b19349e778cb7b967ac529bbd192ea3ce2b6790080c21afa4445faabe18de148cfcef894e5457924782fb5462289dc38ff9af4ab5fcb
-  data.tar.gz: e03cf594244024d41de805ef57bcdc545bd9bb247e34fcd48e1d6fba8c558f8dacc49828b5f529e465b9a5a6089e66adc5e1a8d43cf7029225556429aa97441b
+  metadata.gz: 4671d49935656b0ec907f10d3d4a6b25e29815b328b7661e55d95e4bfabbf84818de2b3550d92d86f444fbd69a561f099c859a5b1156303e10d58a7402641ebc
+  data.tar.gz: 5488428f7290a548344849919a7895dfd1e8d7cbe7990c2b261b4118e2a46845d9bde30b00673928511e2e650b3e4098f81cb2087d8f42227653607d3ae90c6f

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 5.14.0 (2018-11-01)
+
+* Drop defaulting the :port option to 5432 in the postgres adapter, so that setting the :service option in :driver_options works (jeremyevans) (#1558)
+
+* Do not cache values for columns without parseable defaults when using :cache option in defaults_setter plugin (jeremyevans)
+
+* Emulate NULLS FIRST/LAST ordering on databases that do not natively support it (jeremyevans)
+
+* Do not modify boolean expressions created from string or array if string or array is modified (jeremyevans)
+
+* Make roots and roots_dataset dataset methods instead of class methods in the tree plugin (JelF) (#1554)
+
+* Do not cache dataset SQL if dataset uses subquery that cannot cache SQL (jeremyevans)
+
+* Make Model#=== work correctly for models with composite primary keys (jeremyevans)
+
+* Add Model#pk_equal? as a more descriptive name for Model#=== (AlexWayfer) (#1550)
+
+* Do not push down expression inversion in cases where it may result in incorrect behavior (e.g. ANY/SOME/ALL operators) (jeremyevans) (#1549)
+
 === 5.13.0 (2018-10-01)
 
 * Support :single_value type in prepared statements (rintaun) (#1547)

data/doc/postgresql.rdoc

@@ -63,6 +63,14 @@ into the Database instance:
   DB.extension :pg_array
   Sequel.extension :pg_array_ops
 
+With regard to common database types, please note that the generic String type
+is +text+ on PostgreSQL and not <tt>varchar(255)</tt> as it is on some other
+databases.  +text+ is PostgreSQL's recommended type for storage of text data,
+and is more similar to Ruby's String type as it allows for unlimited length.
+If you want to set a maximum size for a text column, you must specify a
+<tt>:size</tt> option.  This will use a <tt>varchar($size)</tt> type and
+impose a maximum size for the column.
+
 == PostgreSQL-specific DDL Support
 
 === Exclusion Constraints
@@ -301,6 +309,18 @@ can pass an +:update+ option with a hash of values to update.  You must pass eit
   DB[:table].insert_conflict(target: :a, update: {b: Sequel[:excluded][:b]}).insert(a: 1, b: 2)
   # INSERT INTO TABLE (a, b) VALUES (1, 2)
   # ON CONFLICT (a) DO UPDATE SET b = excluded.b
+
+If you want to update existing rows but using the current value of the column, you can build
+the desired calculation using <tt>Sequel[]</tt>
+
+  DB[:table]
+    .insert_conflict(
+      target: :a,
+      update: {b: Sequel[:excluded][:b] + Sequel[:table][:a]}
+    )
+    .import([:a, :b], [ [1, 2] ])
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT (a) DO UPDATE SET b = (excluded.b + table.a)
  
 Additionally, if you only want to do the update in certain cases, you can specify an
 +:update_where+ option, which will be used as a filter.  If the row doesn't match the

data/doc/release_notes/5.14.0.txt

@@ -0,0 +1,63 @@
+= New Features
+
+* The :nulls option when creating ordered expressions is now supported
+  on all databases that Sequel ships support for.  For databases that
+  do not support NULLS FIRST/NULLS LAST, support is emulated.
+
+    ds.order(Sequel.asc(:name, :nulls=>:last))
+    # When emulated:
+    # ORDER BY (CASE WHEN (name IS NULL) THEN 2 ELSE 1 END), name ASC
+
+* Model#pk_equal? has been added as a more descriptive name for
+  Model#===.  Model#=== is now an alias of Model#pk_equal?.
+
+* The roots and roots_dataset class methods in the tree plugin are now
+  also available as dataset methods.
+
+= Other Improvements
+
+* Inverting expressions using the ANY/SOME/ALL SQL operators now works
+  correctly:
+
+    # Sequel <5.14.0
+    Sequel.~(:a=>Sequel.function(:any, :x))
+    # "(a != any(x))"
+
+    # Sequel >=5.14.0
+    Sequel.~(:a=>Sequel.function(:any, :x))
+    # "NOT (a = any(x))"
+
+  Sequel has always tried to push inversion down to create SQL that is
+  easier to reason about.  However, inversion cannot be pushed down if
+  an ANY/SOME/ALL SQL operator is used, because that is a different
+  type of operation that just happens to use the same syntax.  Sequel
+  now avoids inversion push down for boolean operators where the
+  right hand side is an SQL::Function, LiteralString, or
+  SQL::PlaceholderLiteralString.
+
+* When creating a boolean expression from a hash or array of pairs, if
+  the right hand side is an unfrozen array and string, use a frozen
+  copy in the expression, so that mutating the array or string
+  argument later does not affect the expression.
+
+* When using the defaults_setter plugin with the :cache option, do not
+  cache values for columns without parseable defaults.  If the default
+  value exists but is not parseable, caching such values could result
+  in incorrect behavior if the model instance is saved later.
+
+* For models with composite primary keys, Model#=== now returns false
+  if any primary key value is nil, mirroring the behavior for the
+  scalar primary key case.
+
+* Model datasets no longer cache SQL if they include a subquery that
+  cannot cache SQL.
+
+* The SQL used for constraints in the constraint_validations
+  extension when the :allow_nil option is used is now clearer and
+  easier to understand.
+
+* The postgres adapter no longer specifies a default port when using
+  the pg driver, in order to work with configurations where the
+  :service option is used in the :driver_options hash.  The pg driver
+  defaults to port 5432 if no port is given, so this should not affect
+  backwards compatibility.

data/lib/sequel/adapters/postgres.rb

@@ -194,7 +194,7 @@ module Sequel
         if USES_PG
           connection_params = {
             :host => opts[:host],
-            :port => opts[:port] || 5432,
+            :port => opts[:port],
             :dbname => opts[:database],
             :user => opts[:user],
             :password => opts[:password],

data/lib/sequel/adapters/shared/access.rb

@@ -234,6 +234,11 @@ module Sequel
         end
       end
 
+      # Access does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       # Access doesn't support ESCAPE for LIKE.
       def requires_like_escape?
         false

data/lib/sequel/adapters/shared/db2.rb

@@ -418,6 +418,11 @@ module Sequel
         false
       end
 
+      # At least some versions of DB do not support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       # Modify the sql to limit the number of rows returned.
       # Uses :offset_strategy Database option to determine how to format the
       # limit and offset.

data/lib/sequel/adapters/shared/mssql.rb

@@ -1046,6 +1046,11 @@ module Sequel
         end
       end
 
+      # MSSQL does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       # MSSQL supports 100-nsec precision for time columns, but ruby by
       # default only supports usec precision.
       def sqltime_precision

data/lib/sequel/adapters/shared/mysql.rb

@@ -1008,6 +1008,11 @@ module Sequel
         super || key == :insert_ignore || key == :update_ignore || key == :on_duplicate_key_update
       end
 
+      # MySQL does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       def select_only_offset_sql(sql)
         sql << " LIMIT "
         literal_append(sql, @opts[:offset])

data/lib/sequel/adapters/shared/sqlanywhere.rb

@@ -397,6 +397,11 @@ module Sequel
         :values
       end
 
+      # SQLAnywhere does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       def select_into_sql(sql)
         if i = @opts[:into]
           sql << " INTO "

data/lib/sequel/adapters/shared/sqlite.rb

@@ -825,6 +825,11 @@ module Sequel
         end
       end
 
+      # SQLite does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       # SQLite does not support FOR UPDATE, but silently ignore it
       # instead of raising an error for compatibility with other
       # databases.

data/lib/sequel/dataset/features.rb

@@ -220,6 +220,11 @@ module Sequel
       true
     end
 
+    # Whether ORDER BY col NULLS FIRST/LAST must be emulated.
+    def requires_emulating_nulls_first?
+      false
+    end
+
     # Whether common table expressions are supported in UNION/INTERSECT/EXCEPT clauses.
     def supports_cte_in_compounds?
       supports_cte_in_subqueries?

data/lib/sequel/dataset/sql.rb

@@ -559,13 +559,30 @@ module Sequel
 
     # Append literalization of ordered expression to SQL string.
     def ordered_expression_sql_append(sql, oe)
+      if emulate = requires_emulating_nulls_first?
+        case oe.nulls
+        when :first
+          null_order = 0
+        when :last
+          null_order = 2
+        end
+
+        if null_order
+          literal_append(sql, Sequel.case({{oe.expression=>nil}=>null_order}, 1))
+          sql << ", "
+        end
+      end
+
       literal_append(sql, oe.expression)
       sql << (oe.descending ? ' DESC' : ' ASC')
-      case oe.nulls
-      when :first
-        sql << " NULLS FIRST"
-      when :last
-        sql << " NULLS LAST"
+
+      unless emulate
+        case oe.nulls
+        when :first
+          sql << " NULLS FIRST"
+        when :last
+          sql << " NULLS LAST"
+        end
       end
     end
 
@@ -1553,7 +1570,13 @@ module Sequel
 
     # Append literalization of the subselect to SQL string.
     def subselect_sql_append(sql, ds)
-      subselect_sql_dataset(sql, ds).sql
+      sds = subselect_sql_dataset(sql, ds)
+      sds.sql
+      unless sds.send(:cache_sql?)
+        # If subquery dataset does not allow caching SQL,
+        # then this dataset should not allow caching SQL.
+        disable_sql_caching!
+      end
     end
 
     def subselect_sql_dataset(sql, ds)

data/lib/sequel/extensions/constraint_validations.rb

@@ -355,6 +355,18 @@ module Sequel
       super
     end
 
+    def constraint_validation_expression(cols, allow_nil)
+      exprs = cols.map do |c|
+        expr = yield c
+        if allow_nil
+          Sequel.|({c=>nil}, expr)
+        else
+          Sequel.&(Sequel.~(c=>nil), expr)
+        end
+      end
+      Sequel.&(*exprs)
+    end
+
     # For the given table, generator, and validations, add constraints
     # to the generator for each of the validations, as well as adding
     # validation metadata to the constraint validations table.
@@ -365,28 +377,44 @@ module Sequel
 
         case validation_type
         when :presence
-          string_check = columns.select{|c| generator_string_column?(generator, table, c)}.map{|c| [Sequel.trim(c), blank_string_value]}
-          generator_add_constraint_from_validation(generator, val, (Sequel.negate(string_check) unless string_check.empty?))
+          strings, non_strings = columns.partition{|c| generator_string_column?(generator, table, c)}
+          if !non_strings.empty? && !allow_nil
+            non_strings_expr = Sequel.&(*non_strings.map{|c| Sequel.~(c=>nil)})
+          end
+
+          unless strings.empty?
+            strings_expr = constraint_validation_expression(strings, allow_nil){|c| Sequel.~(Sequel.trim(c) => blank_string_value)}
+          end
+
+          expr = if non_strings_expr && strings_expr
+            Sequel.&(strings_expr, non_strings_expr)
+          else
+            strings_expr || non_strings_expr
+          end
+
+          if expr
+            generator.constraint(constraint, expr)
+          end
         when :exact_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {Sequel.char_length(c) => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {Sequel.char_length(c) => arg}})
         when :min_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) >= arg}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.char_length(c) >= arg})
         when :max_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) <= arg}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.char_length(c) <= arg})
         when *REVERSE_OPERATOR_MAP.keys
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.identifier(c).public_send(REVERSE_OPERATOR_MAP[validation_type], arg)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.identifier(c).public_send(REVERSE_OPERATOR_MAP[validation_type], arg)})
         when :length_range
           op = arg.exclude_end? ? :< : :<=
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).public_send(op, arg.end)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).public_send(op, arg.end)})
           arg = "#{arg.begin}..#{'.' if arg.exclude_end?}#{arg.end}"
         when :format
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {c => arg}})
           if arg.casefold?
             validation_type = :iformat
           end
           arg = arg.source
         when :includes
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {c => arg}})
           if arg.is_a?(Range)
             if arg.begin.is_a?(Integer) && arg.end.is_a?(Integer)
               validation_type = :includes_int_range
@@ -407,7 +435,7 @@ module Sequel
             raise Error, "validates includes only supports arrays and ranges currently, cannot handle: #{arg.inspect}"
           end
         when :like, :ilike
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.public_send(validation_type, c, arg)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.public_send(validation_type, c, arg)})
         when :unique
           generator.unique(columns, :name=>constraint)
           columns = [columns.join(',')]
@@ -438,23 +466,6 @@ module Sequel
       ds.multi_insert(rows.flatten)
     end
 
-    # Add the constraint to the generator, including a NOT NULL constraint
-    # for all columns unless the :allow_nil option is given.
-    def generator_add_constraint_from_validation(generator, val, cons)
-      if val[:allow_nil]
-        nil_cons = Sequel[val[:columns].map{|c| [c, nil]}]
-        cons = Sequel.|(nil_cons, cons) if cons
-      else
-        nil_cons = Sequel.negate(val[:columns].map{|c| [c, nil]})
-        cons = cons ? Sequel.&(nil_cons, cons) : nil_cons
-      end
-
-      if cons
-        generator.constraint(val[:name], cons)
-      end
-    end
-
-
     # Introspect the generator to determine if column
     # created is a string or not.
     def generator_string_column?(generator, table, c)

data/lib/sequel/extensions/integer64.rb

@@ -20,7 +20,7 @@
 #
 module Sequel
   module Integer64
-    # Use timestamptz by default for generic timestamp value.
+    # Use same type as used for :Bignum by default for generic integer value.
     def type_literal_generic_integer(column)
       type_literal_generic_bignum_symbol(column)
     end

data/lib/sequel/model/base.rb

@@ -1103,16 +1103,33 @@ module Sequel
         eql?(obj)
       end
   
-      # If pk is not nil, true only if the objects have the same class and pk.
-      # If pk is nil, false.
+      # Case equality.  By default, checks equality of the primary key value, see
+      # pk_equal?.
       #
-      #   Artist[1] === Artist[1] # true
-      #   Artist.new === Artist.new # false
-      #   Artist[1].set(:name=>'Bob') == Artist[1] # => true
+      #   Artist[1] === Artist[1] # => true
+      #   Artist.new === Artist.new # => false
+      #   Artist[1].set(:name=>'Bob') === Artist[1] # => true
       def ===(obj)
-        pk.nil? ? false : (obj.class == model) && (obj.pk == pk)
+        case pkv = pk
+        when nil
+          return false
+        when Array
+          return false if pk.any?(&:nil?)
+        end
+
+        (obj.class == model) && (obj.pk == pkv)
       end
-  
+
+      # If the receiver has a primary key value, returns true if the objects have
+      # the same class and primary key value.
+      # If the receiver's primary key value is nil or is an array containing
+      # nil, returns false.
+      #
+      #   Artist[1].pk_equal?(Artist[1]) # => true
+      #   Artist.new.pk_equal?(Artist.new) # => false
+      #   Artist[1].set(:name=>'Bob').pk_equal?(Artist[1]) # => true
+      alias pk_equal? ===
+
       # class is defined in Object, but it is also a keyword,
       # and since a lot of instance methods call class methods,
       # this alias makes it so you can use model instead of

data/lib/sequel/plugins/defaults_setter.rb

@@ -116,7 +116,7 @@ module Sequel
         # Use default value for a new record if values doesn't already contain an entry for it.
         def [](k)
           if new? && !values.has_key?(k)
-            v = model.default_values[k]
+            v = model.default_values.fetch(k){return}
             v = v.call if v.respond_to?(:call)
             values[k] = v if model.cache_default_values?
             v

data/lib/sequel/plugins/tree.rb

@@ -70,6 +70,7 @@ module Sequel
         attr_reader :children_association_name
 
         Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil, :@parent_association_name=>nil, :@children_association_name=>nil)
+        Plugins.def_dataset_methods(self, [:roots, :roots_dataset])
 
         # Should freeze tree order if it is an array when freezing the model class.
         def freeze
@@ -77,22 +78,6 @@ module Sequel
         
           super
         end
-
-        # Returns list of all root nodes (those with no parent nodes).
-        #
-        #   TreeClass.roots # => [root1, root2]
-        def roots
-          roots_dataset.all
-        end
-        
-        # Returns the dataset for retrieval of all root nodes
-        #
-        #   TreeClass.roots_dataset # => Sequel::Dataset instance
-        def roots_dataset
-          ds = where(Sequel.or(Array(parent_column).zip([])))
-          ds = ds.order(*tree_order) if tree_order
-          ds
-        end
       end
       
       module InstanceMethods
@@ -154,6 +139,24 @@ module Sequel
         end
       end
 
+      module DatasetMethods
+        # Returns list of all root nodes (those with no parent nodes).
+        #
+        #   TreeClass.roots # => [root1, root2]
+        def roots
+          roots_dataset.all
+        end
+
+        # Returns the dataset for retrieval of all root nodes
+        #
+        #   TreeClass.roots_dataset # => Sequel::Dataset instance
+        def roots_dataset
+          ds = where(Sequel.or(Array(model.parent_column).zip([])))
+          ds = ds.order(*model.tree_order) if model.tree_order
+          ds
+        end
+      end
+
       # Plugin included when :single_root option is passed.
       module SingleRoot
         module ClassMethods

data/lib/sequel/sql.rb

@@ -265,12 +265,12 @@ module Sequel
     # methods overlap with the standard +BooleanMethods methods+, and they only
     # make sense for integers, they are only included in +NumericExpression+.
     #
-    #   :a.sql_number & :b # "a" & "b"
-    #   :a.sql_number | :b # "a" | "b"
-    #   :a.sql_number ^ :b # "a" ^ "b"
-    #   :a.sql_number << :b # "a" << "b"
-    #   :a.sql_number >> :b # "a" >> "b"
-    #   ~:a.sql_number # ~"a"
+    #   Sequel[:a].sql_number & :b # "a" & "b"
+    #   Sequel[:a].sql_number | :b # "a" | "b"
+    #   Sequel[:a].sql_number ^ :b # "a" ^ "b"
+    #   Sequel[:a].sql_number << :b # "a" << "b"
+    #   Sequel[:a].sql_number >> :b # "a" >> "b"
+    #   ~Sequel[:a].sql_number # ~"a"
     module BitwiseMethods
       ComplexExpression::BITWISE_OPERATORS.each do |o|
         module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
@@ -354,9 +354,15 @@ module Sequel
       end
 
       # Return an <tt>SQL::CaseExpression</tt> created with the given arguments.
+      # The first argument are the <tt>WHEN</tt>/<tt>THEN</tt> conditions,
+      # specified as an array or a hash.  The second argument is the
+      # <tt>ELSE</tt> default value.  The third optional argument is the
+      # <tt>CASE</tt> expression.
       #
-      #   Sequel.case([[{a: [2,3]}, 1]], 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+      #   Sequel.case({a: 1}, 0) # SQL: CASE WHEN a THEN 1 ELSE 0 END
       #   Sequel.case({a: 1}, 0, :b) # SQL: CASE b WHEN a THEN 1 ELSE 0 END
+      #   Sequel.case({{a: [2,3]} => 1}, 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+      #   Sequel.case([[{a: [2,3]}, 1]], 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
       def case(*args)
         SQL::CaseExpression.new(*args)
       end
@@ -745,10 +751,10 @@ module Sequel
     # This module includes the inequality methods (>, <, >=, <=) that are defined on objects that can be 
     # used in a numeric or string context in SQL.
     #
-    #   Sequel.lit('a') > :b # a > "b"
-    #   Sequel.lit('a') < :b # a > "b"
-    #   Sequel.lit('a') >= :b # a >= "b"
-    #   Sequel.lit('a') <= :b # a <= "b"
+    #   Sequel[:a] > :b # a > "b"
+    #   Sequel[:a] < :b # a > "b"
+    #   Sequel[:a] >= :b # a >= "b"
+    #   Sequel[:a] <= :b # a <= "b"
     module InequalityMethods
       ComplexExpression::INEQUALITY_OPERATORS.each do |o|
         module_eval("def #{o}(o) BooleanExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
@@ -759,10 +765,10 @@ module Sequel
     # that are defined on objects that can be used in a numeric context in SQL
     # (+Symbol+, +LiteralString+, and +SQL::GenericExpression+).
     #
-    #   :a + :b # "a" + "b"
-    #   :a - :b # "a" - "b"
-    #   :a * :b # "a" * "b"
-    #   :a / :b # "a" / "b"
+    #   Sequel[:a] + :b # "a" + "b"
+    #   Sequel[:a] - :b # "a" - "b"
+    #   Sequel[:a] * :b # "a" * "b"
+    #   Sequel[:a] / :b # "a" / "b"
     #
     # One exception to this is if + is called with a +String+ or +StringExpression+,
     # in which case the || operator is used instead of the + operator:
@@ -1079,7 +1085,13 @@ module Sequel
             expr = new(:AND, expr, new(r.exclude_end? ? :< : :<=, l, r.end))
           end
           expr
-        when ::Array, ::Sequel::Dataset
+        when ::Array
+          r = r.dup.freeze unless r.frozen?
+          new(:IN, l, r)
+        when ::String
+          r = r.dup.freeze unless r.frozen?
+          new(:'=', l, r)
+        when ::Sequel::Dataset
           new(:IN, l, r)
         when NegativeBooleanConstant
           new(:"IS NOT", l, r.constant)
@@ -1111,8 +1123,21 @@ module Sequel
           case op = ce.op
           when :AND, :OR
             BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
-          else
+          when :IN, :"NOT IN"
             BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+          else
+            if ce.args.length == 2
+              case ce.args[1]
+              when Function, LiteralString, PlaceholderLiteralString
+                # Special behavior to not push down inversion in this case because doing so
+                # can result in incorrect behavior for ANY/SOME/ALL operators.
+                BooleanExpression.new(:NOT, ce)
+              else
+                BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+              end
+            else
+              BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+            end
           end
         when StringExpression, NumericExpression
           raise(Sequel::Error, "cannot invert #{ce.inspect}")

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 13
+  MINOR = 14
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/core/dataset_spec.rb

@@ -1411,6 +1411,10 @@ describe "Dataset#order" do
     @dataset.order(Sequel.asc(:name, :nulls=>:last), Sequel.desc(:price, :nulls=>:first)).sql.must_equal 'SELECT * FROM test ORDER BY name ASC NULLS LAST, price DESC NULLS FIRST'
   end
   
+  it "should emulate :nulls options for asc and desc if not natively supported" do
+    @dataset.with_extend{def requires_emulating_nulls_first?; true end}.order(Sequel.asc(:name, :nulls=>:last), Sequel.desc(:price, :nulls=>:first)).sql.must_equal 'SELECT * FROM test ORDER BY (CASE WHEN (name IS NULL) THEN 2 ELSE 1 END), name ASC, (CASE WHEN (price IS NULL) THEN 0 ELSE 1 END), price DESC'
+  end
+  
   it "should override a previous ordering" do
     @dataset.order(:name).order(:stamp).sql.must_equal 'SELECT * FROM test ORDER BY stamp'
   end
@@ -2344,6 +2348,14 @@ describe "Dataset#from_self" do
     @ds.server(:blah).from_self(:alias=>:some_name).opts[:server].must_equal :blah
   end
 
+  it "should work correctly when a delayed evaluation is used " do
+    a = true
+    ds = @ds.where(Sequel.delay{a}).from_self
+    ds.sql.must_equal "SELECT * FROM (SELECT name FROM test WHERE 't' LIMIT 1) AS t1"
+    a = false
+    ds.sql.must_equal "SELECT * FROM (SELECT name FROM test WHERE 'f' LIMIT 1) AS t1"
+  end
+
   it "should hoist WITH clauses in current dataset if dataset doesn't support WITH in subselect" do
     ds = Sequel.mock.dataset
     ds = ds.with_extend do

data/spec/core/expression_filters_spec.rb

@@ -54,6 +54,22 @@ describe "Blockless Ruby Filters" do
     @d.l(~~Sequel.|(:x, :y)).must_equal '(x OR y)'
   end
 
+  it "should not modifying boolean expression created from array if array is modified" do
+    a = [1]
+    expr = Sequel.expr(:b=>a)
+    @d.l(expr).must_equal '(b IN (1))'
+    a << 2
+    @d.l(expr).must_equal '(b IN (1))'
+  end
+
+  it "should not modifying boolean expression created from string if string is modified" do
+    a = '1'.dup
+    expr = Sequel.expr(:b=>a)
+    @d.l(expr).must_equal "(b = '1')"
+    a << '2'
+    @d.l(expr).must_equal "(b = '1')"
+  end
+
   it "should support = via Hash" do
     @d.l(:x => 100).must_equal '(x = 100)'
     @d.l(:x => 'a').must_equal '(x = \'a\')'
@@ -78,6 +94,12 @@ describe "Blockless Ruby Filters" do
     @d.l(~Sequel.expr(:x => false)).must_equal '(x IS NOT FALSE)'
     @d.l(~Sequel.expr(:x => nil)).must_equal '(x IS NOT NULL)'
   end
+
+  it "should use NOT for inverting boolean expressions where right hand side is function or literal strings" do
+    @d.l(~Sequel.expr(:x => Sequel.function(:any))).must_equal 'NOT (x = any())'
+    @d.l(~Sequel.expr(:x => Sequel.lit('any()'))).must_equal 'NOT (x = any())'
+    @d.l(~Sequel.expr(:x => Sequel.lit('any(?)', 1))).must_equal 'NOT (x = any(1))'
+  end
   
   it "should support = and similar operations via =~ method" do
     @d.l{x =~ 100}.must_equal '(x = 100)'

data/spec/extensions/constraint_validations_spec.rb

@@ -107,12 +107,38 @@ describe "constraint_validations extension" do
     sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CONSTRAINT cons CHECK ((name IS NOT NULL) AND (trim(name) != '')))"]
   end
 
-  it "should handle multiple columns when adding validations" do
+  it "should handle multiple string columns when adding presence validations" do
     @db.create_table(:foo){String :name; String :bar; validate{presence [:name, :bar]}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
     parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo")
-    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), bar varchar(255), CHECK ((name IS NOT NULL) AND (bar IS NOT NULL) AND (trim(name) != '') AND (trim(bar) != '')))"]
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), bar varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '') AND (bar IS NOT NULL) AND (trim(bar) != '')))"]
+  end
+
+  it "should handle multiple string columns when adding presence validations with :allow_nil" do
+    @db.create_table(:foo){String :name; String :bar; validate{presence [:name, :bar], :allow_nil=>true}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t')
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo", :allow_nil=>'t')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), bar varchar(255), CHECK (((name IS NULL) OR (trim(name) != '')) AND ((bar IS NULL) OR (trim(bar) != ''))))"]
+  end
+
+  it "should handle multiple string columns when adding presence validations" do
+    @db.create_table(:foo){String :name; Integer :x; String :bar; validate{presence [:name, :x, :bar]}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo")
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"x", :table=>"foo")
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo")
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), x integer, bar varchar(255), CHECK ((name IS NOT NULL) AND (trim(name) != '') AND (bar IS NOT NULL) AND (trim(bar) != '') AND (x IS NOT NULL)))"]
+  end
+
+  it "should handle multiple string columns when adding presence validations with :allow_nil" do
+    @db.create_table(:foo){String :name; Integer :x; String :bar; validate{presence [:name, :x, :bar], :allow_nil=>true}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t')
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"x", :table=>"foo", :allow_nil=>'t')
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"presence", :column=>"bar", :table=>"foo", :allow_nil=>'t')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), x integer, bar varchar(255), CHECK (((name IS NULL) OR (trim(name) != '')) AND ((bar IS NULL) OR (trim(bar) != ''))))"]
   end
 
   it "should handle presence validation on non-String columns" do

data/spec/extensions/defaults_setter_spec.rb

@@ -78,6 +78,15 @@ describe "Sequel::Plugins::DefaultsSetter" do
     o.a.must_be_same_as(o.a)
   end
 
+  it "should not cache default values if :cache plugin option is used and there is no default values" do
+    @c.plugin :defaults_setter, :cache => true
+    o = @c.new
+    o.a.must_be_nil
+    o.values.must_be_empty
+    o.a.must_be_nil
+    o.a.must_be_same_as(o.a)
+  end
+
   it "should not override a given value" do
     @pr.call(2)
     @c.new('a'=>3).a.must_equal 3

data/spec/extensions/tree_spec.rb

@@ -63,10 +63,13 @@ describe Sequel::Model, "tree plugin" do
     @c.dataset = @c.dataset.with_fetch([{:id=>1, :parent_id=>nil, :name=>'r'}])
     @c.roots.must_equal [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
     @db.sqls.must_equal ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
+    @c.exclude(id: 2).roots.must_equal [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
+    @db.sqls.must_equal ["SELECT * FROM nodes WHERE ((id != 2) AND (parent_id IS NULL))"]
   end
 
   it "should have roots_dataset be a dataset representing the tree's roots" do
     @c.roots_dataset.sql.must_equal "SELECT * FROM nodes WHERE (parent_id IS NULL)"
+    @c.exclude(id: 2).roots_dataset.sql.must_equal "SELECT * FROM nodes WHERE ((id != 2) AND (parent_id IS NULL))"
   end
 
   it "should have ancestors return the ancestors of the current node" do

data/spec/integration/dataset_test.rb

@@ -39,6 +39,15 @@ describe "Simple Dataset operations" do
     @ds.order(:id).all.must_equal [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
   end
 
+  it "should support ordering considering NULLS" do
+    @ds.insert(:number=>20)
+    @ds.insert(:number=>nil)
+    @ds.order(Sequel[:number].asc(:nulls=>:first)).select_map(:number).must_equal [nil, 10, 20]
+    @ds.order(Sequel[:number].asc(:nulls=>:last)).select_map(:number).must_equal [10, 20, nil]
+    @ds.order(Sequel[:number].desc(:nulls=>:first)).select_map(:number).must_equal [nil, 20, 10]
+    @ds.order(Sequel[:number].desc(:nulls=>:last)).select_map(:number).must_equal [20, 10, nil]
+  end
+
   it "should have insert return primary key value" do
     @ds.insert(:number=>20).must_equal 2
     @ds.filter(:id=>2).first[:number].must_equal 20

data/spec/integration/plugin_test.rb

@@ -1709,7 +1709,9 @@ describe "Sequel::Plugins::Tree" do
 
     it "iterate top-level nodes in order" do
       @Node.roots_dataset.count.must_equal 5
-      @Node.roots.map{|p| p.name}.must_equal %w'one two three four five'
+      @Node.roots.map(&:name).must_equal %w'one two three four five'
+      @Node.where(:name=>%w'one two.one').roots_dataset.count.must_equal 1
+      @Node.where(:name=>%w'one two.one').roots.map(&:name).must_equal %w'one'
     end
   
     it "should have children" do
@@ -2026,8 +2028,9 @@ describe "Sequel::Plugins::ConstraintValidations" do
       max_length 6, :minlen, opts.merge(:name=>:maxl2)
       operator :<, 'm', :exactlen, opts.merge(:name=>:lt)
       operator :>=, 5, :num, opts.merge(:name=>:gte)
+      presence [:m1, :m2, :m3], opts.merge(:name=>:pm)
     end
-    @valid_row = {:pre=>'a', :exactlen=>'12345', :minlen=>'12345', :maxlen=>'12345', :lenrange=>'1234', :lik=>'fooabc', :ilik=>'FooABC', :inc=>'abc', :uniq=>'u', :num=>5}
+    @valid_row = {:pre=>'a', :exactlen=>'12345', :minlen=>'12345', :maxlen=>'12345', :lenrange=>'1234', :lik=>'fooabc', :ilik=>'FooABC', :inc=>'abc', :uniq=>'u', :num=>5, :m1=>'a', :m2=>1, :m3=>'a'}
     @violations = [
       [:pre, [nil, '', ' ']],
       [:exactlen, [nil, '', '1234', '123456', 'n1234']],
@@ -2068,6 +2071,41 @@ describe "Sequel::Plugins::ConstraintValidations" do
         end
       end
 
+      try = @valid_row.dup
+      if @validation_opts[:allow_nil]
+        [:m1, :m2, :m3].each do |c|
+          @ds.insert(try.merge(c=>nil))
+          @ds.delete
+        end
+        @ds.insert(try.merge(:m1=>nil, :m2=>nil))
+        @ds.delete
+        @ds.insert(try.merge(:m1=>nil, :m3=>nil))
+        @ds.delete
+        @ds.insert(try.merge(:m2=>nil, :m3=>nil))
+        @ds.delete
+        @ds.insert(try.merge(:m1=>nil, :m2=>nil, :m3=>nil))
+        @ds.delete
+      else
+        [:m1, :m2, :m3].each do |c|
+          proc{@ds.insert(try.merge(c=>nil))}.must_raise(Sequel::DatabaseError)
+        end
+        proc{@ds.insert(try.merge(:m1=>nil, :m2=>nil))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m1=>nil, :m3=>nil))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m2=>nil, :m3=>nil))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m1=>nil, :m2=>nil, :m3=>nil))}.must_raise(Sequel::DatabaseError)
+      end
+
+      unless @db.database_type == :oracle
+        [:m1,  :m3].each do |c|
+          proc{@ds.insert(try.merge(c=>''))}.must_raise(Sequel::DatabaseError)
+        end
+        proc{@ds.insert(try.merge(:m1=>'', :m3=>''))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m1=>'', :m2=>nil))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m1=>nil, :m3=>''))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m2=>nil, :m3=>''))}.must_raise(Sequel::DatabaseError)
+        proc{@ds.insert(try.merge(:m1=>'', :m2=>nil, :m3=>''))}.must_raise(Sequel::DatabaseError)
+      end
+
       # Test for dropping of constraint
       @db.alter_table(:cv_test){validate{drop :maxl2}}
       @ds.insert(@valid_row.merge(:minlen=>'1234567'))
@@ -2092,6 +2130,34 @@ describe "Sequel::Plugins::ConstraintValidations" do
           c.new(try).wont_be :valid?
         end
       end
+
+      try = @valid_row.dup
+      if @validation_opts[:allow_nil]
+        [:m1, :m2, :m3].each do |col|
+          c.new(try.merge(col=>nil)).must_be :valid?
+        end
+        c.new(try.merge(:m1=>nil, :m2=>nil)).must_be :valid?
+        c.new(try.merge(:m1=>nil, :m3=>nil)).must_be :valid?
+        c.new(try.merge(:m2=>nil, :m3=>nil)).must_be :valid?
+        c.new(try.merge(:m1=>nil, :m2=>nil, :m3=>nil)).must_be :valid?
+      else
+        [:m1, :m2, :m3].each do |col|
+          c.new(try.merge(col=>nil)).wont_be :valid?
+        end
+        c.new(try.merge(:m1=>nil, :m2=>nil)).wont_be :valid?
+        c.new(try.merge(:m1=>nil, :m3=>nil)).wont_be :valid?
+        c.new(try.merge(:m2=>nil, :m3=>nil)).wont_be :valid?
+        c.new(try.merge(:m1=>nil, :m2=>nil, :m3=>nil)).wont_be :valid?
+      end
+      c.new(try.merge(:m1=>'', :m2=>nil)).wont_be :valid?
+      c.new(try.merge(:m1=>nil, :m3=>'')).wont_be :valid?
+      c.new(try.merge(:m2=>nil, :m3=>'')).wont_be :valid?
+      c.new(try.merge(:m1=>'', :m2=>nil, :m3=>'')).wont_be :valid?
+      [:m1,  :m3].each do |col|
+        c.new(try.merge(col=>'')).wont_be :valid?
+      end
+      c.new(try.merge(:m1=>'', :m3=>'')).wont_be :valid?
+
       c.db.constraint_validations = nil
     end
   end
@@ -2116,6 +2182,9 @@ describe "Sequel::Plugins::ConstraintValidations" do
           String :inc
           String :uniq, :null=>false
           Integer :num
+          String :m1
+          Integer :m2
+          String :m3
           validate(&validate_block)
         end
       end
@@ -2162,6 +2231,9 @@ describe "Sequel::Plugins::ConstraintValidations" do
             add_column :form, String
           end
           add_column :num, Integer
+          add_column :m1, String
+          add_column :m2, Integer
+          add_column :m3, String
           validate(&validate_block)
         end
       end

data/spec/model/record_spec.rb

@@ -1445,35 +1445,46 @@ describe Sequel::Model, "#==" do
   end
 end
 
-describe Sequel::Model, "#===" do
-  it "should compare instances by class and pk if pk is not nil" do
-    z = Class.new(Sequel::Model)
-    z.columns :id, :x
-    y = Class.new(Sequel::Model)
-    y.columns :id, :x
-    a = z.load(:id => 1, :x => 3)
-    b = z.load(:id => 1, :x => 4)
-    c = z.load(:id => 2, :x => 3)
-    d = y.load(:id => 1, :x => 3)
-    
-    a.must_be :===, b
-    a.wont_be :===, c
-    a.wont_be :===, d
-  end
+[:===, :pk_equal?].each do |method_name|
+  describe Sequel::Model, "##{method_name}" do
+    it "should compare instances by class and pk if pk is not nil" do
+      z = Class.new(Sequel::Model)
+      z.columns :id, :x
+      y = Class.new(Sequel::Model)
+      y.columns :id, :x
+      a = z.load(:id => 1, :x => 3)
+      b = z.load(:id => 1, :x => 4)
+      c = z.load(:id => 2, :x => 3)
+      d = y.load(:id => 1, :x => 3)
+
+      a.must_be method_name, b
+      a.wont_be method_name, c
+      a.wont_be method_name, d
+    end
 
-  it "should always be false if the primary key is nil" do
-    z = Class.new(Sequel::Model)
-    z.columns :id, :x
-    y = Class.new(Sequel::Model)
-    y.columns :id, :x
-    a = z.new(:x => 3)
-    b = z.new(:x => 4)
-    c = z.new(:x => 3)
-    d = y.new(:x => 3)
-    
-    a.wont_be :===, b
-    a.wont_be :===, c
-    a.wont_be :===, d
+    it "should always be false if the primary key is nil" do
+      z = Class.new(Sequel::Model)
+      z.columns :id, :x
+      y = Class.new(Sequel::Model)
+      y.columns :id, :x
+      a = z.new(:x => 3)
+      b = z.new(:x => 4)
+      c = z.new(:x => 3)
+      d = y.new(:x => 3)
+
+      a.wont_be method_name, b
+      a.wont_be method_name, c
+      a.wont_be method_name, d
+    end
+
+    it "should always be false if the primary key is an array containing nil" do
+      z = Class.new(Sequel::Model)
+      z.columns :id, :x
+      z.set_primary_key [:id, :x]
+      z.load(:id => nil, :x => nil).wont_be method_name, z.load(:id => nil, :x => nil)
+      z.load(:id => 1, :x => nil).wont_be method_name, z.load(:id => 1, :x => nil)
+      z.load(:id => nil, :x => 2).wont_be method_name, z.load(:id => nil, :x => 2)
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.13.0
+  version: 5.14.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-01 00:00:00.000000000 Z
+date: 2018-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -197,6 +197,7 @@ extra_rdoc_files:
 - doc/release_notes/5.11.0.txt
 - doc/release_notes/5.12.0.txt
 - doc/release_notes/5.13.0.txt
+- doc/release_notes/5.14.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -280,6 +281,7 @@ files:
 - doc/release_notes/5.11.0.txt
 - doc/release_notes/5.12.0.txt
 - doc/release_notes/5.13.0.txt
+- doc/release_notes/5.14.0.txt
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
@@ -805,7 +807,12 @@ files:
 homepage: http://sequel.jeremyevans.net
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/sequel/issues
+  changelog_uri: http://sequel.jeremyevans.net/rdoc/files/CHANGELOG.html
+  documentation_uri: http://sequel.jeremyevans.net/documentation.html
+  mailing_list_uri: https://groups.google.com/forum/#!forum/sequel-talk
+  source_code_uri: https://github.com/jeremyevans/sequel
 post_install_message: 
 rdoc_options:
 - "--quiet"