arel 0.1.0 → 0.2.0

data/lib/arel/algebra/predicates.rb

@@ -1,41 +1,43 @@
 module Arel
-  class Predicate
-    def or(other_predicate)
-      Or.new(self, other_predicate)
-    end
+  module Predicates
+    class Predicate
+      def or(other_predicate)
+        Or.new(self, other_predicate)
+      end
 
-    def and(other_predicate)
-      And.new(self, other_predicate)
+      def and(other_predicate)
+        And.new(self, other_predicate)
+      end
     end
-  end
 
-  class Binary < Predicate
-    attributes :operand1, :operand2
-    deriving :initialize
+    class Binary < Predicate
+      attributes :operand1, :operand2
+      deriving :initialize
 
-    def ==(other)
-      self.class === other          and
-      @operand1  ==  other.operand1 and
-      @operand2  ==  other.operand2
-    end
+      def ==(other)
+        self.class === other          and
+        @operand1  ==  other.operand1 and
+        @operand2  ==  other.operand2
+      end
 
-    def bind(relation)
-      self.class.new(operand1.find_correlate_in(relation), operand2.find_correlate_in(relation))
+      def bind(relation)
+        self.class.new(operand1.find_correlate_in(relation), operand2.find_correlate_in(relation))
+      end
     end
-  end
 
-  class Equality < Binary
-    def ==(other)
-      Equality === other and
-        ((operand1 == other.operand1 and operand2 == other.operand2) or
-         (operand1 == other.operand2 and operand2 == other.operand1))
+    class Equality < Binary
+      def ==(other)
+        Equality === other and
+          ((operand1 == other.operand1 and operand2 == other.operand2) or
+           (operand1 == other.operand2 and operand2 == other.operand1))
+      end
     end
-  end
 
-  class GreaterThanOrEqualTo  < Binary; end
-  class GreaterThan           < Binary; end
-  class LessThanOrEqualTo     < Binary; end
-  class LessThan              < Binary; end
-  class Match                 < Binary; end
-  class In                    < Binary; end
+    class GreaterThanOrEqualTo  < Binary; end
+    class GreaterThan           < Binary; end
+    class LessThanOrEqualTo     < Binary; end
+    class LessThan              < Binary; end
+    class Match                 < Binary; end
+    class In                    < Binary; end
+  end
 end

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

@@ -0,0 +1,6 @@
+module Arel
+  class From < Compound
+    attributes :relation, :sources
+    deriving :initialize, :==
+  end
+end

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

@@ -0,0 +1,13 @@
+module Arel
+  class Having < Compound
+    attributes :relation, :havings
+    deriving :==
+
+    def initialize(relation, *havings, &block)
+      @relation = relation
+      @havings = (havings + arguments_from_block(relation, &block)) \
+        .collect { |g| g.bind(relation) }
+    end
+  end
+end
+

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

@@ -47,6 +47,10 @@ module Arel
   class InnerJoin  < Join; end
   class OuterJoin  < Join; end
   class StringJoin < Join
+    def externalizable?
+      relation1.externalizable?
+    end
+
     def attributes
       relation1.externalize.attributes
     end

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

@@ -0,0 +1,12 @@
+module Arel
+  class Lock < Compound
+    attributes :relation, :locked
+    deriving :initialize, :==
+
+    def initialize(relation, locked, &block)
+      @relation = relation
+      @locked   = locked.blank? ? " FOR UPDATE" : locked
+    end
+  end
+end
+

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

@@ -14,7 +14,7 @@ module Arel
     end
 
     def externalizable?
-      attributes.any?(&:aggregation?) or relation.externalizable?
+      attributes.any? { |a| a.respond_to?(:aggregation?) && a.aggregation? } || relation.externalizable?
     end
   end
 end

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

@@ -43,7 +43,7 @@ module Arel
         join(other_relation, OuterJoin)
       end
 
