arel 0.3.3 → 0.4.0

data/lib/arel/algebra/relations/operations/join.rb

@@ -19,8 +19,7 @@ module Arel
     end
 
     def attributes
-      @attributes ||= (relation1.externalize.attributes +
-        relation2.externalize.attributes).collect { |a| a.bind(self) }
+      @attributes ||= (relation1.externalize.attributes | relation2.externalize.attributes).bind(self)
     end
 
     def wheres

data/lib/arel/algebra/relations/operations/project.rb

@@ -10,7 +10,7 @@ module Arel
     end
 
     def attributes
-      @attributes ||= projections.collect { |p| p.bind(self) }
+      @attributes ||= Header.new(projections).bind(self)
     end
 
     def externalizable?

data/lib/arel/algebra/relations/relation.rb

@@ -84,16 +84,7 @@ module Arel
 
     module AttributeAccessable
       def [](index)
-        @cached_attributes ||= {}
-        @cached_attributes[index] ||= case index
-        when Symbol, String
-          find_attribute_matching_name(index)
-        when Attribute, Expression
-          find_attribute_matching_attribute(index)
-        when ::Array
-          # TESTME
-          index.collect { |i| self[i] }
-        end
+        attributes[index]
       end
 
       def find_attribute_matching_name(name)
@@ -127,18 +118,18 @@ module Arel
     include AttributeAccessable
 
     module DefaultOperations
-      def attributes;             []  end
-      def projections;            []  end
-      def wheres;                 []  end
-      def orders;                 []  end
-      def inserts;                []  end
-      def groupings;              []  end
-      def havings;                []  end
-      def joins(formatter = nil); nil end # FIXME
-      def taken;                  nil end
-      def skipped;                nil end
-      def sources;                []  end
-      def locked;                 []  end
+      def attributes;             Header.new  end
+      def projections;            []          end
+      def wheres;                 []          end
+      def orders;                 []          end
+      def inserts;                []          end
+      def groupings;              []          end
+      def havings;                []          end
+      def joins(formatter = nil); nil         end # FIXME
+      def taken;                  nil         end
+      def skipped;                nil         end
+      def sources;                []          end
+      def locked;                 []          end
     end
     include DefaultOperations
   end

data/lib/arel/algebra/relations/utilities/compound.rb

@@ -13,7 +13,7 @@ module Arel
       @requires
     end
 
-    [:attributes, :wheres, :groupings, :orders, :havings, :projections].each do |operation_name|
+    [:wheres, :groupings, :orders, :havings, :projections].each do |operation_name|
       class_eval <<-OPERATION, __FILE__, __LINE__
         def #{operation_name}
           @#{operation_name} ||= relation.#{operation_name}.collect { |o| o.bind(self) }
@@ -21,6 +21,10 @@ module Arel
       OPERATION
     end
 
+    def attributes
+      @attributes ||= relation.attributes.bind(self)
+    end
+
     def hash
       @hash ||= :relation.hash
     end

data/lib/arel/algebra/relations/utilities/externalization.rb

@@ -8,7 +8,7 @@ module Arel
     end
 
     def attributes
-      @attributes ||= relation.attributes.collect { |a| a.to_attribute(self) }
+      @attributes ||= Header.new(relation.attributes.map { |a| a.to_attribute(self) })
     end
   end
 

data/lib/arel/engines/memory/predicates.rb

@@ -6,11 +6,53 @@ module Arel
       end
     end
 
+    class Unary < Predicate
+      def eval(row)
+        operand.eval(row).send(operator)
+      end
+    end
+
+    class Not < Unary
+      def eval(row)
+        !operand.eval(row)
+      end
+    end
+
+    class Polyadic < Predicate
+      def eval(row)
+        predicates.send(compounder) do |operation|
+          operation.eval(row)
+        end
+      end
+    end
+
+    class Any < Polyadic
+      def compounder; :any? end
+    end
+
+    class All < Polyadic
+      def compounder; :all? end
+    end
+
+    class CompoundPredicate < Binary
+      def eval(row)
+        eval "operand1.eval(row) #{operator} operand2.eval(row)"
+      end
+    end
+
+    class Or < CompoundPredicate
+      def operator; :or end
+    end
+
+    class And < CompoundPredicate
+      def operator; :and end
+    end
+
     class Equality < Binary
       def operator; :== end
     end
 
