Remove ActiveRelation sub-modules and refactor specs

38 files changed, 1039 insertions, 1041 deletions

diff --git a/lib/active_relation/extensions/base.rb b/lib/active_relation/extensions/base.rb
index 0115586b00..c1b823f9a7 100644
--- a/lib/active_relation/extensions/base.rb
+++ b/lib/active_relation/extensions/base.rb
@@ -5,7 +5,7 @@ class ActiveRecord::Base
     end
     
     def relation
-      @relation ||= ActiveRelation::Relations::Table.new(table_name)
+      @relation ||= ActiveRelation::Table.new(table_name)
     end
   end
   
diff --git a/lib/active_relation/predicates.rb b/lib/active_relation/predicates.rb
index 84db60e3b9..55a6c852e2 100644
--- a/lib/active_relation/predicates.rb
+++ b/lib/active_relation/predicates.rb
@@ -1,87 +1,85 @@
 module ActiveRelation
-  module Predicates
-    class Base
-      def ==(other)
-        self.class == other.class
-      end
+  class Predicate
+    def ==(other)
+      self.class == other.class
     end
-  
-    class Binary < Base
-      attr_reader :attribute, :operand
+  end
+
+  class Binary < Predicate
+    attr_reader :attribute, :operand
 
-      def initialize(attribute, operand)
-        @attribute, @operand = attribute, operand
-      end
+    def initialize(attribute, operand)
+      @attribute, @operand = attribute, operand
+    end
+
+    def ==(other)
+      super and @attribute == other.attribute and @operand == other.operand
+    end
 
-      def ==(other)
-        super and @attribute == other.attribute and @operand == other.operand
-      end
+    def qualify
+      self.class.new(attribute.qualify, operand.qualify)
+    end
 
-      def qualify
-        self.class.new(attribute.qualify, operand.qualify)
-      end
+    def to_sql(strategy = Sql::Predicate.new)
+      "#{attribute.to_sql(strategy)} #{predicate_sql} #{operand.to_sql(strategy)}"
+    end
+  end
 
-      def to_sql(strategy = Sql::Predicate.new)
-        "#{attribute.to_sql(strategy)} #{predicate_sql} #{operand.to_sql(strategy)}"
-      end
+  class Equality < Binary
+    def ==(other)
+      self.class == other.class and
+        ((attribute == other.attribute and operand == other.operand) or
+         (attribute == other.operand and operand == other.attribute))
     end
-  
-    class Equality < Binary
-      def ==(other)
-        self.class == other.class and
-          ((attribute == other.attribute and operand == other.operand) or
-           (attribute == other.operand and operand == other.attribute))
-      end
 
-      protected
-      def predicate_sql
-        '='
-      end
+    protected
+    def predicate_sql
+      '='
     end
-  
-    class GreaterThanOrEqualTo < Binary
-      protected
-      def predicate_sql
-        '>='
-      end
+  end
+
+  class GreaterThanOrEqualTo < Binary
+    protected
+    def predicate_sql
+      '>='
     end
-  
-    class GreaterThan < Binary
-      protected
-      def predicate_sql
-        '>'
-      end
+  end
+
+  class GreaterThan < Binary
+    protected
+    def predicate_sql
+      '>'
     end
-  
-    class LessThanOrEqualTo < Binary
-      protected
-      def predicate_sql
-        '<='
-      end
+  end
+
+  class LessThanOrEqualTo < Binary
+    protected
+    def predicate_sql
+      '<='
     end
-  
-    class LessThan < Binary
-      protected
-      def predicate_sql
-        '<'
-      end
+  end
+
+  class LessThan < Binary
+    protected
+    def predicate_sql
+      '<'
     end
-  
-    class Match < Binary
-      alias_method :regexp, :operand
+  end
+
+  class Match < Binary
+    alias_method :regexp, :operand
 
-      def initialize(attribute, regexp)
-        @attribute, @regexp = attribute, regexp
-      end
+    def initialize(attribute, regexp)
+      @attribute, @regexp = attribute, regexp
     end
-  
-    class RelationInclusion < Binary
-      alias_method :relation, :operand
-      
-      protected
-      def predicate_sql
-        'IN'
-      end
+  end
+
+  class RelationInclusion < Binary
+    alias_method :relation, :operand
+    
+    protected
+    def predicate_sql
+      'IN'
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/primitives/aggregation.rb b/lib/active_relation/primitives/aggregation.rb
index 189eb33ac9..48f8946835 100644
--- a/lib/active_relation/primitives/aggregation.rb
+++ b/lib/active_relation/primitives/aggregation.rb
@@ -1,19 +1,17 @@
 module ActiveRelation
-  module Primitives
-    class Aggregation  
-      attr_reader :attribute, :function_sql
-      
-      def initialize(attribute, function_sql)
-        @attribute, @function_sql = attribute, function_sql
-      end
-  
-      def to_sql(strategy = nil)
-        "#{function_sql}(#{attribute.to_sql})"
-      end
-      
-      def ==(other)
-        self.class == other.class and attribute == other.attribute and function_sql == other.function_sql
-      end
+  class Aggregation
+    attr_reader :attribute, :function_sql
+    
+    def initialize(attribute, function_sql)
+      @attribute, @function_sql = attribute, function_sql
+    end
+
+    def to_sql(strategy = nil)
+      "#{function_sql}(#{attribute.to_sql})"
+    end
+    
+    def ==(other)
+      self.class == other.class and attribute == other.attribute and function_sql == other.function_sql
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/primitives/attribute.rb b/lib/active_relation/primitives/attribute.rb
index 6ebaf1b292..90bbe8012b 100644
--- a/lib/active_relation/primitives/attribute.rb
+++ b/lib/active_relation/primitives/attribute.rb
@@ -1,83 +1,79 @@
 module ActiveRelation
-  module Primitives
-    class Attribute
-      attr_reader :relation, :name, :alias
-  
-      def initialize(relation, name, aliaz = nil)
-        @relation, @name, @alias = relation, name, aliaz
+  class Attribute
+    attr_reader :relation, :name, :alias
+
+    def initialize(relation, name, aliaz = nil)
+      @relation, @name, @alias = relation, name, aliaz
+    end
+
+    def as(aliaz = nil)
+      Attribute.new(relation, name, aliaz)
+    end
+
+    def qualified_name
+      "#{relation.name}.#{name}"
+    end
+
+    def qualify
+      self.as(qualified_name)
+    end
+
+    def ==(other)
+      relation == other.relation and name == other.name and @alias == other.alias
+    end
+
+    module Predications
+      def equals(other)
+        Equality.new(self, other)
       end
-  
-      def as(aliaz = nil)
-        Attribute.new(relation, name, aliaz)
+
+      def less_than(other)
+        LessThan.new(self, other)
       end
-  
-      def qualified_name
-        "#{relation.name}.#{name}"
+
+      def less_than_or_equal_to(other)
+        LessThanOrEqualTo.new(self, other)
       end
-  
-      def qualify
-        self.as(qualified_name)
+
+      def greater_than(other)
+        GreaterThan.new(self, other)
       end
-  
-      def ==(other)
-        relation == other.relation and name == other.name and @alias == other.alias
+
+      def greater_than_or_equal_to(other)
+        GreaterThanOrEqualTo.new(self, other)
       end
 
-      module Predications
-        include Predicates
-        
-        def equals(other)
-          Equality.new(self, other)
-        end
-  
-        def less_than(other)
-          LessThan.new(self, other)
-        end
-  
-        def less_than_or_equal_to(other)
-          LessThanOrEqualTo.new(self, other)
-        end
-  
-        def greater_than(other)
-          GreaterThan.new(self, other)
-        end
-  
-        def greater_than_or_equal_to(other)
-          GreaterThanOrEqualTo.new(self, other)
-        end
-  
-        def matches(regexp)
-          Match.new(self, regexp)
-        end
+      def matches(regexp)
+        Match.new(self, regexp)
+      end
+    end
+    include Predications
+    
+    module Aggregations
+      def count
+        Aggregation.new(self, "COUNT")
+      end
+      
+      def sum
+        Aggregation.new(self, "SUM")
+      end
+      
+      def maximum
+        Aggregation.new(self, "MAX")
       end
-      include Predications
       
-      module Aggregations
-        def count
-          Aggregation.new(self, "COUNT")
-        end
-        
-        def sum
-          Aggregation.new(self, "SUM")
-        end
-        
-        def maximum
-          Aggregation.new(self, "MAX")
-        end
-        
-        def minimum
-          Aggregation.new(self, "MIN")
-        end
-        
-        def average
-          Aggregation.new(self, "AVG")
-        end
+      def minimum
+        Aggregation.new(self, "MIN")
       end
-      include Aggregations
-  
-      def to_sql(strategy = Sql::Predicate.new)
-        strategy.attribute relation.name, name, self.alias
+      
+      def average
+        Aggregation.new(self, "AVG")
       end
     end
+    include Aggregations
+
+    def to_sql(strategy = Sql::Predicate.new)
+      strategy.attribute relation.name, name, self.alias
+    end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations.rb b/lib/active_relation/relations.rb
index 1eb58d3b42..9ae8f16524 100644
--- a/lib/active_relation/relations.rb
+++ b/lib/active_relation/relations.rb
@@ -1,4 +1,4 @@
-require 'active_relation/relations/base'
+require 'active_relation/relations/relation'
 require 'active_relation/relations/compound'
 require 'active_relation/relations/table'
 require 'active_relation/relations/join'
