sequel 3.23.0 → 3.24.0

data/lib/sequel/dataset/sql.rb

@@ -269,6 +269,7 @@ module Sequel
               literal(op == :IN ? expr : ~expr)
             else
               old_vals = vals
+              vals = vals.naked if vals.is_a?(Sequel::Dataset)
               vals = vals.to_a
               val_cols = old_vals.columns
               complex_expression_sql(op, [cols, vals.map!{|x| x.values_at(*val_cols)}])
@@ -774,59 +775,7 @@ module Sequel
     
     # Qualify the given expression e to the given table.
     def qualified_expression(e, table)
-      case e
-      when Symbol
-        t, column, aliaz = split_symbol(e)
-        if t
-          e
-        elsif aliaz
-          SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(table, SQL::Identifier.new(column)), aliaz)
-        else
-          SQL::QualifiedIdentifier.new(table, e)
-        end
-      when Array
-        e.map{|a| qualified_expression(a, table)}
-      when Hash
-        h = {}
-        e.each{|k,v| h[qualified_expression(k, table)] = qualified_expression(v, table)}
-        h
-      when SQL::Identifier
-        SQL::QualifiedIdentifier.new(table, e)
-      when SQL::OrderedExpression
-        SQL::OrderedExpression.new(qualified_expression(e.expression, table), e.descending, :nulls=>e.nulls)
-      when SQL::AliasedExpression
-        SQL::AliasedExpression.new(qualified_expression(e.expression, table), e.aliaz)
-      when SQL::CaseExpression
-        args = [qualified_expression(e.conditions, table), qualified_expression(e.default, table)]
-        args << qualified_expression(e.expression, table) if e.expression?
-        SQL::CaseExpression.new(*args)
-      when SQL::Cast
-        SQL::Cast.new(qualified_expression(e.expr, table), e.type)
-      when SQL::Function
-        SQL::Function.new(e.f, *qualified_expression(e.args, table))
-      when SQL::ComplexExpression 
-        SQL::ComplexExpression.new(e.op, *qualified_expression(e.args, table))
-      when SQL::Subscript 
-        SQL::Subscript.new(qualified_expression(e.f, table), qualified_expression(e.sub, table))
-      when SQL::WindowFunction
-        SQL::WindowFunction.new(qualified_expression(e.function, table), qualified_expression(e.window, table))
-      when SQL::Window
-        o = e.opts.dup
-        o[:partition] = qualified_expression(o[:partition], table) if o[:partition]
-        o[:order] = qualified_expression(o[:order], table) if o[:order]
-        SQL::Window.new(o)
-      when SQL::PlaceholderLiteralString
-        args = if e.args.is_a?(Hash)
-          h = {}
-          e.args.each{|k,v| h[k] = qualified_expression(v, table)}
-          h
-        else
-          qualified_expression(e.args, table)
-        end
-        SQL::PlaceholderLiteralString.new(e.str, args, e.parens)
-      else
-        e
-      end
+      Qualifier.new(self, table).transform(e)
     end
 
     # The order of methods to call to build the SELECT SQL statement

data/lib/sequel/exceptions.rb

@@ -44,6 +44,10 @@ module Sequel
   # and won't reraise it.
   class Rollback < Error ; end
 
+  # Exception that occurs when unbinding a dataset that has multiple different values
+  # for a given variable.
+  class UnbindDuplicate < Error; end
+
   class Error
     AdapterNotFound = Sequel::AdapterNotFound
     InvalidOperation = Sequel::InvalidOperation

data/lib/sequel/extensions/to_dot.rb

@@ -4,109 +4,111 @@
 # of the dataset's abstract syntax tree.
 
 module Sequel
-  class Dataset
+  class ToDot
     # The option keys that should be included in the dot output.
     TO_DOT_OPTIONS = [:with, :distinct, :select, :from, :join, :where, :group, :having, :compounds, :order, :limit, :offset, :lock].freeze
 
-    # Return a string that can be processed by the +dot+ program (included
-    # with graphviz) in order to see a visualization of the dataset's
-    # abstract syntax tree.
-    def to_dot
-      i = 0
-      dot = ["digraph G {", "#{i} [label=\"self\"];"]
-      _to_dot(dot, "", i, self, i)
-      dot << "}"
-      dot.join("\n")
+    # Given a +Dataset+, return a string in +dot+ format that will
+    # generate a visualization of the dataset.
+    def self.output(ds)
+      new(ds).output
+    end
+
+    # Given a +Dataset+, parse the internal structure to generate
+    # a dataset visualization.
+    def initialize(ds)
+      @i = 0
+      @stack = [@i]
+      @dot = ["digraph G {", "0 [label=\"self\"];"]
+      v(ds, "")
+      @dot << "}"
+    end
+
+    # Output the dataset visualization as a string in +dot+ format.
+    def output
+      @dot.join("\n")
     end
 
     private
 