-    class Not < Binary
+    class Inequality < Binary
       def eval(row)
         operand1.eval(row) != operand2.eval(row)
       end
@@ -36,8 +78,22 @@ module Arel
       def operator; :=~ end
     end
 
+    class NotMatch < Binary
+      def eval(row)
+        operand1.eval(row) !~ operand2.eval(row)
+      end
+    end
+
     class In < Binary
-      def operator; :include? end
+      def eval(row)
+        operand2.eval(row).include?(operand1.eval(row))
+      end
+    end
+
+    class NotIn < Binary
+      def eval(row)
+        !(operand2.eval(row).include?(operand1.eval(row)))
+      end
     end
   end
 end

data/lib/arel/engines/memory/relations/array.rb

@@ -15,9 +15,12 @@ module Arel
     end
 
     def attributes
-      @attributes ||= @attribute_names_and_types.collect do |attribute, type|
-        attribute = type.new(self, attribute) if Symbol === attribute
-        attribute
+      @attributes ||= begin
+        attrs = @attribute_names_and_types.collect do |attribute, type|
+          attribute = type.new(self, attribute) if Symbol === attribute
+          attribute
+        end
+        Header.new(attrs)
       end
     end
 

data/lib/arel/engines/memory/relations/operations.rb

@@ -8,7 +8,7 @@ module Arel
   class Order < Compound
     def eval
       unoperated_rows.sort do |row1, row2|
-        ordering = orderings.detect { |o| o.eval(row1, row2) != 0 } || orderings.last
+        ordering = orders.detect { |o| o.eval(row1, row2) != 0 } || orders.last
         ordering.eval(row1, row2)
       end
     end

data/lib/arel/engines/sql/attributes.rb

@@ -37,4 +37,4 @@ module Arel
       end
     end
   end
-end
+end

data/lib/arel/engines/sql/core_extensions/array.rb

@@ -13,6 +13,10 @@ module Arel
         "IN"
       end
 
+      def exclusion_predicate_sql
+        "NOT IN"
+      end
+
       Array.send(:include, self)
     end
   end

data/lib/arel/engines/sql/core_extensions/nil_class.rb

@@ -5,6 +5,10 @@ module Arel
         'IS'
       end
 
+      def inequality_predicate_sql
+        'IS NOT'
+      end
+
       NilClass.send(:include, self)
     end
   end

data/lib/arel/engines/sql/core_extensions/object.rb

@@ -9,6 +9,10 @@ module Arel
         '='
       end
 
+      def inequality_predicate_sql
+        '!='
+      end
+
       Object.send(:include, self)
     end
   end

data/lib/arel/engines/sql/core_extensions/range.rb

@@ -9,6 +9,10 @@ module Arel
         "BETWEEN"
       end
 
+      def exclusion_predicate_sql
+        "NOT BETWEEN"
+      end
+
       Range.send(:include, self)
     end
   end

data/lib/arel/engines/sql/predicates.rb

@@ -6,6 +6,16 @@ module Arel
       end
     end
 
+    class Unary < Predicate
+      def to_sql(formatter = nil)
+        "#{predicate_sql} (#{operand.to_sql(formatter)})"
+      end
+    end
+
+    class Not < Unary
+      def predicate_sql; "NOT" end
+    end
+
     class CompoundPredicate < Binary
       def to_sql(formatter = nil)
         "(#{operand1.to_sql(formatter)} #{predicate_sql} #{operand2.to_sql(formatter)})"
@@ -20,14 +30,32 @@ module Arel
       def predicate_sql; "AND" end
     end
 
+    class Polyadic < Predicate
+      def to_sql(formatter = nil)
+        "(" +
+          predicates.map {|p| p.to_sql(formatter)}.join(" #{predicate_sql} ") +
+        ")"
+      end
+    end
+
+    class Any < Polyadic
+      def predicate_sql; "OR" end
+    end
+
+    class All < Polyadic
+      def predicate_sql; "AND" end
+    end
+
     class Equality < Binary
       def predicate_sql
         operand2.equality_predicate_sql
       end
     end
 
-    class Not < Binary
-      def predicate_sql; '!=' end
+    class Inequality < Binary
+      def predicate_sql
+        operand2.inequality_predicate_sql
+      end
     end
 
     class GreaterThanOrEqualTo < Binary
@@ -50,8 +78,26 @@ module Arel
       def predicate_sql; 'LIKE' end
     end
 