diff --git a/lib/active_relation/relations/alias.rb b/lib/active_relation/relations/alias.rb
index 2d1b9c1476..63a92ccba1 100644
--- a/lib/active_relation/relations/alias.rb
+++ b/lib/active_relation/relations/alias.rb
@@ -1,36 +1,34 @@
 module ActiveRelation
-  module Relations
-    class Alias < Compound
-      attr_reader :alias
-      alias_method :name, :alias
-  
-      def initialize(relation, aliaz)
-        @relation, @alias = relation, aliaz
-      end
-        
-      def attributes
-        relation.attributes.collect(&method(:substitute))
-      end
+  class Alias < Compound
+    attr_reader :alias
+    alias_method :name, :alias
 
-      def ==(other)
-        relation == other.relation and self.alias == other.alias
-      end
-      
-      protected
-      def table_sql
-        "#{quote_table_name(relation.name)} AS #{quote_table_name(@alias)}"
-      end
-      
-      def attribute(name)
-        if unaliased_attribute = relation[name]
-          substitute(unaliased_attribute)
-        end
-      end
+    def initialize(relation, aliaz)
+      @relation, @alias = relation, aliaz
+    end
       
-      private
-      def substitute(attribute)
-        Primitives::Attribute.new(self, attribute.name, attribute.alias)
+    def attributes
+      relation.attributes.collect(&method(:substitute))
+    end
+
+    def ==(other)
+      relation == other.relation and self.alias == other.alias
+    end
+    
+    protected
+    def table_sql
+      "#{quote_table_name(relation.name)} AS #{quote_table_name(@alias)}"
+    end
+    
+    def attribute(name)
+      if unaliased_attribute = relation[name]
+        substitute(unaliased_attribute)
       end
     end
+    
+    private
+    def substitute(attribute)
+      Attribute.new(self, attribute.name, attribute.alias)
+    end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/base.rb b/lib/active_relation/relations/base.rb
deleted file mode 100644
index d90d8ae3e6..0000000000
--- a/lib/active_relation/relations/base.rb
+++ /dev/null
@@ -1,105 +0,0 @@
-module ActiveRelation
-  module Relations
-    class Base
-      include Sql::Quoting
-  
-      module Iteration
-        include Enumerable
-    
-        def each(&block)
-          connection.select_all(to_s).each(&block)
-        end
-    
-        def first
-          connection.select_one(to_s)
-        end
-      end
-      include Iteration
-  
-      module Operations
-        def join(other)
-          JoinOperation.new("INNER JOIN", self, other)
-        end
-  
-        def outer_join(other)
-          JoinOperation.new("LEFT OUTER JOIN", self, other)
-        end
-  
-        def [](index)
-          case index
-          when Symbol
-            attribute(index)
-          when ::Range
-            Range.new(self, index)
-          end
-        end
-  
-        def include?(attribute)
-          Predicates::RelationInclusion.new(attribute, self)
-        end
-  
-        def select(*predicates)
-          Selection.new(self, *predicates)
-        end
-  
-        def project(*attributes)
-          Projection.new(self, *attributes)
-        end
-        
-        def as(aliaz)
-          Alias.new(self, aliaz)
-        end
-  
-        def order(*attributes)
-          Order.new(self, *attributes)
-        end
-    
-        def rename(attribute, aliaz)
-          Rename.new(self, attribute => aliaz)
-        end
-    
-        def insert(record)
-          Insertion.new(self, record)
-        end
-    
-        def delete
-          Deletion.new(self)
-        end
-    
-        JoinOperation = Struct.new(:join_sql, :relation1, :relation2) do
-          def on(*predicates)
-            Join.new(join_sql, relation1, relation2, *predicates)
-          end
-        end
-      end
-      include Operations
-  
-      def to_sql(strategy = Sql::Select.new)
-        strategy.select [
-          "SELECT #{attributes.collect{ |a| a.to_sql(Sql::Projection.new) }.join(', ')}",
-          "FROM #{table_sql}",
-          (joins unless joins.blank?),
-          ("WHERE #{selects.collect{|s| s.to_sql(Sql::Predicate.new)}.join("\n\tAND ")}" unless selects.blank?),
-          ("ORDER BY #{orders.collect(&:to_sql)}" unless orders.blank?),
-          ("LIMIT #{limit.to_sql}" unless limit.blank?),
-          ("OFFSET #{offset.to_sql}" unless offset.blank?)
-        ].compact.join("\n")
-      end
-      alias_method :to_s, :to_sql
-    
-      protected
-      def connection
-        ActiveRecord::Base.connection
-      end
-
-      def attributes; []  end
-      def selects;    []  end
-      def orders;     []  end
-      def inserts;    []  end
-      def joins;      nil end
-      def limit;      nil end
-      def offset;     nil end
-      def alias;      nil end
-    end
-  end
-end
\ No newline at end of file
diff --git a/lib/active_relation/relations/compound.rb b/lib/active_relation/relations/compound.rb
index 46454eb628..d6da8eb8fa 100644
--- a/lib/active_relation/relations/compound.rb
+++ b/lib/active_relation/relations/compound.rb
@@ -1,9 +1,7 @@
 module ActiveRelation
-  module Relations
-    class Compound < Base
-      attr_reader :relation
-  
-      delegate :attributes, :attribute, :joins, :selects, :orders, :table_sql, :inserts, :limit, :offset, :to => :relation
-    end
+  class Compound < Relation
+    attr_reader :relation
+
+    delegate :attributes, :attribute, :joins, :selects, :orders, :table_sql, :inserts, :limit, :offset, :to => :relation
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/deletion.rb b/lib/active_relation/relations/deletion.rb
index add6440c2a..4ac40a146b 100644
--- a/lib/active_relation/relations/deletion.rb
+++ b/lib/active_relation/relations/deletion.rb
@@ -1,17 +1,15 @@
 module ActiveRelation
-  module Relations
-    class Deletion < Compound
-      def initialize(relation)
-        @relation = relation
-      end
-  
-      def to_sql(strategy = nil)
-        [
-          "DELETE",
-          "FROM #{table_sql}",
-          ("WHERE #{selects.collect(&:to_sql).join('\n\tAND ')}" unless selects.blank?)
-        ].compact.join("\n")
-      end  
+  class Deletion < Compound
+    def initialize(relation)
+      @relation = relation
     end
+
+    def to_sql(strategy = nil)
+      [
+        "DELETE",
+        "FROM #{table_sql}",
+        ("WHERE #{selects.collect(&:to_sql).join('\n\tAND ')}" unless selects.blank?)
+      ].compact.join("\n")
+    end  
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/insertion.rb b/lib/active_relation/relations/insertion.rb
index c82513ce0f..31e4339ee0 100644
--- a/lib/active_relation/relations/insertion.rb
+++ b/lib/active_relation/relations/insertion.rb
@@ -1,25 +1,23 @@
 module ActiveRelation
-  module Relations
-    class Insertion < Compound
-      attr_reader :record
-  
-      def initialize(relation, record)
-        @relation, @record = relation, record
-      end
+  class Insertion < Compound
+    attr_reader :record
 
-      def to_sql(strategy = nil)
-        [
-          "INSERT",
-          "INTO #{table_sql}",
-          "(#{record.keys.collect(&:to_sql).join(', ')})",
-          "VALUES #{inserts.collect(&:to_sql).join(', ')}"
-        ].join("\n")
-      end  
+    def initialize(relation, record)
+      @relation, @record = relation, record
+    end
+
+    def to_sql(strategy = nil)
+      [
+        "INSERT",
+        "INTO #{table_sql}",
+        "(#{record.keys.collect(&:to_sql).join(', ')})",
+        "VALUES #{inserts.collect(&:to_sql).join(', ')}"
+      ].join("\n")
+    end  
 
-      protected
-      def inserts
-        relation.inserts + [record]
-      end
+    protected
+    def inserts
+      relation.inserts + [record]
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/join.rb b/lib/active_relation/relations/join.rb
index 4e6c85979e..8ccd1e9c6c 100644
--- a/lib/active_relation/relations/join.rb
+++ b/lib/active_relation/relations/join.rb
@@ -1,45 +1,43 @@
 module ActiveRelation