-      [:where, :project, :order, :take, :skip, :group].each do |operation_name|
+      [:where, :project, :order, :take, :skip, :group, :from, :having].each do |operation_name|
         class_eval <<-OPERATION, __FILE__, __LINE__
           def #{operation_name}(*arguments, &block)
             arguments.all?(&:blank?) && !block_given?? self : #{operation_name.to_s.classify}.new(self, *arguments, &block)
@@ -51,6 +51,10 @@ module Arel
         OPERATION
       end
 
+      def lock(locking = nil)
+        Lock.new(self, locking)
+      end
+
       def alias
         Alias.new(self)
       end
@@ -110,7 +114,7 @@ module Arel
       private
       def matching_attributes(attribute)
         (@matching_attributes ||= attributes.inject({}) do |hash, a|
-          (hash[a.root] ||= []) << a
+          (hash[a.is_a?(Value) ? a.value : a.root] ||= []) << a
           hash
         end)[attribute.root] || []
       end
@@ -127,9 +131,12 @@ module Arel
       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

@@ -2,10 +2,10 @@ module Arel
   class Compound < Relation
     attr_reader :relation
     delegate :joins, :join?, :inserts, :taken, :skipped, :name, :externalizable?,
-             :column_for, :engine,
+             :column_for, :engine, :sources, :locked, :table_alias,
              :to => :relation
 
-    [:attributes, :wheres, :groupings, :orders].each do |operation_name|
+    [:attributes, :wheres, :groupings, :orders, :havings].each do |operation_name|
       class_eval <<-OPERATION, __FILE__, __LINE__
         def #{operation_name}
           @#{operation_name} ||= relation.#{operation_name}.collect { |o| o.bind(self) }

data/lib/arel/algebra/relations.rb

@@ -5,10 +5,13 @@ require 'arel/algebra/relations/utilities/externalization'
 require 'arel/algebra/relations/row'
 require 'arel/algebra/relations/writes'
 require 'arel/algebra/relations/operations/alias'
+require 'arel/algebra/relations/operations/from'
 require 'arel/algebra/relations/operations/group'
+require 'arel/algebra/relations/operations/having'
 require 'arel/algebra/relations/operations/join'
 require 'arel/algebra/relations/operations/order'
 require 'arel/algebra/relations/operations/project'
 require 'arel/algebra/relations/operations/where'
 require 'arel/algebra/relations/operations/skip'
 require 'arel/algebra/relations/operations/take'
+require 'arel/algebra/relations/operations/lock'

data/lib/arel/algebra.rb

@@ -1,4 +1,9 @@
-require 'arel/algebra/extensions'
+require 'arel/algebra/core_extensions'
+
+require 'arel/algebra/attribute'
+require 'arel/algebra/expression'
+require 'arel/algebra/ordering'
 require 'arel/algebra/predicates'
 require 'arel/algebra/relations'
-require 'arel/algebra/primitives'
+require 'arel/algebra/value'
+

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

@@ -1,35 +1,37 @@
 module Arel
-  class Binary < Predicate
-    def eval(row)
-      operand1.eval(row).send(operator, operand2.eval(row))
+  module Predicates
+    class Binary < Predicate
+      def eval(row)
+        operand1.eval(row).send(operator, operand2.eval(row))
+      end
     end
-  end
 
-  class Equality < Binary
-    def operator; :== end
-  end
+    class Equality < Binary
+      def operator; :== end
+    end
 
-  class GreaterThanOrEqualTo < Binary
-    def operator; :>= end
-  end
+    class GreaterThanOrEqualTo < Binary
+      def operator; :>= end
+    end
 
-  class GreaterThan < Binary
-    def operator; :> end
-  end
+    class GreaterThan < Binary
+      def operator; :> end
+    end
 
-  class LessThanOrEqualTo < Binary
-    def operator; :<= end
-  end
+    class LessThanOrEqualTo < Binary
+      def operator; :<= end
+    end
 
