arel 0.4.0 → 1.0.0.rc1

data/lib/arel/algebra/core_extensions/object.rb

@@ -8,10 +8,6 @@ module Arel
       bind(relation)
     end
 
-    def let
-      yield(self)
-    end
-
     Object.send(:include, self)
   end
 end

data/lib/arel/algebra/expression.rb

@@ -1,43 +1,56 @@
 module Arel
   class Expression < Attribute
-    attributes :attribute, :alias, :ancestor
-    deriving :==
-    delegate :relation, :to => :attribute
-    alias_method :name, :alias
+    attr_reader :attribute
+    alias :name :alias
 
     def initialize(attribute, aliaz = nil, ancestor = nil)
-      @attribute, @alias, @ancestor = attribute, aliaz, ancestor
+      super(attribute.relation, aliaz, :alias => aliaz, :ancestor => ancestor)
+      @attribute = attribute
     end
 
     def aggregation?
       true
     end
 
-    def inspect
-      "<#{self.class.name} #{attribute.inspect}>"
+    def to_sql(formatter = Sql::SelectClause.new(relation))
+      formatter.expression self
     end
 
-    module Transformations
-      def as(aliaz)
-        self.class.new(attribute, aliaz, self)
-      end
+    def as(aliaz)
+      self.class.new(attribute, aliaz, self)
+    end
 
-      def bind(new_relation)
-        new_relation == relation ? self : self.class.new(attribute.bind(new_relation), @alias, self)
-      end
+    def bind(new_relation)
+      new_relation == relation ? self : self.class.new(attribute.bind(new_relation), @alias, self)
+    end
 
-      def to_attribute(relation)
-        Attribute.new(relation, @alias, :ancestor => self)
-      end
+    def to_attribute(relation)
+      Attribute.new(relation, @alias, :ancestor => self)
     end
-    include Transformations
   end
 
-  class Count    < Expression; end
-  class Distinct < Expression; end
-  class Sum      < Expression; end
-  class Maximum  < Expression; end
-  class Minimum  < Expression; end
-  class Average  < Expression; end
+  class Count < Expression
+    def function_sql; 'COUNT' end
+  end
+
+  class Distinct < Expression
+    def function_sql; 'DISTINCT' end
+  end
+
+  class Sum < Expression
+    def function_sql; 'SUM' end
+  end
+
+  class Maximum < Expression
+    def function_sql; 'MAX' end
+  end
+
+  class Minimum < Expression
+    def function_sql; 'MIN' end
+  end
+
+  class Average < Expression
+    def function_sql; 'AVG' end
+  end
 end
 

data/lib/arel/algebra/header.rb

@@ -4,13 +4,11 @@ module Arel
 
     def initialize(attrs = [])
       @attributes = attrs.to_ary
-      @names = Hash.new do |h,k|
-        h[k] = @attributes.detect { |a| a.named?(k) }
-      end
+      @names      = {}
     end
 
-    def each(&block)
-      to_ary.each(&block)
+    def each
+      to_ary.each { |e| yield e }
       self
     end
 
@@ -55,7 +53,8 @@ module Arel
     end
 
     def find_by_name(name)
-      @names[name.to_sym]
+      k = name.to_sym
+      @names[k] ||= @attributes.detect { |a| a.named?(k) }
     end
 
     def find_by_attribute(attr)

data/lib/arel/algebra/ordering.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Ordering
+  class Ordering < Struct.new(:attribute)
     delegate :relation, :to => :attribute
 
     def bind(relation)
@@ -9,15 +9,23 @@ module Arel
     def to_ordering
       self
     end
+
+    def eval(row1, row2)
+      (attribute.eval(row1) <=> attribute.eval(row2)) * direction
+    end
+
+    def to_sql(formatter = Sql::OrderClause.new(relation))
+      formatter.ordering self
+    end
   end
 
   class Ascending  < Ordering
-    attributes :attribute
-    deriving :initialize, :==
+    def direction; 1 end
+    def direction_sql; 'ASC' end
   end
 
   class Descending < Ordering
-    attributes :attribute
-    deriving :initialize, :==
+    def direction_sql; 'DESC' end
+    def direction; -1 end
   end
 end

data/lib/arel/algebra/predicates.rb

@@ -19,7 +19,7 @@ module Arel
     end
 
     class Polyadic < Predicate
-      attributes :predicates
+      attr_reader :predicates
 
       def initialize(*predicates)
         @predicates = predicates
@@ -32,14 +32,14 @@ module Arel
       # * <tt>additional_operands</tt> - All possible right-hand operands
       def self.build(operator, operand1, *additional_operands)
         new(
-          *additional_operands.uniq.inject([]) do |predicates, operand|
-            predicates << operator.new(operand1, operand)
+          *additional_operands.uniq.map do |operand|
+            operator.new(operand1, operand)
           end
         )
       end
 
       def ==(other)
-        same_elements?(@predicates, other.predicates)
+        super || predicates == other.predicates
       end
 
       def bind(relation)
@@ -48,14 +48,16 @@ module Arel
         )
       end
 
-      private
-
-      def same_elements?(a1, a2)
-        [:select, :inject, :size].each do |m|
-          return false unless [a1, a2].each {|a| a.respond_to?(m) }
+      def eval(row)
+        predicates.send(compounder) do |operation|
+          operation.eval(row)
         end
-        a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h } ==
-        a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
+      end
+
+      def to_sql(formatter = nil)
+        "(" +
+          predicates.map {|p| p.to_sql(formatter)}.join(" #{predicate_sql} ") +
+        ")"
       end
     end
 
@@ -63,61 +65,118 @@ module Arel
       def complement
         All.new(*predicates.map {|p| p.complement})
       end