-  module Relations
-    class Join < Base
-      attr_reader :join_sql, :relation1, :relation2, :predicates
-  
-      def initialize(join_sql, relation1, relation2, *predicates)
-        @join_sql, @relation1, @relation2, @predicates = join_sql, relation1, relation2, predicates
-      end
-  
-      def ==(other)
-        predicates == other.predicates and
-          ((relation1 == other.relation1 and relation2 == other.relation2) or
-          (relation2 == other.relation1 and relation1 == other.relation2))
-      end
-
-      def qualify
-        Join.new(join_sql, relation1.qualify, relation2.qualify, *predicates.collect(&:qualify))
-      end
-  
-      protected
-      def joins
-        [relation1.joins, relation2.joins, join].compact.join(" ")
-      end
-  
-      def selects
-        relation1.send(:selects) + relation2.send(:selects)
-      end
-  
-      def attributes
-        relation1.attributes + relation2.attributes
-      end
-  
-      def attribute(name)
-        relation1[name] || relation2[name]
-      end
-  
-      delegate :table_sql, :to => :relation1
-  
-      private
-      def join
-        "#{join_sql} #{relation2.send(:table_sql)} ON #{predicates.collect { |p| p.to_sql(Sql::Predicate.new) }.join(' AND ')}"
-      end
+  class Join < Relation
+    attr_reader :join_sql, :relation1, :relation2, :predicates
+
+    def initialize(join_sql, relation1, relation2, *predicates)
+      @join_sql, @relation1, @relation2, @predicates = join_sql, relation1, relation2, predicates
+    end
+
+    def ==(other)
+      predicates == other.predicates and
+        ((relation1 == other.relation1 and relation2 == other.relation2) or
+        (relation2 == other.relation1 and relation1 == other.relation2))
+    end
+
+    def qualify
+      Join.new(join_sql, relation1.qualify, relation2.qualify, *predicates.collect(&:qualify))
+    end
+
+    protected
+    def joins
+      [relation1.joins, relation2.joins, join].compact.join(" ")
+    end
+
+    def selects
+      relation1.send(:selects) + relation2.send(:selects)
+    end
+
+    def attributes
+      relation1.attributes + relation2.attributes
+    end
+
+    def attribute(name)
+      relation1[name] || relation2[name]
+    end
+
+    delegate :table_sql, :to => :relation1
+
+    private
+    def join
+      "#{join_sql} #{relation2.send(:table_sql)} ON #{predicates.collect { |p| p.to_sql(Sql::Predicate.new) }.join(' AND ')}"
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/order.rb b/lib/active_relation/relations/order.rb
index bca81c1b6d..d5c2a54cd1 100644
--- a/lib/active_relation/relations/order.rb
+++ b/lib/active_relation/relations/order.rb
@@ -1,19 +1,17 @@
 module ActiveRelation
-  module Relations
-    class Order < Compound
-      attr_reader :orders
-  
-      def initialize(relation, *orders)
-        @relation, @orders = relation, orders
-      end
-  
-      def ==(other)
-        relation == other.relation and orders == other.orders
-      end
-  
-      def qualify
-        Order.new(relation.qualify, *orders.collect { |o| o.qualify })
-      end
+  class Order < Compound
+    attr_reader :orders
+
+    def initialize(relation, *orders)
+      @relation, @orders = relation, orders
+    end
+
+    def ==(other)
+      relation == other.relation and orders == other.orders
+    end
+
+    def qualify
+      Order.new(relation.qualify, *orders.collect { |o| o.qualify })
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/projection.rb b/lib/active_relation/relations/projection.rb
index 131db916f0..211e0607ac 100644
--- a/lib/active_relation/relations/projection.rb
+++ b/lib/active_relation/relations/projection.rb
@@ -1,19 +1,17 @@
 module ActiveRelation
-  module Relations
-    class Projection < Compound
-      attr_reader :attributes
-  
-      def initialize(relation, *attributes)
-        @relation, @attributes = relation, attributes
-      end
-  
-      def ==(other)
-        self.class == other.class and relation == other.relation and attributes == other.attributes
-      end
-  
-      def qualify
-        Projection.new(relation.qualify, *attributes.collect(&:qualify))
-      end
+  class Projection < Compound
+    attr_reader :attributes
+
+    def initialize(relation, *attributes)
+      @relation, @attributes = relation, attributes
+    end
+
+    def ==(other)
+      self.class == other.class and relation == other.relation and attributes == other.attributes
+    end
+
+    def qualify
+      Projection.new(relation.qualify, *attributes.collect(&:qualify))
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/range.rb b/lib/active_relation/relations/range.rb
index d7e08efa06..e8b7f4b69d 100644
--- a/lib/active_relation/relations/range.rb
+++ b/lib/active_relation/relations/range.rb
@@ -1,23 +1,21 @@
 module ActiveRelation
-  module Relations
-    class Range < Compound
-      attr_reader :range
-  
-      def initialize(relation, range)
-        @relation, @range = relation, range
-      end
-  
-      def ==(other)
-        relation == other.relation and range == other.range
-      end
-  
-      def limit
-        range.end - range.begin + 1
-      end
-  
-      def offset
-        range.begin
-      end
+  class Range < Compound
+    attr_reader :range
+
+    def initialize(relation, range)
+      @relation, @range = relation, range
+    end
+
+    def ==(other)
+      relation == other.relation and range == other.range
+    end
+
+    def limit
+      range.end - range.begin + 1
+    end
+
+    def offset
+      range.begin
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/relation.rb b/lib/active_relation/relations/relation.rb
new file mode 100644
index 0000000000..663450e69c
--- /dev/null
+++ b/lib/active_relation/relations/relation.rb
@@ -0,0 +1,103 @@
+module ActiveRelation
+  class Relation
+    include Sql::Quoting
+
+    module Iteration
+      include Enumerable
+  
+      def each(&block)
+        connection.select_all(to_s).each(&block)
+      end
+  
+      def first
+        connection.select_one(to_s)
+      end
+    end
+    include Iteration
+
+    module Operations
+      def join(other)
+        JoinOperation.new("INNER JOIN", self, other)
+      end
+
+      def outer_join(other)
+        JoinOperation.new("LEFT OUTER JOIN", self, other)
+      end
+
+      def [](index)
+        case index
+        when Symbol
+          attribute(index)
+        when ::Range
+          Range.new(self, index)
+        end
+      end
+
+      def include?(attribute)
+        RelationInclusion.new(attribute, self)
+      end
+
+      def select(*predicates)
+        Selection.new(self, *predicates)
+      end
+
+      def project(*attributes)
+        Projection.new(self, *attributes)
+      end
+      
+      def as(aliaz)
+        Alias.new(self, aliaz)
+      end
+
+      def order(*attributes)
+        Order.new(self, *attributes)
+      end
+  
+      def rename(attribute, aliaz)
+        Rename.new(self, attribute => aliaz)
+      end
+  
+      def insert(record)
+        Insertion.new(self, record)
+      end
+  
+      def delete
+        Deletion.new(self)
+      end
+  
+      JoinOperation = Struct.new(:join_sql, :relation1, :relation2) do
+        def on(*predicates)
+          Join.new(join_sql, relation1, relation2, *predicates)
+        end
+      end
+    end
+    include Operations
+
+    def to_sql(strategy = Sql::Select.new)
+      strategy.select [
+        "SELECT #{attributes.collect{ |a| a.to_sql(Sql::Projection.new) }.join(', ')}",
+        "FROM #{table_sql}",
+        (joins unless joins.blank?),
+        ("WHERE #{selects.collect{|s| s.to_sql(Sql::Predicate.new)}.join("\n\tAND ")}" unless selects.blank?),
+        ("ORDER BY #{orders.collect(&:to_sql)}" unless orders.blank?),
+        ("LIMIT #{limit.to_sql}" unless limit.blank?),
+        ("OFFSET #{offset.to_sql}" unless offset.blank?)
+      ].compact.join("\n")
+    end
+    alias_method :to_s, :to_sql
+  
+    protected
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    def attributes; []  end
+    def selects;    []  end
+    def orders;     []  end
+    def inserts;    []  end
+    def joins;      nil end
+    def limit;      nil end
+    def offset;     nil end
+    def alias;      nil end
+  end
+end
\ No newline at end of file
diff --git a/lib/active_relation/relations/rename.rb b/lib/active_relation/relations/rename.rb
index c4ba6ded88..2977804db1 100644
--- a/lib/active_relation/relations/rename.rb
+++ b/lib/active_relation/relations/rename.rb
@@ -1,38 +1,36 @@
 module ActiveRelation
-  module Relations
-    class Rename < Compound
-      attr_reader :schmattribute, :rename
-  
-      def initialize(relation, renames)
-        @schmattribute, @rename = renames.shift
-        @relation = renames.empty?? relation : Rename.new(relation, renames)
-      end
-  
-      def ==(other)
-        relation == other.relation and schmattribute == other.schmattribute and self.rename == other.rename
-      end
-  
-      def attributes
-        relation.attributes.collect(&method(:substitute))
-      end
-  
-      def qualify
-        Rename.new(relation.qualify, schmattribute.qualify => self.rename)
-      end
-  
-      protected
-      def attribute(name)
-        case
-        when name == self.rename then schmattribute.as(self.rename)
-        when relation[name] == schmattribute then nil
-        else relation[name]
-        end
-      end
-  
-      private
-      def substitute(a)
-        a == schmattribute ? a.as(self.rename) : a
+  class Rename < Compound
+    attr_reader :schmattribute, :rename
+
+    def initialize(relation, renames)
+      @schmattribute, @rename = renames.shift
+      @relation = renames.empty?? relation : Rename.new(relation, renames)
+    end
+
+    def ==(other)
+      relation == other.relation and schmattribute == other.schmattribute and self.rename == other.rename
+    end
+
+    def attributes
+      relation.attributes.collect(&method(:substitute))
+    end
+
+    def qualify
+      Rename.new(relation.qualify, schmattribute.qualify => self.rename)
+    end
+
+    protected
+    def attribute(name)
+      case
+      when name == self.rename then schmattribute.as(self.rename)
+      when relation[name] == schmattribute then nil
+      else relation[name]
       end
     end