-  class LessThan < Binary
-    def operator; :< end
-  end
+    class LessThan < Binary
+      def operator; :< end
+    end
 
-  class Match < Binary
-    def operator; :=~ end
-  end
+    class Match < Binary
+      def operator; :=~ end
+    end
 
-  class In < Binary
-    def operator; :include? end
+    class In < Binary
+      def operator; :include? end
+    end
   end
 end

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

@@ -32,6 +32,12 @@ module Arel
     end
   end
 
+  class From < Compound
+    def eval
+      unoperated_rows[sources..-1]
+    end
+  end
+
   class Group < Compound
     def eval
       raise NotImplementedError

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

@@ -4,7 +4,8 @@ module Arel
       def name_for(relation)
         @used_names ||= Hash.new(0)
         (@relation_names ||= Hash.new do |hash, relation|
-          @used_names[name = relation.name] += 1
+          name =  relation.table_alias ? relation.table_alias : relation.name
+          @used_names[name] += 1
           hash[relation] = name + (@used_names[name] > 1 ? "_#{@used_names[name]}" : '')
         end)[relation.table]
       end

data/lib/arel/engines/sql/{extensions → core_extensions}/array.rb

@@ -2,13 +2,17 @@ module Arel
   module Sql
     module ArrayExtensions
       def to_sql(formatter = nil)
-        "(" + collect { |e| e.to_sql(formatter) }.join(', ') + ")"
+        if any?
+          "(" + collect { |e| e.to_sql(formatter) }.join(', ') + ")"
+        else
+          "(NULL)"
+        end
       end
 
       def inclusion_predicate_sql
         "IN"
       end
-      
+
       Array.send(:include, self)
     end
   end

data/lib/arel/engines/sql/{extensions → core_extensions}/nil_class.rb

@@ -4,7 +4,7 @@ module Arel
       def equality_predicate_sql
         'IS'
       end
-      
+
       NilClass.send(:include, self)
     end
   end

data/lib/arel/engines/sql/{extensions → core_extensions}/object.rb

@@ -8,7 +8,7 @@ module Arel
       def equality_predicate_sql
         '='
       end
-      
+
       Object.send(:include, self)
     end
   end

data/lib/arel/engines/sql/{extensions → core_extensions}/range.rb

@@ -8,7 +8,7 @@ module Arel
       def inclusion_predicate_sql
         "BETWEEN"
       end
-      
+
       Range.send(:include, self)
     end
   end

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

@@ -0,0 +1,4 @@
+require 'arel/engines/sql/core_extensions/object'
+require 'arel/engines/sql/core_extensions/array'
+require 'arel/engines/sql/core_extensions/range'
+require 'arel/engines/sql/core_extensions/nil_class'

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

@@ -9,6 +9,10 @@ module Arel
         @ar.connection
       end
 
+      def adapter_name
+        @adapter_name ||= connection.adapter_name
+      end
+
       def method_missing(method, *args, &block)
         @ar.connection.send(method, *args, &block)
       end

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

@@ -13,7 +13,6 @@ module Arel
 
     class SelectClause < Formatter
       def attribute(attribute)
-        # FIXME this should check that the column exists
         "#{quote_table_name(name_for(attribute.original_relation))}.#{quote_column_name(attribute.name)}" +
         (attribute.alias ? " AS #{quote(attribute.alias.to_s)}" : "")
       end
@@ -58,6 +57,12 @@ module Arel
       end
     end
 
+    class HavingClause < PassThrough
+      def attribute(attribute)
+        attribute
+      end
+    end
+
     class WhereCondition < Formatter
       def attribute(attribute)
         "#{quote_table_name(name_for(attribute.original_relation))}.#{quote_column_name(attribute.name)}"
@@ -92,8 +97,12 @@ module Arel
       end
 
       def table(table)
