arel 0.4.0 → 1.0.0.rc1

data/lib/arel/algebra/relations.rb

@@ -4,7 +4,6 @@ require 'arel/algebra/relations/utilities/nil'
 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'

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

@@ -1,6 +1,14 @@
 module Arel
   class From < Compound
-    attributes :relation, :sources
-    deriving :initialize, :==
+    attr_reader :sources
+
+    def initialize relation, sources
+      super(relation)
+      @sources = sources
+    end
+
+    def eval
+      unoperated_rows[sources..-1]
+    end
   end
 end

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

@@ -1,12 +1,14 @@
 module Arel
   class Group < Compound
-    attributes :relation, :groupings
-    deriving :==
+    attr_reader :groupings
 
-    def initialize(relation, *groupings, &block)
-      @relation = relation
-      @groupings = (groupings + arguments_from_block(relation, &block)) \
-        .collect { |g| g.bind(relation) }
+    def initialize(relation, groupings)
+      super(relation)
+      @groupings = groupings.collect { |g| g.bind(relation) }
+    end
+
+    def eval
+      raise NotImplementedError
     end
   end
 end

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

@@ -1,13 +1,10 @@
 module Arel
   class Having < Compound
-    attributes :relation, :predicates
-    deriving   :==
-    requires   :restricting
+    attr_reader :predicates
 
-    def initialize(relation, *predicates, &block)
-      predicates = [yield(relation)] + predicates if block_given?
+    def initialize(relation, predicates)
+      super(relation)
       @predicates = predicates.map { |p| p.bind(relation) }
-      @relation   = relation
     end
 
     def havings

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

@@ -2,20 +2,17 @@ module Arel
   class Join
     include Relation
 
-    attributes :relation1, :relation2, :predicates
-    deriving :==
-    delegate :name, :to => :relation1
+    attr_reader :relation1, :relation2, :predicates
 
     def initialize(relation1, relation2 = Nil.instance, *predicates)
-      @relation1, @relation2, @predicates = relation1, relation2, predicates
+      @relation1  = relation1
+      @relation2  = relation2
+      @predicates = predicates
+      @attributes = nil
     end
 
-    def hash
-      @hash ||= :relation1.hash
-    end
-
-    def eql?(other)
-      self == other
+    def name
+      relation1.name
     end
 
     def attributes
@@ -43,11 +40,54 @@ module Arel
     def engine
       relation1.engine != relation2.engine ? Memory::Engine.new : relation1.engine
     end