-    # Internal recursive version that handles all object types understood
-    # by Sequel.  Arguments:
-    # * dot :: An array of strings representing the lines in the returned
-    #          output.  This function just pushes strings onto this array.
-    # * l :: The transition label from the parent node of the AST to the
-    #        current node.
-    # * c :: An integer representing the parent node of the AST.
-    # * e :: The current node of the AST.
-    # * i :: The integer representing the last created node of the AST.
-    #
-    # The basic algorithm is that the +i+ is incremented to get the current
-    # node's integer.  Then the transition from the parent node to the
-    # current node is added to the +dot+ array.  Finally, the current node
-    # is added to the +dot+ array, and if it is a compound node with children,
-    # its children are then added by recursively calling this method. The
-    # return value is the integer representing the last created node.
-    def _to_dot(dot, l, c, e, i)
-      i += 1
-      dot << "#{c} -> #{i} [label=\"#{l}\"];" if l
-      c = i
+    # Add an entry to the +dot+ output with the given label.  If +j+
+    # is given, it is used directly as the node or transition.  Otherwise
+    # a node is created for the current object.
+    def dot(label, j=nil)
+      @dot << "#{j||@i} [label=#{label.to_s.inspect}];"
+    end
+
+    # Recursive method that parses all of Sequel's internal datastructures,
+    # adding the appropriate nodes and transitions to the internal +dot+
+    # structure.
+    def v(e, l)
+      @i += 1
+      dot(l, "#{@stack.last} -> #{@i}") if l
+      @stack.push(@i)
       case e
       when LiteralString
-        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}.lit\"];"
-        i
+        dot "#{e.inspect}.lit"
       when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
-        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}\"];"
-        i
+        dot e.inspect
       when Array
-        dot << "#{i} [label=\"Array\"];"
-        e.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "Array"
+        e.each_with_index do |val, j|
+          v(val, j)
         end
       when Hash
-        dot << "#{i} [label=\"Hash\"];"
-        e.each do |k, v|
-          i = _to_dot(dot, k, c, v, i)
+        dot "Hash"
+        e.each do |k, val|
+          v(val, k)
         end
       when SQL::ComplexExpression 
-        dot << "#{i} [label=\"ComplexExpression: #{e.op}\"];"
-        e.args.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "ComplexExpression: #{e.op}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
         end
       when SQL::Identifier
-        dot << "#{i} [label=\"Identifier\"];"
-        i = _to_dot(dot, :value, c, e.value, i)
+        dot "Identifier"
+        v(e.value, :value)
       when SQL::QualifiedIdentifier
-        dot << "#{i} [label=\"QualifiedIdentifier\"];"
-        i = _to_dot(dot, :table, c, e.table, i)
-        i = _to_dot(dot, :column, c, e.column, i)
+        dot "QualifiedIdentifier"
+        v(e.table, :table)
+        v(e.column, :column)
       when SQL::OrderedExpression
-        dot << "#{i} [label=\"OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i)
+        dot "OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}"
+        v(e.expression, :expression)
       when SQL::AliasedExpression
-        dot << "#{i} [label=\"AliasedExpression\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i)
-        i = _to_dot(dot, :alias, c, e.aliaz, i)
+        dot "AliasedExpression"
+        v(e.expression, :expression)
+        v(e.aliaz, :alias)
       when SQL::CaseExpression
-        dot << "#{i} [label=\"CaseExpression\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i) if e.expression
-        i = _to_dot(dot, :conditions, c, e.conditions, i)
-        i = _to_dot(dot, :default, c, e.default, i)
+        dot "CaseExpression"
+        v(e.expression, :expression) if e.expression
+        v(e.conditions, :conditions)
+        v(e.default, :default)
       when SQL::Cast
-        dot << "#{i} [label=\"Cast\"];"
-        i = _to_dot(dot, :expr, c, e.expr, i)
-        i = _to_dot(dot, :type, c, e.type, i)
+        dot "Cast"
+        v(e.expr, :expr)
+        v(e.type, :type)
       when SQL::Function
-        dot << "#{i} [label=\"Function: #{e.f}\"];"
-        e.args.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "Function: #{e.f}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
         end
       when SQL::Subscript 