+
+      def compounder; :any? end
+
+      def predicate_sql; "OR" end
     end
 
     class All < Polyadic
       def complement
         Any.new(*predicates.map {|p| p.complement})
       end
+
+      def compounder; :all? end
+
+      def predicate_sql; "AND" end
     end
 
     class Unary < Predicate
-      attributes :operand
-      deriving :initialize, :==
+      attr_reader :operand
+
+      def initialize operand
+        @operand = operand
+      end
 
       def bind(relation)
         self.class.new(operand.find_correlate_in(relation))
       end
+
+      def == other
+        super || self.class === other && operand == other.operand
+      end
+
+      def eval(row)
+        operand.eval(row).send(operator)
+      end
+
+      def to_sql(formatter = nil)
+        "#{predicate_sql} (#{operand.to_sql(formatter)})"
+      end
     end
 
     class Not < Unary
       def complement
         operand
       end
+
+      def eval(row)
+        !operand.eval(row)
+      end
+
+      def predicate_sql; "NOT" end
     end
 
-    class Binary < Predicate
-      attributes :operand1, :operand2
-      deriving :initialize
+    class Binary < Unary
+      attr_reader :operand2
+      alias :operand1 :operand
+
+      def initialize left, right
+        super(left)
+        @operand2 = right
+      end
 
       def ==(other)
-        self.class === other          and
-        @operand1  ==  other.operand1 and
-        @operand2  ==  other.operand2
+        super && @operand2 == other.operand2
       end
 
       def bind(relation)
         self.class.new(operand1.find_correlate_in(relation), operand2.find_correlate_in(relation))
       end
+
+      def eval(row)
+        operand1.eval(row).send(operator, operand2.eval(row))
+      end
+
+      def to_sql(formatter = nil)
+        "#{operand1.to_sql} #{predicate_sql} #{operand1.format(operand2)}"
+      end
+      alias :value :to_sql
     end
 
-    class CompoundPredicate < Binary; end
+    class CompoundPredicate < Binary
+      def eval(row)
+        eval "operand1.eval(row) #{operator} operand2.eval(row)"
+      end
+
+      def to_sql(formatter = nil)
+        "(#{operand1.to_sql(formatter)} #{predicate_sql} #{operand2.to_sql(formatter)})"
+      end
+    end
 
     class And < CompoundPredicate
       def complement
         Or.new(operand1.complement, operand2.complement)
       end
+
+      def operator; :and end
+
+      def predicate_sql; "AND" end
     end
 
     class Or < CompoundPredicate
       def complement
         And.new(operand1.complement, operand2.complement)
       end
+
+      def operator; :or end
+
+      def predicate_sql; "OR" end
     end
 
     class Equality < Binary
       def ==(other)
-        Equality === other and
+        self.class === other and
           ((operand1 == other.operand1 and operand2 == other.operand2) or
            (operand1 == other.operand2 and operand2 == other.operand1))
       end
@@ -125,66 +184,123 @@ module Arel
       def complement
         Inequality.new(operand1, operand2)
       end
-    end
 
-    class Inequality  < Binary
-      def ==(other)
-        Equality === other and
-          ((operand1 == other.operand1 and operand2 == other.operand2) or
-           (operand1 == other.operand2 and operand2 == other.operand1))
+      def operator; :== end
+
+      def predicate_sql
+        operand2.equality_predicate_sql
       end
+    end
 
+    class Inequality < Equality
       def complement
         Equality.new(operand1, operand2)
       end
+
+      def operator; :"!=" end
+      def eval(row)
+        operand1.eval(row) != operand2.eval(row)
+      end
+
+      def predicate_sql
+        operand2.inequality_predicate_sql
+      end
     end
 
     class GreaterThanOrEqualTo < Binary
       def complement
         LessThan.new(operand1, operand2)
       end
+
+      def operator; :>= end
+
+      def predicate_sql; '>=' end
     end
 
     class GreaterThan < Binary
       def complement
         LessThanOrEqualTo.new(operand1, operand2)
       end
+
+      def operator; :> end
+
+      def predicate_sql; '>' end
     end
 
     class LessThanOrEqualTo < Binary
       def complement
         GreaterThan.new(operand1, operand2)
       end
+
+      def operator; :<= end
+
+      def predicate_sql; '<=' end
     end
 
     class LessThan < Binary
       def complement
         GreaterThanOrEqualTo.new(operand1, operand2)
       end
+
+      def operator; :< end
+
+      def predicate_sql; '<' end
     end
 
     class Match < Binary
       def complement
         NotMatch.new(operand1, operand2)
       end
+
+      def operator; :=~ end
+
+      def predicate_sql; 'LIKE' end
     end
 
     class NotMatch < Binary
       def complement
         Match.new(operand1, operand2)
       end
+
+      def eval(row)
+        operand1.eval(row) !~ operand2.eval(row)
+      end
+
+      def predicate_sql; 'NOT LIKE' end
     end
 
     class In < Binary
       def complement
         NotIn.new(operand1, operand2)
       end
+
+      def eval(row)
+        operand2.eval(row).include?(operand1.eval(row))
+      end
+
+      def to_sql(formatter = nil)
+        if operand2.is_a?(Range) && operand2.exclude_end?
+          GreaterThanOrEqualTo.new(operand1, operand2.begin).and(
+            LessThan.new(operand1, operand2.end)
+          ).to_sql(formatter)
+        else
+          super
+        end
+      end
+
+      def predicate_sql; operand2.inclusion_predicate_sql end
     end
 
     class NotIn < Binary
       def complement
         In.new(operand1, operand2)
       end
+
+      def eval(row)
+        !(operand2.eval(row).include?(operand1.eval(row)))
+      end
+
+      def predicate_sql; operand2.exclusion_predicate_sql end
     end
   end
 end