+    class NotMatch < Binary
+      def predicate_sql; 'NOT LIKE' end
+    end
+
     class In < Binary
+      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 predicate_sql; operand2.exclusion_predicate_sql end
+    end
   end
 end

data/lib/arel/engines/sql/primitives.rb

@@ -30,10 +30,18 @@ module Arel
       value.inclusion_predicate_sql
     end
 
+    def exclusion_predicate_sql
+      value.exclusion_predicate_sql
+    end
+
     def equality_predicate_sql
       value.equality_predicate_sql
     end
 
+    def inequality_predicate_sql
+      value.inequality_predicate_sql
+    end
+
     def to_sql(formatter = Sql::WhereCondition.new(relation))
       formatter.value value
     end

data/lib/arel/engines/sql/relations/compiler.rb

@@ -12,9 +12,9 @@ module Arel
           "SELECT     #{select_clauses.join(', ')}",
           "FROM       #{from_clauses}",
           (joins(self)                                   unless joins(self).blank? ),
-          ("WHERE     #{where_clauses.join(" AND ")}"    unless wheres.blank?      ),
+          ("WHERE     #{where_clauses.join(' AND ')}"    unless wheres.blank?      ),
           ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
-          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
+          ("HAVING    #{having_clauses.join(' AND ')}"      unless havings.blank?     ),
           ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      )
           engine.add_limit_offset!(query,{ :limit => taken, :offset => skipped }) if taken || skipped
           query << " #{locked}" unless locked.blank?

data/lib/arel/engines/sql/relations/operations/join.rb

@@ -10,7 +10,7 @@ module Arel
           join_sql,
           relation2.externalize.table_sql(formatter),
           ("ON" unless predicates.blank?),
-          (ons + relation2.externalize.wheres).collect { |p| p.bind(environment).to_sql(Sql::WhereClause.new(environment)) }.join(' AND ')
+          (ons + relation2.externalize.wheres).collect { |p| p.bind(environment.relation).to_sql(Sql::WhereClause.new(environment)) }.join(' AND ')
         ].compact.join(" ")
         [relation1.joins(environment), this_join, relation2.joins(environment)].compact.join(" ")
       end

data/lib/arel/engines/sql/relations/relation.rb

@@ -22,6 +22,10 @@ module Arel
       "IN"
     end
 
+    def exclusion_predicate_sql
+      "NOT IN"
+    end
+
     def primary_key
       connection_id = engine.connection.object_id
       if @@connection_tables_primary_keys[connection_id] && @@connection_tables_primary_keys[connection_id].has_key?(table.name)

data/lib/arel/engines/sql/relations/table.rb

@@ -42,11 +42,14 @@ module Arel
     def attributes
       return @attributes if defined?(@attributes)
       if table_exists?
-        @attributes = columns.collect do |column|
-          Sql::Attributes.for(column).new(column, self, column.name.to_sym)
+        @attributes ||= begin
+          attrs = columns.collect do |column|
+            Sql::Attributes.for(column).new(column, self, column.name.to_sym)
+          end
+          Header.new(attrs)
         end
       else
-        []
+        Header.new
       end
     end
 
@@ -67,7 +70,8 @@ module Arel
     end
 
     def reset
-      @attributes = @columns = nil
+      @columns = nil
+      @attributes = Header.new([])
     end
 
     def ==(other)

data/lib/arel/version.rb

@@ -1,3 +1,3 @@
 module Arel
-  VERSION = "0.3.3" unless defined?(Arel::VERSION)
+  VERSION = "0.4.0" unless defined?(Arel::VERSION)
 end

data/spec/algebra/unit/relations/join_spec.rb

@@ -18,8 +18,7 @@ module Arel
     describe '#attributes' do
       it 'combines the attributes of the two relations' do
         join = InnerJoin.new(@relation1, @relation2, @predicate)
-        join.attributes.should ==
-          (@relation1.attributes + @relation2.attributes).collect { |a| a.bind(join) }
+        join.attributes.should == (@relation1.attributes | @relation2.attributes).bind(join)
       end
     end
   end

data/spec/algebra/unit/relations/table_spec.rb

@@ -9,7 +9,7 @@ module Arel
     describe '[]' do
       describe 'when given a', Symbol do
         it "manufactures an attribute if the symbol names an attribute within the relation" do
-          check @relation[:id].should == Attribute.new(@relation, :id)
+          check @relation[:id].should == Attributes::Integer.new(@relation, :id)
         end
       end