+
+    private
+    def substitute(a)
+      a == schmattribute ? a.as(self.rename) : a
+    end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/selection.rb b/lib/active_relation/relations/selection.rb
index e86dc627db..3ecea059d5 100644
--- a/lib/active_relation/relations/selection.rb
+++ b/lib/active_relation/relations/selection.rb
@@ -1,25 +1,23 @@
 module ActiveRelation
-  module Relations
-    class Selection < Compound
-      attr_reader :predicate
-  
-      def initialize(relation, *predicates)
-        @predicate = predicates.shift
-        @relation = predicates.empty?? relation : Selection.new(relation, *predicates)
-      end
-  
-      def ==(other)
-        relation == other.relation and predicate == other.predicate
-      end
-  
-      def qualify
-        Selection.new(relation.qualify, predicate.qualify)
-      end
-  
-      protected
-      def selects
-        relation.send(:selects) + [predicate]
-      end
+  class Selection < Compound
+    attr_reader :predicate
+
+    def initialize(relation, *predicates)
+      @predicate = predicates.shift
+      @relation = predicates.empty?? relation : Selection.new(relation, *predicates)
+    end
+
+    def ==(other)
+      relation == other.relation and predicate == other.predicate
+    end
+
+    def qualify
+      Selection.new(relation.qualify, predicate.qualify)
+    end
+
+    protected
+    def selects
+      relation.send(:selects) + [predicate]
     end
   end
 end
\ No newline at end of file
diff --git a/lib/active_relation/relations/table.rb b/lib/active_relation/relations/table.rb
index a370b4266d..5220087318 100644
--- a/lib/active_relation/relations/table.rb
+++ b/lib/active_relation/relations/table.rb
@@ -1,39 +1,37 @@
 module ActiveRelation
-  module Relations
-    class Table < Base
-      attr_reader :name
-  
-      def initialize(name)
-        @name = name
-      end
-  
-      def attributes
-        attributes_by_name.values
-      end
+  class Table < Relation
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def attributes
+      attributes_by_name.values
+    end
+
+    def qualify
+      Rename.new self, qualifications
+    end
   
-      def qualify
-        Rename.new self, qualifications
-      end
+    protected
+    def attribute(name)
+      attributes_by_name[name.to_s]
+    end
     
-      protected
-      def attribute(name)
-        attributes_by_name[name.to_s]
-      end
-      
-      def table_sql
-        "#{quote_table_name(name)}"
-      end
-  
-      private
-      def attributes_by_name
-        @attributes_by_name ||= connection.columns(name, "#{name} Columns").inject({}) do |attributes_by_name, column|
-          attributes_by_name.merge(column.name => Primitives::Attribute.new(self, column.name.to_sym))
-        end
-      end
-  
-      def qualifications
-        attributes.zip(attributes.collect(&:qualified_name)).to_hash
+    def table_sql
+      "#{quote_table_name(name)}"
+    end
+
+    private
+    def attributes_by_name
+      @attributes_by_name ||= connection.columns(name, "#{name} Columns").inject({}) do |attributes_by_name, column|
+        attributes_by_name.merge(column.name => Attribute.new(self, column.name.to_sym))
       end
     end
+
+    def qualifications
+      attributes.zip(attributes.collect(&:qualified_name)).to_hash
+    end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/binary_spec.rb b/spec/active_relation/predicates/binary_spec.rb
index be607efd95..a6878e4898 100644
--- a/spec/active_relation/predicates/binary_spec.rb
+++ b/spec/active_relation/predicates/binary_spec.rb
@@ -1,42 +1,44 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::Binary do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name1)
-    @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation2, :name2)
-    class ConcreteBinary < ActiveRelation::Predicates::Binary
-      def predicate_sql
-        "<=>"
+module ActiveRelation
+  describe Binary do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = Attribute.new(@relation1, :name1)
+      @attribute2 = Attribute.new(@relation2, :name2)
+      class ConcreteBinary < Binary
+        def predicate_sql
+          "<=>"
+        end
       end
     end
-  end
   
-  describe '==' do
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2)
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should_not == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute1)
-    end
+    describe '==' do
+      it "obtains if attribute1 and attribute2 are identical" do
+        Binary.new(@attribute1, @attribute2).should == Binary.new(@attribute1, @attribute2)
+        Binary.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute1)
+      end
     