-        quote_table_name(table.name) +
-        (table.name != name_for(table) ? " AS " + quote_table_name(name_for(table)) : '')
+        if table.name =~ /\s/
+          table.name
+        else
+          quote_table_name(table.name) +
+            (table.name != name_for(table) ? " AS " + quote_table_name(name_for(table)) : '')
+        end
       end
     end
 

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

@@ -1,51 +1,53 @@
 module Arel
-  class Binary < Predicate
-    def to_sql(formatter = nil)
-      "#{operand1.to_sql} #{predicate_sql} #{operand1.format(operand2)}"
+  module Predicates
+    class Binary < Predicate
+      def to_sql(formatter = nil)
+        "#{operand1.to_sql} #{predicate_sql} #{operand1.format(operand2)}"
+      end
     end
-  end
 
-  class CompoundPredicate < Binary
-    def to_sql(formatter = nil)
-      "(#{operand1.to_sql(formatter)} #{predicate_sql} #{operand2.to_sql(formatter)})"
+    class CompoundPredicate < Binary
+      def to_sql(formatter = nil)
+        "(#{operand1.to_sql(formatter)} #{predicate_sql} #{operand2.to_sql(formatter)})"
+      end
     end
-  end
 
-  class Or < CompoundPredicate
-    def predicate_sql; "OR" end
-  end
+    class Or < CompoundPredicate
+      def predicate_sql; "OR" end
+    end
 
-  class And < CompoundPredicate
-    def predicate_sql; "AND" end
-  end
+    class And < CompoundPredicate
+      def predicate_sql; "AND" end
+    end
 
-  class Equality < Binary
-    def predicate_sql
-      operand2.equality_predicate_sql
+    class Equality < Binary
+      def predicate_sql
+        operand2.equality_predicate_sql
+      end
     end
-  end
 
-  class GreaterThanOrEqualTo < Binary
-    def predicate_sql; '>=' end
-  end
+    class GreaterThanOrEqualTo < Binary
+      def predicate_sql; '>=' end
+    end
 
-  class GreaterThan < Binary
-    def predicate_sql; '>' end
-  end
+    class GreaterThan < Binary
+      def predicate_sql; '>' end
+    end
 
-  class LessThanOrEqualTo < Binary
-    def predicate_sql; '<=' end
-  end
+    class LessThanOrEqualTo < Binary
+      def predicate_sql; '<=' end
+    end
 
-  class LessThan < Binary
-    def predicate_sql; '<' end
-  end
+    class LessThan < Binary
+      def predicate_sql; '<' end
+    end
 
-  class Match < Binary
-    def predicate_sql; 'LIKE' end
-  end
+    class Match < Binary
+      def predicate_sql; 'LIKE' end
+    end
 
-  class In < Binary
-    def predicate_sql; operand2.inclusion_predicate_sql end
+    class In < Binary
+      def predicate_sql; operand2.inclusion_predicate_sql end
+    end
   end
 end

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

@@ -3,10 +3,12 @@ module Arel
     def relation
       nil
     end
-    
+
     def to_sql(formatter = nil)
       self
     end
+
+    include Attribute::Expressions
   end
 
   class Attribute
@@ -28,7 +30,13 @@ module Arel
   end
 
   class Value
-    delegate :inclusion_predicate_sql, :equality_predicate_sql, :to => :value
+    def inclusion_predicate_sql
+      value.inclusion_predicate_sql
+    end
+
+    def equality_predicate_sql
+      value.equality_predicate_sql
+    end
 
     def to_sql(formatter = Sql::WhereCondition.new(relation))
       formatter.value value

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

@@ -26,8 +26,8 @@ module Arel
   end
 
   class StringJoin < Join
-    def joins(_, __ = nil)
-      relation2
+    def joins(environment, formatter = Sql::TableReference.new(environment))
+       [relation1.joins(environment), relation2].compact.join(" ")
     end
   end
 end

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

@@ -5,15 +5,40 @@ module Arel
     end
 
     def select_sql