-        dot << "#{i} [label=\"Subscript: #{e.f}\"];"
-        i = _to_dot(dot, :f, c, e.f, i)
-        i = _to_dot(dot, :sub, c, e.sub, i)
+        dot "Subscript"
+        v(e.f, :f)
+        v(e.sub, :sub)
       when SQL::WindowFunction
-        dot << "#{i} [label=\"WindowFunction\"];"
-        i = _to_dot(dot, :function, c, e.function, i)
-        i = _to_dot(dot, :window, c, e.window, i)
+        dot "WindowFunction"
+        v(e.function, :function)
+        v(e.window, :window)
       when SQL::Window
-        dot << "#{i} [label=\"Window\"];"
-        i = _to_dot(dot, :opts, c, e.opts, i)
+        dot "Window"
+        v(e.opts, :opts)
       when SQL::PlaceholderLiteralString
         str = e.str
         str = "(#{str})" if e.parens
-        dot << "#{i} [label=\"PlaceholderLiteralString: #{str.inspect.gsub('"', '\\"')}\"];"
-        i = _to_dot(dot, :args, c, e.args, i)
+        dot "PlaceholderLiteralString: #{str.inspect}"
+        v(e.args, :args)
       when SQL::JoinClause
         str = "#{e.join_type.to_s.upcase} JOIN"
         if e.is_a?(SQL::JoinOnClause)
@@ -114,24 +116,34 @@ module Sequel
         elsif e.is_a?(SQL::JoinUsingClause)
           str << " USING"
         end
-        dot << "#{i} [label=\"#{str}\"];"
-        i = _to_dot(dot, :table, c, e.table, i)
-        i = _to_dot(dot, :alias, c, e.table_alias, i) if e.table_alias
+        dot str
+        v(e.table, :table)
+        v(e.table_alias, :alias) if e.table_alias
         if e.is_a?(SQL::JoinOnClause)
-          i = _to_dot(dot, :on, c, e.on, i)
+          v(e.on, :on) 
         elsif e.is_a?(SQL::JoinUsingClause)
-          i = _to_dot(dot, :using, c, e.using, i)
+          v(e.using, :using) 
         end
       when Dataset
-        dot << "#{i} [label=\"Dataset\"];"
+        dot "Dataset"
         TO_DOT_OPTIONS.each do |k|
-          next unless e.opts[k]
-          i = _to_dot(dot, k, c, e.opts[k], i)
+          if val = e.opts[k]
+            v(val, k.to_s) 
+          end
         end
       else
-        dot << "#{i} [label=\"Unhandled: #{e.inspect.gsub('"', "''")}\"];"
+        dot "Unhandled: #{e.inspect}"
       end
-      i
+      @stack.pop
+    end
+  end
+
+  class Dataset
+    # Return a string that can be processed by the +dot+ program (included
+    # with graphviz) in order to see a visualization of the dataset's
+    # abstract syntax tree.
+    def to_dot
+      ToDot.output(self)
     end
   end
 end

data/lib/sequel/model.rb

@@ -80,6 +80,11 @@ module Sequel
     # +super+ on the first line of your method, so later hooks are called after earlier hooks.
     AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
 
+    # Hooks that are called around an action.  If overridden, these methods must call super
+    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
+    # raised by the code they wrap or ensure that some behavior is executed no matter what.
+    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
+
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
     # call +super+ to get the default behavior (while empty by default, they can also be defined

data/lib/sequel/model/associations.rb

@@ -1415,18 +1415,40 @@ module Sequel
         # types, this is a simple transformation, but for +many_to_many+ associations this 
         # creates a subquery to the join table.
         def complex_expression_sql(op, args)
