arel 1.0.1 → 2.0.0

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

@@ -1,14 +0,0 @@
-module Arel
-  class Having < Compound
-    attr_reader :predicates
-
-    def initialize(relation, predicates)
-      super(relation)
-      @predicates = predicates.map { |p| p.bind(relation) }
-    end
-
-    def havings
-      @havings ||= relation.havings + predicates
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-module Arel
-  class Join
-    include Relation
-
-    attr_reader :relation1, :relation2, :predicates
-
-    def initialize(relation1, relation2 = Nil.instance, *predicates)
-      @relation1  = relation1
-      @relation2  = relation2
-      @predicates = predicates
-      @attributes = nil
-    end
-
-    def name
-      relation1.name
-    end
-
-    def attributes
-      @attributes ||= (relation1.externalize.attributes | relation2.externalize.attributes).bind(self)
-    end
-
-    def wheres
-      # TESTME bind to self?
-      relation1.externalize.wheres
-    end
-
-    def ons
-      @ons ||= @predicates.collect { |p| p.bind(self) }
-    end
-
-    # TESTME
-    def externalizable?
-      relation1.externalizable? or relation2.externalizable?
-    end
-
-    def join?
-      true
-    end
-
-    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 StringJoin < Join
-    def joins(environment, formatter = Sql::TableReference.new(environment))
-       [relation1.joins(environment), relation2].compact.join(" ")
-    end
-
-    def externalizable?
-      relation1.externalizable?
-    end
-
-    def attributes
-      relation1.externalize.attributes
-    end
-
-    def engine
-      relation1.engine
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-module Arel
-  class Lock < Compound
-    attr_reader :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,23 +0,0 @@
-module Arel
-  class Order < Compound
-    attr_reader :orderings
-
-    def initialize(relation, orderings)
-      super(relation)
-      @orderings = orderings.collect { |o| o.bind(relation) }
-    end
-
-    # TESTME
-    def orders
-      # 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 +0,0 @@
-module Arel
-  class Project < Compound
-    attr_reader :projections, :attributes, :christener
-
-    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,14 +0,0 @@
-module Arel
-  class Skip < Compound
-    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,18 +0,0 @@
-module Arel
-  class Take < Compound
-    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,24 +0,0 @@
-module Arel
-  class Where < Compound
-    attr_reader :predicates
-
-    def initialize(relation, predicates)
-      super(relation)
-      @predicates = predicates.respond_to?(:map) ?
-        predicates.map { |p| p.bind(relation) } : [predicates.bind(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,205 +0,0 @@
-module Arel
-  module Relation
-    include Enumerable
-
-    @@connection_tables_primary_keys = {}
-
-    attr_reader :count
-
-    def session
-      Session.instance
-    end
-
-    def join?
-      false
-    end
-
-    def call
-      engine.read(self)
-    end
-
-    def bind(relation)
-      self
-    end
-
-    def externalize
-      @externalized ||= externalizable?? Externalization.new(self) : self
-    end
-
-    def externalizable?
-      false
-    end
-
-    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 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
-
-    def select_clauses
-      attributes.map { |a|
-        case a
-        when Value
-          a.value
-        else
-          a.to_sql(Sql::SelectClause.new(self))
-        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 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
-
-    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
-
-    def project *args
-      args.empty? ? self : Project.new(self, args)
-    end
-
-    def where clause = nil
-      clause ? Where.new(self, [clause].flatten) : self
-    end
-
-    def skip thing = nil
-      thing ? Skip.new(self, thing) : self
-    end
-
-    def take count
-      Take.new self, count
-    end
-
-    def from thing
-      From.new self, thing
-    end
-
-    def lock(locking = true)
-      Lock.new(self, locking)
-    end
-
-    def alias
-      Alias.new(self)
-    end
-
-    def insert(record)
-      session.create Insert.new(self, record)
-    end
-
-    def update(assignments)
-      session.update Update.new(self, assignments)
-    end
-
-    def delete
-      session.delete Deletion.new(self)
-    end
-
-    JoinOperation = Struct.new(:join_class, :relation1, :relation2) do
-      def on(*predicates)
-        join_class.new(relation1, relation2, *predicates)
-      end
-    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
-
-    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

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

@@ -1,29 +0,0 @@
-module Arel
-  class Row
-    attr_reader :tuple, :relation
-
-    def initialize relation, tuple
-      @relation = relation
-      @tuple = tuple
-    end
-
-    def [](attribute)
-      attribute.type_cast(tuple[relation.position_of(attribute)])
-    end
-
-    def slice(*attributes)
-      Row.new(relation, attributes.map do |attribute|
-        # FIXME TESTME method chaining
-        tuple[relation.relation.position_of(attribute)]
-      end)
-    end
-
-    def bind(relation)
-      Row.new(relation, tuple)
-    end
-
-    def combine(other, relation)
-      Row.new(relation, tuple + other.tuple)
-    end
-  end
-end