-    it "obtains if the concrete type of the ActiveRelation::Predicates::Binarys are identical" do
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2)
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should_not == ConcreteBinary.new(@attribute1, @attribute2)
+      it "obtains if the concrete type of the Predicates::Binarys are identical" do
+        Binary.new(@attribute1, @attribute2).should == Binary.new(@attribute1, @attribute2)
+        Binary.new(@attribute1, @attribute2).should_not == ConcreteBinary.new(@attribute1, @attribute2)
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the predicates and attributes" do
-      ConcreteBinary.new(@attribute1, @attribute2).qualify. \
-        should == ConcreteBinary.new(@attribute1.qualify, @attribute2.qualify)
+    describe '#qualify' do
+      it "distributes over the predicates and attributes" do
+        ConcreteBinary.new(@attribute1, @attribute2).qualify. \
+          should == ConcreteBinary.new(@attribute1.qualify, @attribute2.qualify)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it 'manufactures correct sql' do
-      ConcreteBinary.new(@attribute1, @attribute2).to_sql.should be_like("""
-        `foo`.`name1` <=> `bar`.`name2`
-      """)
+    describe '#to_sql' do
+      it 'manufactures correct sql' do
+        ConcreteBinary.new(@attribute1, @attribute2).to_sql.should be_like("""
+          `foo`.`name1` <=> `bar`.`name2`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/equality_spec.rb b/spec/active_relation/predicates/equality_spec.rb
index 9394e63835..d23893e438 100644
--- a/spec/active_relation/predicates/equality_spec.rb
+++ b/spec/active_relation/predicates/equality_spec.rb
@@ -1,28 +1,30 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::Equality do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-    @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation2, :name)
-  end
-  
-  describe '==' do 
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2)
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should_not == ActiveRelation::Predicates::Equality.new(@attribute1, @attribute1)
+module ActiveRelation
+  describe Equality do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = Attribute.new(@relation1, :name)
+      @attribute2 = Attribute.new(@relation2, :name)
     end
+  
+    describe '==' do 
+      it "obtains if attribute1 and attribute2 are identical" do
+        Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute1, @attribute2)
+        Equality.new(@attribute1, @attribute2).should_not == Equality.new(@attribute1, @attribute1)
+      end
     
-    it "obtains if the concrete type of the predicates are identical" do
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should_not == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2)
-    end
+      it "obtains if the concrete type of the predicates are identical" do
+        Equality.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute2)
+      end
     
-    it "is commutative on the attributes" do
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Equality.new(@attribute2, @attribute1)
+      it "is commutative on the attributes" do
+        Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute2, @attribute1)
+      end
     end
-  end
   
-  describe '#to_sql' do
+    describe '#to_sql' do
+    end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/match_spec.rb b/spec/active_relation/predicates/match_spec.rb
index a01f4fb76b..3d01ce1055 100644
--- a/spec/active_relation/predicates/match_spec.rb
+++ b/spec/active_relation/predicates/match_spec.rb
@@ -1,16 +1,18 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::RelationInclusion do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute = @relation1[:baz]
-  end
+module ActiveRelation
+  describe RelationInclusion do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute = @relation1[:baz]
+    end
   
-  describe ActiveRelation::Predicates::RelationInclusion, '==' do    
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1)
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should_not == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation2)
+    describe RelationInclusion, '==' do    
+      it "obtains if attribute1 and attribute2 are identical" do
+        RelationInclusion.new(@attribute, @relation1).should == RelationInclusion.new(@attribute, @relation1)
+        RelationInclusion.new(@attribute, @relation1).should_not == RelationInclusion.new(@attribute, @relation2)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/relation_inclusion_spec.rb b/spec/active_relation/predicates/relation_inclusion_spec.rb
index de3dcf7747..05039028ee 100644
--- a/spec/active_relation/predicates/relation_inclusion_spec.rb
+++ b/spec/active_relation/predicates/relation_inclusion_spec.rb
@@ -1,25 +1,27 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::RelationInclusion do
-  before do
-    foo = ActiveRelation::Relations::Table.new(:foo)
-    @relation1 = foo.project(foo[:id])
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute = @relation1[:id]
-  end
+module ActiveRelation
+  describe RelationInclusion do
+    before do
+      foo = Table.new(:foo)
+      @relation1 = foo.project(foo[:id])
+      @relation2 = Table.new(:bar)
+      @attribute = @relation1[:id]
+    end
   
-  describe ActiveRelation::Predicates::RelationInclusion, '==' do    
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1)
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should_not == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation2)
+    describe RelationInclusion, '==' do    
+      it "obtains if attribute1 and attribute2 are identical" do
+        RelationInclusion.new(@attribute, @relation1).should == RelationInclusion.new(@attribute, @relation1)
+        RelationInclusion.new(@attribute, @relation1).should_not == RelationInclusion.new(@attribute, @relation2)
+      end
     end
-  end
   
-  describe ActiveRelation::Predicates::RelationInclusion, '#to_sql' do
-    it "manufactures subselect sql" do
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).to_sql.should be_like("""
-        `foo`.`id` IN (SELECT `foo`.`id` FROM `foo`)
-      """)
+    describe RelationInclusion, '#to_sql' do
+      it "manufactures subselect sql" do
+        RelationInclusion.new(@attribute, @relation1).to_sql.should be_like("""
+          `foo`.`id` IN (SELECT `foo`.`id` FROM `foo`)
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/primitives/aggregation_spec.rb b/spec/active_relation/primitives/aggregation_spec.rb
index 60bb4a6aa8..bdfa152bca 100644
--- a/spec/active_relation/primitives/aggregation_spec.rb
+++ b/spec/active_relation/primitives/aggregation_spec.rb
@@ -1,25 +1,27 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Primitives::Aggregation do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-  end
+module ActiveRelation
+  describe Aggregation do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+    end
   
-  describe '==' do
-    it 'obtains if the attribute and function sql are identical' do
-      @relation1[:id].sum.should == @relation1[:id].sum
-      @relation1[:id].sum.should_not == @relation1[:name].sum
-      @relation1[:id].sum.should_not == @relation1[:name].average 
-      @relation1[:id].sum.should_not == @relation2[:id].sum
+    describe '==' do
+      it 'obtains if the attribute and function sql are identical' do
+        @relation1[:id].sum.should == @relation1[:id].sum
+        @relation1[:id].sum.should_not == @relation1[:name].sum
+        @relation1[:id].sum.should_not == @relation1[:name].average 
+        @relation1[:id].sum.should_not == @relation2[:id].sum
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it 'manufactures sql with an aggregation function' do
-      @relation1[:id].maximum.to_sql.should be_like("""
-        MAX(`foo`.`id`)
-      """)
+    describe '#to_sql' do
+      it 'manufactures sql with an aggregation function' do
+        @relation1[:id].maximum.to_sql.should be_like("""
+          MAX(`foo`.`id`)
+        """)
+      end
     end
   end
-end
+end
\ No newline at end of file
diff --git a/spec/active_relation/primitives/attribute_spec.rb b/spec/active_relation/primitives/attribute_spec.rb
index f1aa404a34..6078da08f3 100644
--- a/spec/active_relation/primitives/attribute_spec.rb
+++ b/spec/active_relation/primitives/attribute_spec.rb
@@ -1,119 +1,119 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Primitives::Attribute do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-  end
-  
-  describe '#as' do
-    it "manufactures an aliased attributed when provided a parameter" do
-      @relation1[:id].as(:alias).should == ActiveRelation::Primitives::Attribute.new(@relation1, :id, :alias)
+module ActiveRelation
+  describe Attribute do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
     end
-  end
   
-  describe '#qualified_name' do
-    it "manufactures an attribute name prefixed with the relation's name" do
-      @relation1[:id].qualified_name.should == 'foo.id'
+    describe '#as' do
+      it "manufactures an aliased attributed when provided a parameter" do
+        @relation1[:id].as(:alias).should == Attribute.new(@relation1, :id, :alias)
+      end
     end
+  
+    describe '#qualified_name' do
+      it "manufactures an attribute name prefixed with the relation's name" do
+        @relation1[:id].qualified_name.should == 'foo.id'
+      end
     
-    it "manufactures an attribute name prefixed with the relation's aliased name" do
-      @relation1.as(:bar)[:id].qualified_name.should == 'bar.id'
+      it "manufactures an attribute name prefixed with the relation's aliased name" do
+        @relation1.as(:bar)[:id].qualified_name.should == 'bar.id'
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "manufactures an attribute aliased with that attributes qualified name" do
-      @relation1[:id].qualify.should == @relation1[:id].qualify
+    describe '#qualify' do
+      it "manufactures an attribute aliased with that attributes qualified name" do
+        @relation1[:id].qualify.should == @relation1[:id].qualify
+      end
     end
-  end
   
-  describe '==' do
-    it "obtains if the relation and attribute name are identical" do
-      ActiveRelation::Primitives::Attribute.new(@relation1, :name).should == ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-      ActiveRelation::Primitives::Attribute.new(@relation1, :name).should_not == ActiveRelation::Primitives::Attribute.new(@relation1, :another_name)
-      ActiveRelation::Primitives::Attribute.new(@relation1, :name).should_not == ActiveRelation::Primitives::Attribute.new(@relation2, :name)
+    describe '==' do
+      it "obtains if the relation and attribute name are identical" do
+        Attribute.new(@relation1, :name).should == Attribute.new(@relation1, :name)
+        Attribute.new(@relation1, :name).should_not == Attribute.new(@relation1, :another_name)
+        Attribute.new(@relation1, :name).should_not == Attribute.new(@relation2, :name)
+      end
     end
-  end
   
-  describe 'predications' do
-    before do
-      @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-      @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation2, :name)
-    end
+    describe 'predications' do
+      before do
+        @attribute1 = Attribute.new(@relation1, :name)
+        @attribute2 = Attribute.new(@relation2, :name)
+      end
     
-    describe '#equals' do
-      it "manufactures an equality predicate" do
-        @attribute1.equals(@attribute2).should == ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2)
+      describe '#equals' do
+        it "manufactures an equality predicate" do
+          @attribute1.equals(@attribute2).should == Equality.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#less_than' do
-      it "manufactures a less-than predicate" do
-        @attribute1.less_than(@attribute2).should == ActiveRelation::Predicates::LessThan.new(@attribute1, @attribute2)
+      describe '#less_than' do
+        it "manufactures a less-than predicate" do
+          @attribute1.less_than(@attribute2).should == LessThan.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#less_than_or_equal_to' do
-      it "manufactures a less-than or equal-to predicate" do
-        @attribute1.less_than_or_equal_to(@attribute2).should == ActiveRelation::Predicates::LessThanOrEqualTo.new(@attribute1, @attribute2)
+      describe '#less_than_or_equal_to' do
+        it "manufactures a less-than or equal-to predicate" do
+          @attribute1.less_than_or_equal_to(@attribute2).should == LessThanOrEqualTo.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#greater_than' do
-      it "manufactures a greater-than predicate" do
-        @attribute1.greater_than(@attribute2).should == ActiveRelation::Predicates::GreaterThan.new(@attribute1, @attribute2)
+      describe '#greater_than' do
+        it "manufactures a greater-than predicate" do
+          @attribute1.greater_than(@attribute2).should == GreaterThan.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#greater_than_or_equal_to' do
-      it "manufactures a greater-than or equal to predicate" do
-        @attribute1.greater_than_or_equal_to(@attribute2).should == ActiveRelation::Predicates::GreaterThanOrEqualTo.new(@attribute1, @attribute2)
+      describe '#greater_than_or_equal_to' do
+        it "manufactures a greater-than or equal to predicate" do
+          @attribute1.greater_than_or_equal_to(@attribute2).should == GreaterThanOrEqualTo.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#matches' do
-      it "manufactures a match predicate" do
-        @attribute1.matches(/.*/).should == ActiveRelation::Predicates::Match.new(@attribute1, @attribute2)
+      describe '#matches' do
+        it "manufactures a match predicate" do
+          @attribute1.matches(/.*/).should == Match.new(@attribute1, @attribute2)
+        end
       end
     end
-  end
   
-  describe 'aggregations' do
-    before do
-      @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)    
-    end
-    
-    describe '#count' do
-      it "manufactures a count aggregation" do
-        @attribute1.count.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "COUNT")
+    describe 'aggregations' do
+      before do
+        @attribute1 = Attribute.new(@relation1, :name)    
       end
-    end
     
-    describe '#sum' do
-      it "manufactures a sum aggregation" do
-        @attribute1.sum.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "SUM")
+      describe '#count' do
+        it "manufactures a count aggregation" do
+          @attribute1.count.should == Aggregation.new(@attribute1, "COUNT")
+        end
       end
-    end
     
-    describe '#maximum' do
-      it "manufactures a maximum aggregation" do
-        @attribute1.maximum.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "MAX")
+      describe '#sum' do
+        it "manufactures a sum aggregation" do
+          @attribute1.sum.should == Aggregation.new(@attribute1, "SUM")
+        end
       end
-    end
     
-    describe '#minimum' do
-      it "manufactures a minimum aggregation" do
-        @attribute1.minimum.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "MIN")
+      describe '#maximum' do
+        it "manufactures a maximum aggregation" do
+          @attribute1.maximum.should == Aggregation.new(@attribute1, "MAX")
+        end
       end
-    end
     
-    describe '#average' do
-      it "manufactures an average aggregation" do
-        @attribute1.average.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "AVG")
+      describe '#minimum' do
+        it "manufactures a minimum aggregation" do
+          @attribute1.minimum.should == Aggregation.new(@attribute1, "MIN")
+        end
       end
-    end
-    
     
+      describe '#average' do
+        it "manufactures an average aggregation" do
+          @attribute1.average.should == Aggregation.new(@attribute1, "AVG")
+        end
+      end 
+    end
   end