-          if op == :'=' and args.at(1).is_a?(Sequel::Model)
-            l, r = args
+          r = args.at(1)
+          if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
+              (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
+            l = args.at(0)
             if ar = model.association_reflections[l]
-              unless r.is_a?(ar.associated_class)
+              if multiple
+                klass = ar.associated_class
+                if is_ds
+                  if r.respond_to?(:model)
+                    unless r.model <= klass
+                      # A dataset for a different model class, could be a valid regular query
+                      return super
+                    end
+                  else
+                    # Not a model dataset, could be a valid regular query
+                    return super
+                  end
+                else
+                  unless r.all?{|x| x.is_a?(klass)}
+                    raise Sequel::Error, "invalid association class for one object for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{klass.inspect}"
+                  end
+                end
+              elsif !r.is_a?(ar.associated_class)
                 raise Sequel::Error, "invalid association class #{r.class.inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{ar.associated_class.inspect}"
               end
 
-              if exp = association_filter_expression(ar, r)
+              if exp = association_filter_expression(op, ar, r)
                 literal(exp)
               else
                 raise Sequel::Error, "invalid association type #{ar[:type].inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}"
               end
+            elsif multiple && (is_ds || r.empty?)
+              # Not a query designed for this support, could be a valid regular query
+              super
             else
               raise Sequel::Error, "invalid association #{l.inspect} used in dataset filter for model #{model.inspect}"
             end
@@ -1577,9 +1599,46 @@ module Sequel
         private
       
         # Return an expression for filtering by the given association reflection and associated object.
-        def association_filter_expression(ref, obj)
+        def association_filter_expression(op, ref, obj)
           meth = :"#{ref[:type]}_association_filter_expression"
-          send(meth, ref, obj) if respond_to?(meth, true)
+          send(meth, op, ref, obj) if respond_to?(meth, true)
+        end
+
+        # Handle inversion for association filters by returning an inverted expression,
+        # plus also handling cases where the referenced columns are NULL.
+        def association_filter_handle_inversion(op, exp, cols)
+          if op == :'!=' || op == :'NOT IN'
+            if exp == SQL::Constants::FALSE
+              ~exp
+            else
+              ~exp | Sequel::SQL::BooleanExpression.from_value_pairs(cols.zip([]), :OR)
+            end
+          else
+            exp
+          end
+        end
+
+        # Return an expression for making sure that the given keys match the value of
+        # the given methods for either the single object given or for any of the objects
+        # given if +obj+ is an array.
+        def association_filter_key_expression(keys, meths, obj)
+          vals = if obj.is_a?(Sequel::Dataset)
+            {(keys.length == 1 ? keys.first : keys)=>obj.select(*meths).exclude(Sequel::SQL::BooleanExpression.from_value_pairs(meths.zip([]), :OR))}
+          else
+            vals = Array(obj).reject{|o| !meths.all?{|m| o.send(m)}}
+            return SQL::Constants::FALSE if vals.empty?
+            if obj.is_a?(Array)
+              if keys.length == 1
+                meth = meths.first
+                {keys.first=>vals.map{|o| o.send(meth)}}
+              else
+                {keys=>vals.map{|o| meths.map{|m| o.send(m)}}}
+              end  
+            else
+              keys.zip(meths.map{|k| obj.send(k)})
+            end
+          end
+          SQL::BooleanExpression.from_value_pairs(vals)
         end
 
         # Make sure the association is valid for this model, and return the related AssociationReflection.
@@ -1685,20 +1744,27 @@ module Sequel
         end
       
         # Return a subquery expression for filering by a many_to_many association
-        def many_to_many_association_filter_expression(ref, obj)
-            lpks, lks, rks = ref.values_at(:left_primary_keys, :left_keys, :right_keys)
-            lpks = lpks.first if lpks.length == 1
-            SQL::BooleanExpression.from_value_pairs(lpks=>model.db[ref[:join_table]].select(*lks).where(rks.zip(ref.right_primary_keys.map{|k| obj.send(k)})))
+        def many_to_many_association_filter_expression(op, ref, obj)
+          lpks, lks, rks = ref.values_at(:left_primary_keys, :left_keys, :right_keys)
+          lpks = lpks.first if lpks.length == 1
+          exp = association_filter_key_expression(rks, ref.right_primary_keys, obj)
+          if exp == SQL::Constants::FALSE
+            association_filter_handle_inversion(op, exp, Array(lpks))
+          else
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>model.db[ref[:join_table]].select(*lks).where(exp).exclude(SQL::BooleanExpression.from_value_pairs(lks.zip([]), :OR))), Array(lpks))
+          end
         end
 
         # Return a simple equality expression for filering by a many_to_one association
-        def many_to_one_association_filter_expression(ref, obj)
-          SQL::BooleanExpression.from_value_pairs(ref[:keys].zip(ref.primary_keys.map{|k| obj.send(k)}))
+        def many_to_one_association_filter_expression(op, ref, obj)
+          keys = ref[:keys]
+          association_filter_handle_inversion(op, association_filter_key_expression(keys, ref.primary_keys, obj), keys)
         end
 
         # Return a simple equality expression for filering by a one_to_* association
-        def one_to_many_association_filter_expression(ref, obj)
-          SQL::BooleanExpression.from_value_pairs(ref[:primary_keys].zip(ref[:keys].map{|k| obj.send(k)}))
+        def one_to_many_association_filter_expression(op, ref, obj)
+          keys = ref[:primary_keys]
+          association_filter_handle_inversion(op, association_filter_key_expression(keys, ref[:keys], obj), keys)
         end
         alias one_to_one_association_filter_expression one_to_many_association_filter_expression