+
+    def table_sql(formatter = Sql::TableReference.new(self))
+      relation1.externalize.table_sql(formatter)
+    end
+
+    def joins(environment, formatter = Sql::TableReference.new(environment))
+      @joins ||= begin
+        this_join = [
+          join_sql,
+          relation2.externalize.table_sql(formatter),
+          ("ON" unless predicates.blank?),
+          (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
+    end
+
+    def eval
+      result = []
+      relation1.call.each do |row1|
+        relation2.call.each do |row2|
+          combined_row = row1.combine(row2, self)
+          if predicates.all? { |p| p.eval(combined_row) }
+            result << combined_row
+          end
+        end
+      end
+      result
+    end
+
+    def to_sql(formatter = nil)
+      compiler.select_sql
+    end
+  end
+
+  class InnerJoin < Join
+    def join_sql; "INNER JOIN" end
+  end
+
+  class OuterJoin < Join
+    def join_sql; "LEFT OUTER JOIN" end
   end
 
-  class InnerJoin  < Join; end
-  class OuterJoin  < Join; end
   class StringJoin < Join
+    def joins(environment, formatter = Sql::TableReference.new(environment))
+       [relation1.joins(environment), relation2].compact.join(" ")
+    end
+
     def externalizable?
       relation1.externalizable?
     end
@@ -60,10 +100,4 @@ module Arel
       relation1.engine
     end
   end
-
-  module Relation
-    def join?
-      false
-    end
-  end
 end

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

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

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

@@ -1,13 +1,10 @@
 module Arel
   class Order < Compound
-    attributes :relation, :orderings
-    deriving   :==
-    requires   :ordering
+    attr_reader :orderings
 
-    def initialize(relation, *orderings, &block)
-      @relation = relation
-      @orderings = (orderings + arguments_from_block(relation, &block)) \
-        .collect { |o| o.bind(relation) }
+    def initialize(relation, orderings)
+      super(relation)
+      @orderings = orderings.collect { |o| o.bind(relation) }
     end
 
     # TESTME
@@ -15,5 +12,12 @@ module Arel
       # QUESTION - do we still need relation.orders ?
       (orderings + relation.orders).collect { |o| o.bind(self) }.collect { |o| o.to_ordering }
     end
+
+    def eval
+      unoperated_rows.sort do |row1, row2|
+        ordering = orders.detect { |o| o.eval(row1, row2) != 0 } || orders.last
+        ordering.eval(row1, row2)
+      end
+    end
   end
 end

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

@@ -1,20 +1,20 @@
 module Arel
   class Project < Compound
-    attributes :relation, :projections
-    deriving :==
+    attr_reader :projections, :attributes, :christener
 
-    def initialize(relation, *projections, &block)
-      @relation = relation
-      @projections = (projections + arguments_from_block(relation, &block)) \
-        .collect { |p| p.bind(relation) }
-    end
-
-    def attributes
-      @attributes ||= Header.new(projections).bind(self)
+    def initialize(relation, projections)
+      super(relation)
+      @projections = projections.map { |p| p.bind(relation) }
+      @christener = Sql::Christener.new
+      @attributes = Header.new(projections.map { |x| x.bind(self) })
     end
 
     def externalizable?
       attributes.any? { |a| a.respond_to?(:aggregation?) && a.aggregation? } || relation.externalizable?
     end
+
+    def eval
+      unoperated_rows.collect { |r| r.slice(*projections) }
+    end
   end
 end

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

@@ -1,7 +1,14 @@
 module Arel
   class Skip < Compound
-    attributes :relation, :skipped
-    deriving   :initialize, :==
-    requires   :skipping
+    attr_reader :relation, :skipped
+
+    def initialize relation, skipped
+      super(relation)
+      @skipped = skipped
+    end
+
+    def eval
+      unoperated_rows[skipped..-1]
+    end
   end
 end

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

@@ -1,11 +1,18 @@
 module Arel
   class Take < Compound
-    attributes :relation, :taken
-    deriving   :initialize, :==
-    requires   :limiting
+    attr_reader :taken
+
+    def initialize relation, taken
+      super(relation)
+      @taken = taken
+    end
 
     def externalizable?
       true
     end
+
+    def eval
+      unoperated_rows[0, taken]
+    end
   end
 end

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

@@ -1,17 +1,23 @@
 module Arel
   class Where < Compound
-    attributes :relation, :predicates
-    deriving   :==
-    requires   :restricting
+    attr_reader :predicates
 
-    def initialize(relation, *predicates, &block)
-      predicates = [yield(relation)] + predicates if block_given?
+    def initialize(relation, predicates)
+      super(relation)
       @predicates = predicates.map { |p| p.bind(relation) }
-      @relation   = relation
+      @wheres = nil
     end
 
     def wheres
       @wheres ||= relation.wheres + predicates
     end
+
+    def eval
+      unoperated_rows.select { |row| predicates.all? { |p| p.eval(row) } }
+    end
+
+    def to_sql(formatter = nil)
+      compiler.select_sql
+    end
   end
 end

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

@@ -1,9 +1,17 @@
 module Arel
   module Relation
+    include Enumerable
+
+    @@connection_tables_primary_keys = {}
+
     attr_reader :count
 
     def session
-      Session.new
+      Session.instance
+    end
+
+    def join?
+      false
     end
 
     def call
@@ -14,123 +22,184 @@ module Arel
       self
     end
 
-    module Enumerable
-      include ::Enumerable
+    def externalize
+      @externalized ||= externalizable?? Externalization.new(self) : self
+    end
+
+    def externalizable?
+      false
+    end
 
-      def each(&block)
-        session.read(self).each(&block)
+    def compiler
+      @compiler ||=  begin
+        Arel::SqlCompiler.const_get("#{engine.adapter_name}Compiler").new(self)
+      rescue
+        Arel::SqlCompiler::GenericCompiler.new(self)
       end
+    end
+
+    def to_sql(formatter = nil)
+      sql = compiler.select_sql
+
+      return sql unless formatter
+      formatter.select sql, self
+    end
+
+    def christener
+      @christener ||= Sql::Christener.new
+    end
+
+    def inclusion_predicate_sql
+      "IN"
+    end
+
+    def exclusion_predicate_sql
+      "NOT IN"
+    end
 
-      def first
-        session.read(self).first
+    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)
+        @@connection_tables_primary_keys[connection_id][table.name]
+      else
+        @@connection_tables_primary_keys[connection_id] ||= {}
+        @@connection_tables_primary_keys[connection_id][table.name] = engine.connection.primary_key(table.name)
       end
     end
-    include Enumerable
 
-    module Operable
-      def join(other_relation = nil, join_class = InnerJoin)
-        case other_relation
-        when String
-          StringJoin.new(self, other_relation)
-        when Relation
-          JoinOperation.new(join_class, self, other_relation)
+    def select_clauses
+      attributes.map { |a|
+        case a
+        when Value
+          a.value
         else
-          self
+          a.to_sql(Sql::SelectClause.new(self))
         end
-      end
+      }
+    end
+
+    def from_clauses
+      sources.empty? ? table_sql : sources
+    end
+
+    def where_clauses
+      wheres.map { |w| w.value }
+    end
+
+    def group_clauses
+      groupings.collect { |g| g.to_sql(Sql::GroupClause.new(self)) }
+    end
 
-      def outer_join(other_relation = nil)
-        join(other_relation, OuterJoin)
+    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 each
+      session.read(self).each { |e| yield e }
+    end
+
+    def join(other_relation = nil, join_class = InnerJoin)
+      case other_relation
+      when String
+        StringJoin.new(self, other_relation)
+      when Relation
+        JoinOperation.new(join_class, self, other_relation)
+      else
+        self
       end
+    end
 
-      [: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)
+    def outer_join(other_relation = nil)
+      join(other_relation, OuterJoin)
+    end
+
+    %w{
+        having group order
+    }.each do |op|
+      class_eval <<-OPERATION, __FILE__, __LINE__
+          def #{op}(*args)
+            args.all? { |x| x.blank? } ? self : #{op.capitalize}.new(self, args)
           end
-        OPERATION
-      end
+      OPERATION
+    end
 
-      def lock(locking = nil)
-        Lock.new(self, locking)
-      end
+    def project *args
+      args.empty? ? self : Project.new(self, args)
+    end
 
-      def alias
-        Alias.new(self)
-      end
+    def where clause = nil
+      clause ? Where.new(self, Array(clause)) : self
+    end
 
-      module Writable
-        def insert(record)
-          session.create Insert.new(self, record)
-        end
+    def skip thing = nil
+      thing ? Skip.new(self, thing) : self
+    end
 
-        def update(assignments)
-          session.update Update.new(self, assignments)
-        end
+    def take count
+      Take.new self, count
+    end
 
-        def delete
-          session.delete Deletion.new(self)
-        end
-      end
-      include Writable
+    def from thing
+      From.new self, thing
+    end
 
-      JoinOperation = Struct.new(:join_class, :relation1, :relation2) do
-        def on(*predicates)
-          join_class.new(relation1, relation2, *predicates)
-        end
-      end
+    def lock(locking = true)
+      Lock.new(self, locking)
     end
-    include Operable
 
-    module AttributeAccessable
-      def [](index)
-        attributes[index]
-      end
+    def alias
+      Alias.new(self)
+    end
 
-      def find_attribute_matching_name(name)
-        attributes.detect { |a| a.named?(name) } || Attribute.new(self, name)
-      end
+    def insert(record)
+      session.create Insert.new(self, record)
+    end
 
-      def find_attribute_matching_attribute(attribute)
-        matching_attributes(attribute).max do |a1, a2|
-          (a1.original_attribute / attribute) <=> (a2.original_attribute / attribute)
-        end
-      end
+    def update(assignments)
+      session.update Update.new(self, assignments)
+    end
 
-      def position_of(attribute)
-        (@position_of ||= Hash.new do |h, attribute|
-          h[attribute] = attributes.index(self[attribute])
-        end)[attribute]
-      end
+    def delete
+      session.delete Deletion.new(self)
+    end
 
-      private
-      def matching_attributes(attribute)
-        (@matching_attributes ||= attributes.inject({}) do |hash, a|
-          (hash[a.is_a?(Value) ? a.value : a.root] ||= []) << a
-          hash
-        end)[attribute.root] || []
+    JoinOperation = Struct.new(:join_class, :relation1, :relation2) do
+      def on(*predicates)
+        join_class.new(relation1, relation2, *predicates)
       end
+    end
 
-      def has_attribute?(attribute)
-        !matching_attributes(attribute).empty?
-      end
+    def [](index)
+      attributes[index]
+    end
+
+    def find_attribute_matching_name(name)
+      attributes.detect { |a| a.named?(name) } || Attribute.new(self, name)
+    end
+
+    def position_of(attribute)
+      @position_of ||= {}
+
+      return @position_of[attribute] if @position_of.key? attribute
+
+      @position_of[attribute] = attributes.index(attributes[attribute])
     end
-    include AttributeAccessable
-
-    module DefaultOperations
-      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
+
+    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
 end