-end
+end
\ No newline at end of file
diff --git a/spec/active_relation/relations/alias_spec.rb b/spec/active_relation/relations/alias_spec.rb
index 6f25df3ddb..418af7fe66 100644
--- a/spec/active_relation/relations/alias_spec.rb
+++ b/spec/active_relation/relations/alias_spec.rb
@@ -1,36 +1,38 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Alias do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-    @alias_relation = @relation.as(:foo)
-  end
+module ActiveRelation
+  describe Alias do
+    before do
+      @relation = Table.new(:users)
+      @alias_relation = @relation.as(:foo)
+    end
   
-  describe '#name' do
-    it 'returns the alias' do
-      @alias_relation.name.should == :foo
+    describe '#name' do
+      it 'returns the alias' do
+        @alias_relation.name.should == :foo
+      end
     end
-  end
   
-  describe '#attributes' do
-    it 'manufactures sql deleting a table relation' do
-      @alias_relation.attributes.should == @relation.attributes.collect { |a| ActiveRelation::Primitives::Attribute.new(@alias_relation, a.name) }
+    describe '#attributes' do
+      it 'manufactures sql deleting a table relation' do
+        @alias_relation.attributes.should == @relation.attributes.collect { |a| Attribute.new(@alias_relation, a.name) }
+      end
     end
-  end
   
-  describe '[]' do
-    it 'manufactures attributes associated with the aliased relation' do
-      @alias_relation[:id].relation.should == @alias_relation
-      @alias_relation[:does_not_exist].should be_nil
+    describe '[]' do
+      it 'manufactures attributes associated with the aliased relation' do
+        @alias_relation[:id].relation.should == @alias_relation
+        @alias_relation[:does_not_exist].should be_nil
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures an aliased select query" do
-      @alias_relation.to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `users` AS `foo`
-      """)
+    describe '#to_sql' do
+      it "manufactures an aliased select query" do
+        @alias_relation.to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `users` AS `foo`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/base_spec.rb b/spec/active_relation/relations/base_spec.rb
deleted file mode 100644
index 18063757df..0000000000
--- a/spec/active_relation/relations/base_spec.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
-
-describe ActiveRelation::Relations::Base do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :id)
-    @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-  end
-  
-  describe '[]' do
-    it "manufactures an attribute when given a symbol" do
-      @relation1[:id].should == ActiveRelation::Primitives::Attribute.new(@relation1, :id)
-    end
-    
-    it "manufactures a range relation when given a range" do
-      @relation1[1..2].should == ActiveRelation::Relations::Range.new(@relation1, 1..2)
-    end
-  end
-  
-  describe '#include?' do
-    it "manufactures an inclusion predicate" do
-      @relation1.include?(@attribute1).should be_kind_of(ActiveRelation::Predicates::RelationInclusion)
-    end
-  end
-
-  describe 'read operations' do
-    describe 'joins' do
-      before do
-        @predicate = @relation1[:id].equals(@relation2[:id])
-      end
-      
-      describe '#join' do
-        it "manufactures an inner join operation between those two relations" do
-          @relation1.join(@relation2).on(@predicate).should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate)
-        end
-      end
-    
-      describe '#outer_join' do
-        it "manufactures a left outer join operation between those two relations" do
-          @relation1.outer_join(@relation2).on(@predicate).should == ActiveRelation::Relations::Join.new("LEFT OUTER JOIN", @relation1, @relation2, @predicate)
-        end      
-      end
-    end
-  
-    describe '#project' do
-      it "collapses identical projections" do
-        pending
-      end
-    
-      it "manufactures a projection relation" do
-        @relation1.project(@attribute1, @attribute2).should == ActiveRelation::Relations::Projection.new(@relation1, @attribute1, @attribute2)
-      end
-    end
-    
-    describe '#as' do
-      it "manufactures an alias relation" do
-        @relation1.as(:thucydides).should == ActiveRelation::Relations::Alias.new(@relation1, :thucydides)
-      end
-    end
-  
-    describe '#rename' do
-      it "manufactures a rename relation" do
-        @relation1.rename(@attribute1, :foo).should == ActiveRelation::Relations::Rename.new(@relation1, @attribute1 => :foo)
-      end
-    end
-  
-    describe '#select' do
-      before do
-        @predicate = ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2)
-      end
-    
-      it "manufactures a selection relation" do
-        @relation1.select(@predicate).should == ActiveRelation::Relations::Selection.new(@relation1, @predicate)
-      end
-    
-      it "accepts arbitrary strings" do
-        @relation1.select("arbitrary").should == ActiveRelation::Relations::Selection.new(@relation1, "arbitrary")
-      end
-    end
-  
-    describe '#order' do
-      it "manufactures an order relation" do
-        @relation1.order(@attribute1, @attribute2).should be_kind_of(ActiveRelation::Relations::Order)
-      end
-    end
-  end
-  
-  describe 'write operations' do
-    describe '#delete' do
-      it 'manufactures a deletion relation' do
-        @relation1.delete.should be_kind_of(ActiveRelation::Relations::Deletion)
-      end
-    end
-    
-    describe '#insert' do
-      it 'manufactures an insertion relation' do
-        @relation1.insert(record = {:id => 1}).should be_kind_of(ActiveRelation::Relations::Insertion)
-      end
-    end
-  end
-end
\ No newline at end of file
diff --git a/spec/active_relation/relations/compound_spec.rb b/spec/active_relation/relations/compound_spec.rb
index f383ff4dfd..6309547c7d 100644
--- a/spec/active_relation/relations/compound_spec.rb
+++ b/spec/active_relation/relations/compound_spec.rb
@@ -1,12 +1,14 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Compound do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
+module ActiveRelation
+  describe Compound do
+    before do
+      @relation = Table.new(:users)
     
-    class ConcreteCompound < ActiveRelation::Relations::Compound
-      def initialize(relation)
-        @relation = relation
+      class ConcreteCompound < Compound
+        def initialize(relation)
+          @relation = relation
+        end
       end
     end
   end
diff --git a/spec/active_relation/relations/deletion_spec.rb b/spec/active_relation/relations/deletion_spec.rb
index ed201ac0d9..64b75d0600 100644
--- a/spec/active_relation/relations/deletion_spec.rb
+++ b/spec/active_relation/relations/deletion_spec.rb
@@ -1,24 +1,26 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Deletion do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-  end
-  
-  describe '#to_sql' do
-    it 'manufactures sql deleting a table relation' do
-      ActiveRelation::Relations::Deletion.new(@relation).to_sql.should be_like("""
-        DELETE
-        FROM `users`
-      """)
+module ActiveRelation
+  describe Deletion do
+    before do
+      @relation = Table.new(:users)
     end
+  
+    describe '#to_sql' do
+      it 'manufactures sql deleting a table relation' do
+        Deletion.new(@relation).to_sql.should be_like("""
+          DELETE
+          FROM `users`
+        """)
+      end
     
-    it 'manufactures sql deleting a selection relation' do
-      ActiveRelation::Relations::Deletion.new(@relation.select(@relation[:id].equals(1))).to_sql.should be_like("""
-        DELETE
-        FROM `users`
-        WHERE `users`.`id` = 1
-      """)
+      it 'manufactures sql deleting a selection relation' do
+        Deletion.new(@relation.select(@relation[:id].equals(1))).to_sql.should be_like("""
+          DELETE
+          FROM `users`
+          WHERE `users`.`id` = 1
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/insertion_spec.rb b/spec/active_relation/relations/insertion_spec.rb
index da39edf773..f16ab8cc23 100644
--- a/spec/active_relation/relations/insertion_spec.rb
+++ b/spec/active_relation/relations/insertion_spec.rb
@@ -1,26 +1,28 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Insertion do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-  end
-  
-  describe '#to_sql' do
-    it 'manufactures sql inserting the data for one item' do
-      ActiveRelation::Relations::Insertion.new(@relation, @relation[:name] => "nick").to_sql.should be_like("""
-        INSERT
-        INTO `users`
-        (`users`.`name`) VALUES ('nick')
-      """)
+module ActiveRelation
+  describe Insertion do
+    before do
+      @relation = Table.new(:users)
     end
+  
+    describe '#to_sql' do
+      it 'manufactures sql inserting the data for one item' do
+        Insertion.new(@relation, @relation[:name] => "nick").to_sql.should be_like("""
+          INSERT
+          INTO `users`
+          (`users`.`name`) VALUES ('nick')
+        """)
+      end
     