-      build_query \
-        "SELECT     #{select_clauses.join(', ')}",
-        "FROM       #{table_sql(Sql::TableReference.new(self))}",
-        (joins(self)                                   unless joins(self).blank? ),
-        ("WHERE     #{where_clauses.join("\n\tAND ")}" unless wheres.blank?      ),
-        ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
-        ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      ),
-        ("LIMIT     #{taken}"                          unless taken.blank?       ),
-        ("OFFSET    #{skipped}"                        unless skipped.blank?     )
+      if engine.adapter_name == "PostgreSQL" && !orders.blank? && using_distinct_on?
+        # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON, so we work around this
+        # by wrapping the +sql+ string as a sub-select and ordering in that query.
+        order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
+        order = order.zip((0...order.size).to_a).map { |s,i| "id_list.alias_#{i} #{'DESC' if s =~ /\bdesc$/i}" }.join(', ')
+
+        query = build_query \
+          "SELECT     #{select_clauses.kind_of?(::Array) ? select_clauses.join("") : select_clauses.to_s}",
+          "FROM       #{from_clauses}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses.join(" AND ")}"    unless wheres.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?   ),
+          ("#{locked}"                                   unless locked.blank?     )
+
+        build_query \
+          "SELECT * FROM (#{query}) AS id_list",
+          "ORDER BY #{order}",
+          ("LIMIT     #{taken}"                          unless taken.blank?       ),
+          ("OFFSET    #{skipped}"                        unless skipped.blank?     )
+
+      else
+        build_query \
+          "SELECT     #{select_clauses.join(', ')}",
+          "FROM       #{from_clauses}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses.join(" AND ")}"    unless wheres.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
+          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      ),
+          ("LIMIT     #{taken}"                          unless taken.blank?       ),
+          ("OFFSET    #{skipped}"                        unless skipped.blank?     ),
+          ("#{locked}"                                   unless engine.adapter_name =~ /SQLite/ || locked.blank?)
+      end
     end
 
     def inclusion_predicate_sql
@@ -27,7 +52,11 @@ module Arel
   protected
 
     def build_query(*parts)
-      parts.compact.join("\n")
+      parts.compact.join(" ")
+    end
+
+    def from_clauses
+      sources.blank? ? table_sql(Sql::TableReference.new(self)) : sources
     end
 
     def select_clauses
@@ -42,9 +71,16 @@ module Arel
       groupings.collect { |g| g.to_sql(Sql::GroupClause.new(self)) }
     end
 
+    def having_clauses
+      havings.collect { |g| g.to_sql(Sql::HavingClause.new(self)) }
+    end
+
     def order_clauses
       orders.collect { |o| o.to_sql(Sql::OrderClause.new(self)) }
     end
 
+    def using_distinct_on?
+      select_clauses.any? { |x| x =~ /DISTINCT ON/ }
+    end
   end
 end

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

@@ -3,10 +3,22 @@ module Arel
     include Recursion::BaseCase
 
     cattr_accessor :engine
-    attr_reader :name, :engine
+    attr_reader :name, :engine, :table_alias, :options
 
-    def initialize(name, engine = Table.engine)
-      @name, @engine = name.to_s, engine
+    def initialize(name, options = {})
+      @name = name.to_s
+
+      if options.is_a?(Hash)
+        @options = options
+        @engine = options[:engine] || Table.engine
+        @table_alias = options[:as].to_s if options[:as].present? && options[:as].to_s != @name
+      else
+        @engine = options # Table.new('foo', engine)
+      end
+    end
+
+    def as(table_alias)
+      Table.new(name, options.merge(:as => table_alias))
     end
 
     def attributes
@@ -40,8 +52,9 @@ module Arel
     end
 
     def ==(other)
-      Table      === other and
-      name       ==  other.name
+      Table       === other and
+      name        ==  other.name and
+      table_alias ==  other.table_alias
     end
   end
 end