-    it 'manufactures sql inserting the data for multiple items' do
-      nested_insertion = ActiveRelation::Relations::Insertion.new(@relation, @relation[:name] => "cobra")
-      ActiveRelation::Relations::Insertion.new(nested_insertion, nested_insertion[:name] => "commander").to_sql.should be_like("""
-        INSERT
-        INTO `users`
-        (`users`.`name`) VALUES ('cobra'), ('commander')
-      """)
+      it 'manufactures sql inserting the data for multiple items' do
+        nested_insertion = Insertion.new(@relation, @relation[:name] => "cobra")
+        Insertion.new(nested_insertion, nested_insertion[:name] => "commander").to_sql.should be_like("""
+          INSERT
+          INTO `users`
+          (`users`.`name`) VALUES ('cobra'), ('commander')
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/join_spec.rb b/spec/active_relation/relations/join_spec.rb
index 2a84a92b70..25c505e371 100644
--- a/spec/active_relation/relations/join_spec.rb
+++ b/spec/active_relation/relations/join_spec.rb
@@ -1,43 +1,45 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Join do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @predicate = ActiveRelation::Predicates::Equality.new(@relation1[:id], @relation2[:id])
-  end
-  
-  describe '==' do
-    it 'obtains if the two relations and the predicate are identical' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate)
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).should_not == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation1, @predicate)
+module ActiveRelation
+  describe Join do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @predicate = Equality.new(@relation1[:id], @relation2[:id])
     end
   
-    it 'is commutative on the relations' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation2, @relation1, @predicate)
-    end
-  end
+    describe '==' do
+      it 'obtains if the two relations and the predicate are identical' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == Join.new("INNER JOIN", @relation1, @relation2, @predicate)
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).should_not == Join.new("INNER JOIN", @relation1, @relation1, @predicate)
+      end
   
-  describe '#qualify' do
-    it 'distributes over the relations and predicates' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).qualify. \
-        should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1.qualify, @relation2.qualify, @predicate.qualify)
+      it 'is commutative on the relations' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == Join.new("INNER JOIN", @relation2, @relation1, @predicate)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    before do
-      @relation1 = @relation1.select(@relation1[:id].equals(1))
+    describe '#qualify' do
+      it 'distributes over the relations and predicates' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).qualify. \
+          should == Join.new("INNER JOIN", @relation1.qualify, @relation2.qualify, @predicate.qualify)
+      end
     end
+  
+    describe '#to_sql' do
+      before do
+        @relation1 = @relation1.select(@relation1[:id].equals(1))
+      end
     
-    it 'manufactures sql joining the two tables on the predicate, merging the selects' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`, `bar`.`name`, `bar`.`foo_id`, `bar`.`id`
-        FROM `foo`
-          INNER JOIN `bar` ON `foo`.`id` = `bar`.`id`
-        WHERE
-          `foo`.`id` = 1
-      """)
+      it 'manufactures sql joining the two tables on the predicate, merging the selects' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`, `bar`.`name`, `bar`.`foo_id`, `bar`.`id`
+          FROM `foo`
+            INNER JOIN `bar` ON `foo`.`id` = `bar`.`id`
+          WHERE
+            `foo`.`id` = 1
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/order_spec.rb b/spec/active_relation/relations/order_spec.rb
index edf2faf455..204558daec 100644
--- a/spec/active_relation/relations/order_spec.rb
+++ b/spec/active_relation/relations/order_spec.rb
@@ -1,28 +1,30 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Order do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = @relation1[:id]
-    @attribute2 = @relation2[:id]
-  end
+module ActiveRelation
+  describe Order do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = @relation1[:id]
+      @attribute2 = @relation2[:id]
+    end
 
-  describe '#qualify' do
-    it "distributes over the relation and attributes" do
-      ActiveRelation::Relations::Order.new(@relation1, @attribute1).qualify. \
-        should == ActiveRelation::Relations::Order.new(@relation1.qualify, @attribute1.qualify)
+    describe '#qualify' do
+      it "distributes over the relation and attributes" do
+        Order.new(@relation1, @attribute1).qualify. \
+          should == Order.new(@relation1.qualify, @attribute1.qualify)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with an order clause" do
-      ActiveRelation::Relations::Order.new(@relation1, @attribute1).to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        ORDER BY `foo`.`id`
-      """)
+    describe '#to_sql' do
+      it "manufactures sql with an order clause" do
+        Order.new(@relation1, @attribute1).to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          ORDER BY `foo`.`id`
+        """)
+      end
     end
   end
-  
-end
\ No newline at end of file
+end
+  
\ No newline at end of file
diff --git a/spec/active_relation/relations/projection_spec.rb b/spec/active_relation/relations/projection_spec.rb
index 6ffdeb8e09..8d6a093af2 100644
--- a/spec/active_relation/relations/projection_spec.rb
+++ b/spec/active_relation/relations/projection_spec.rb
@@ -1,34 +1,36 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Projection do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = @relation1[:id]
-    @attribute2 = @relation2[:id]
-  end
+module ActiveRelation
+  describe Projection do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = @relation1[:id]
+      @attribute2 = @relation2[:id]
+    end
   
-  describe '==' do
-    it "obtains if the relations and attributes are identical" do
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1, @attribute2).should == ActiveRelation::Relations::Projection.new(@relation1, @attribute1, @attribute2)
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).should_not == ActiveRelation::Relations::Projection.new(@relation2, @attribute1)
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).should_not == ActiveRelation::Relations::Projection.new(@relation1, @attribute2)
+    describe '==' do
+      it "obtains if the relations and attributes are identical" do
+        Projection.new(@relation1, @attribute1, @attribute2).should == Projection.new(@relation1, @attribute1, @attribute2)
+        Projection.new(@relation1, @attribute1).should_not == Projection.new(@relation2, @attribute1)
+        Projection.new(@relation1, @attribute1).should_not == Projection.new(@relation1, @attribute2)
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the relation and attributes" do
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).qualify. \
-        should == ActiveRelation::Relations::Projection.new(@relation1.qualify, @attribute1.qualify)
+    describe '#qualify' do
+      it "distributes over the relation and attributes" do
+        Projection.new(@relation1, @attribute1).qualify. \
+          should == Projection.new(@relation1.qualify, @attribute1.qualify)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with a limited select clause" do
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).to_sql.should be_like("""
-        SELECT `foo`.`id`
-        FROM `foo`
-      """)
+    describe '#to_sql' do
+      it "manufactures sql with a limited select clause" do
+        Projection.new(@relation1, @attribute1).to_sql.should be_like("""
+          SELECT `foo`.`id`
+          FROM `foo`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/range_spec.rb b/spec/active_relation/relations/range_spec.rb
index d4107259aa..f417626fed 100644
--- a/spec/active_relation/relations/range_spec.rb
+++ b/spec/active_relation/relations/range_spec.rb
@@ -1,30 +1,31 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Range do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @range1 = 1..2
-    @range2 = 4..9
-  end
+module ActiveRelation
+  describe Range do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @range1 = 1..2
+      @range2 = 4..9
+    end
 
-  describe '#qualify' do
-    it "distributes over the relation and attributes" do
-      pending
+    describe '#qualify' do
+      it "distributes over the relation and attributes" do
+        pending
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with limit and offset" do
-      range_size = @range2.last - @range2.first + 1
-      range_start = @range2.first
-      ActiveRelation::Relations::Range.new(@relation1, @range2).to_s.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        LIMIT #{range_size}
-        OFFSET #{range_start}
-      """)
+    describe '#to_sql' do
+      it "manufactures sql with limit and offset" do
+        range_size = @range2.last - @range2.first + 1
+        range_start = @range2.first
+        Range.new(@relation1, @range2).to_s.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          LIMIT #{range_size}
+          OFFSET #{range_start}
+        """)
+      end
     end
   end
-  
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/relation_spec.rb b/spec/active_relation/relations/relation_spec.rb
new file mode 100644
index 0000000000..72b7d14389
--- /dev/null
+++ b/spec/active_relation/relations/relation_spec.rb
@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+module ActiveRelation
+  describe Relation do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = Attribute.new(@relation1, :id)
+      @attribute2 = Attribute.new(@relation1, :name)
+    end
+  
+    describe '[]' do
+      it "manufactures an attribute when given a symbol" do
+        @relation1[:id].should == Attribute.new(@relation1, :id)
+      end
+    
+      it "manufactures a range relation when given a range" do
+        @relation1[1..2].should == Range.new(@relation1, 1..2)
+      end
+    end
+  
+    describe '#include?' do
+      it "manufactures an inclusion predicate" do
+        @relation1.include?(@attribute1).should be_kind_of(RelationInclusion)
+      end
+    end
+
+    describe 'read operations' do
+      describe 'joins' do
+        before do
+          @predicate = @relation1[:id].equals(@relation2[:id])
+        end
+      
+        describe '#join' do
+          it "manufactures an inner join operation between those two relations" do
+            @relation1.join(@relation2).on(@predicate).should == Join.new("INNER JOIN", @relation1, @relation2, @predicate)
+          end
+        end
+    
+        describe '#outer_join' do
+          it "manufactures a left outer join operation between those two relations" do
+            @relation1.outer_join(@relation2).on(@predicate).should == Join.new("LEFT OUTER JOIN", @relation1, @relation2, @predicate)
+          end      
+        end
+      end
+  
+      describe '#project' do
+        it "collapses identical projections" do
+          pending
+        end
+    
+        it "manufactures a projection relation" do
+          @relation1.project(@attribute1, @attribute2).should == Projection.new(@relation1, @attribute1, @attribute2)
+        end
+      end
+    
+      describe '#as' do
+        it "manufactures an alias relation" do
+          @relation1.as(:thucydides).should == Alias.new(@relation1, :thucydides)
+        end
+      end
+  
+      describe '#rename' do
+        it "manufactures a rename relation" do
+          @relation1.rename(@attribute1, :foo).should == Rename.new(@relation1, @attribute1 => :foo)
+        end
+      end
+  
+      describe '#select' do
+        before do
+          @predicate = Equality.new(@attribute1, @attribute2)
+        end
+    
+        it "manufactures a selection relation" do
+          @relation1.select(@predicate).should == Selection.new(@relation1, @predicate)
+        end
+    
+        it "accepts arbitrary strings" do
+          @relation1.select("arbitrary").should == Selection.new(@relation1, "arbitrary")
+        end
+      end
+  
+      describe '#order' do
+        it "manufactures an order relation" do
+          @relation1.order(@attribute1, @attribute2).should be_kind_of(Order)
+        end
+      end
+    end
+  
+    describe 'write operations' do
+      describe '#delete' do
+        it 'manufactures a deletion relation' do
+          @relation1.delete.should be_kind_of(Deletion)
+        end
+      end
+    
+      describe '#insert' do
+        it 'manufactures an insertion relation' do
+          @relation1.insert(record = {:id => 1}).should be_kind_of(Insertion)
+        end
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/spec/active_relation/relations/rename_spec.rb b/spec/active_relation/relations/rename_spec.rb
index bdc5c97492..3f8d5e3dbd 100644
--- a/spec/active_relation/relations/rename_spec.rb
+++ b/spec/active_relation/relations/rename_spec.rb
@@ -1,61 +1,63 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Rename do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:foo)
-    @renamed_relation = ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :schmid)
-  end
-
-  describe '#initialize' do
-    it "manufactures nested rename relations if multiple renames are provided" do
-      ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :humpty, @relation[:name] => :dumpty). \
-        should == ActiveRelation::Relations::Rename.new(ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :humpty), @relation[:name] => :dumpty)
+module ActiveRelation
+  describe Rename do
+    before do
+      @relation = Table.new(:foo)
+      @renamed_relation = Rename.new(@relation, @relation[:id] => :schmid)
     end
 
-    it "raises an exception if the rename provided is already used" do
-      pending
+    describe '#initialize' do
+      it "manufactures nested rename relations if multiple renames are provided" do
+        Rename.new(@relation, @relation[:id] => :humpty, @relation[:name] => :dumpty). \
+          should == Rename.new(Rename.new(@relation, @relation[:id] => :humpty), @relation[:name] => :dumpty)
+      end
+
+      it "raises an exception if the rename provided is already used" do
+        pending
+      end
     end
-  end
     
-  describe '==' do
-    it "obtains if the relation, attribute, and rename are identical" do
-      pending
+    describe '==' do
+      it "obtains if the relation, attribute, and rename are identical" do
+        pending
+      end
     end
-  end
   
-  describe '#attributes' do
-    it "manufactures a list of attributes with the renamed attribute renameed" do
-      ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :schmid).attributes.should ==
-        (@relation.attributes - [@relation[:id]]) + [@relation[:id].as(:schmid)]
+    describe '#attributes' do
+      it "manufactures a list of attributes with the renamed attribute renameed" do
+        Rename.new(@relation, @relation[:id] => :schmid).attributes.should ==
+          (@relation.attributes - [@relation[:id]]) + [@relation[:id].as(:schmid)]
+      end
     end
-  end
   
-  describe '[]' do
-    it 'indexes attributes by rename' do
-      @renamed_relation[:id].should be_nil
-      @renamed_relation[:schmid].should == @relation[:id].as(:schmid)
+    describe '[]' do
+      it 'indexes attributes by rename' do
+        @renamed_relation[:id].should be_nil
+        @renamed_relation[:schmid].should == @relation[:id].as(:schmid)
+      end
     end
-  end
   
-  describe '#schmattribute' do
-    it "should be renamed" do
-      pending
+    describe '#schmattribute' do
+      it "should be renamed" do
+        pending
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the relation and renames" do
-      ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :schmid).qualify. \
-        should == ActiveRelation::Relations::Rename.new(@relation.qualify, @relation[:id].qualify => :schmid)
+    describe '#qualify' do
+      it "distributes over the relation and renames" do
+        Rename.new(@relation, @relation[:id] => :schmid).qualify. \
+          should == Rename.new(@relation.qualify, @relation[:id].qualify => :schmid)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it 'manufactures sql renameing the attribute' do
-      @renamed_relation.to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id` AS 'schmid'
-        FROM `foo`
-      """)
+    describe '#to_sql' do
+      it 'manufactures sql renameing the attribute' do
+        @renamed_relation.to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id` AS 'schmid'
+          FROM `foo`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/selection_spec.rb b/spec/active_relation/relations/selection_spec.rb
index 90dc3169b6..95d9e68625 100644
--- a/spec/active_relation/relations/selection_spec.rb
+++ b/spec/active_relation/relations/selection_spec.rb
@@ -1,42 +1,44 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Selection do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @predicate1 = ActiveRelation::Predicates::Equality.new(@relation1[:id], @relation2[:foo_id])
-    @predicate2 = ActiveRelation::Predicates::LessThan.new(@relation1[:age], 2)
-  end
-  
-  describe '#initialize' do
-    it "manufactures nested selection relations if multiple predicates are provided" do
-      ActiveRelation::Relations::Selection.new(@relation1, @predicate1, @predicate2). \
-        should == ActiveRelation::Relations::Selection.new(ActiveRelation::Relations::Selection.new(@relation1, @predicate2), @predicate1)
+module ActiveRelation
+  describe Selection do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @predicate1 = Equality.new(@relation1[:id], @relation2[:foo_id])
+      @predicate2 = LessThan.new(@relation1[:age], 2)
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the relation and predicates" do
-      ActiveRelation::Relations::Selection.new(@relation1, @predicate1).qualify. \
-        should == ActiveRelation::Relations::Selection.new(@relation1.qualify, @predicate1.qualify)
+    describe '#initialize' do
+      it "manufactures nested selection relations if multiple predicates are provided" do
+        Selection.new(@relation1, @predicate1, @predicate2). \
+          should == Selection.new(Selection.new(@relation1, @predicate2), @predicate1)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with where clause conditions" do
-      ActiveRelation::Relations::Selection.new(@relation1, @predicate1).to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        WHERE `foo`.`id` = `bar`.`foo_id`
-      """)
+    describe '#qualify' do
+      it "distributes over the relation and predicates" do
+        Selection.new(@relation1, @predicate1).qualify. \
+          should == Selection.new(@relation1.qualify, @predicate1.qualify)
+      end
     end
+  
+    describe '#to_sql' do
+      it "manufactures sql with where clause conditions" do
+        Selection.new(@relation1, @predicate1).to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          WHERE `foo`.`id` = `bar`.`foo_id`
+        """)
+      end
     
-    it "allows arbitrary sql" do
-      ActiveRelation::Relations::Selection.new(@relation1, "asdf").to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        WHERE asdf
-      """)
+      it "allows arbitrary sql" do
+        Selection.new(@relation1, "asdf").to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          WHERE asdf
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/table_spec.rb b/spec/active_relation/relations/table_spec.rb
index 1418ac203f..ec6e6e10bd 100644
--- a/spec/active_relation/relations/table_spec.rb
+++ b/spec/active_relation/relations/table_spec.rb
@@ -1,30 +1,32 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Table do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-  end
+module ActiveRelation
+  describe Table do
+    before do
+      @relation = Table.new(:users)
+    end
   
-  describe '#to_sql' do
-    it "manufactures a simple select query" do
-      @relation.to_sql.should be_like("""
-        SELECT `users`.`name`, `users`.`id`
-        FROM `users`
-      """)
+    describe '#to_sql' do
+      it "manufactures a simple select query" do
+        @relation.to_sql.should be_like("""
+          SELECT `users`.`name`, `users`.`id`
+          FROM `users`
+        """)
+      end
     end
-  end
   
-  describe '#attributes' do
-    it 'manufactures attributes corresponding to columns in the table' do
-      pending
+    describe '#attributes' do
+      it 'manufactures attributes corresponding to columns in the table' do
+        pending
+      end
     end
-  end
   
-  describe '#qualify' do
-    it 'manufactures a rename relation with all attribute names qualified' do
-      @relation.qualify.should == ActiveRelation::Relations::Rename.new(
-        ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => 'users.id'), @relation[:name] => 'users.name'
-      )
+    describe '#qualify' do
+      it 'manufactures a rename relation with all attribute names qualified' do
+        @relation.qualify.should == Rename.new(
+          Rename.new(@relation, @relation[:id] => 'users.id'), @relation[:name] => 'users.name'
+        )
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index e799aed339..ab9a14f3bd 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -9,7 +9,7 @@ ActiveRecord::Base.configurations = {
   'sql_algebra_test' => {
     :adapter  => 'mysql',
     :username => 'root',
-    :password => 'password',
+    :password => '',
     :encoding => 'utf8',
     :database => 'sql_algebra_test',
   },
@@ -26,8 +26,5 @@ end
 
 Spec::Runner.configure do |config|  
   config.include(BeLikeMatcher)
-  config.include(ActiveRelation::Relations)
-  config.include(ActiveRelation::Primitives)
-  config.include(ActiveRelation::Predicates)
   config.mock_with :rr
 end
\ No newline at end of file