arel 0.4.0 → 1.0.0.rc1

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

@@ -1,97 +0,0 @@
-module Arel
-  class SqlLiteral < String
-    def relation
-      nil
-    end
-
-    def to_sql(formatter = nil)
-      self
-    end
-
-    include Attribute::Expressions
-  end
-
-  class Attribute
-    def column
-      original_relation.column_for(self)
-    end
-
-    def format(object)
-      object.to_sql(Sql::Attribute.new(self))
-    end
-
-    def to_sql(formatter = Sql::WhereCondition.new(relation))
-      formatter.attribute self
-    end
-  end
-
-  class Value
-    def inclusion_predicate_sql
-      value.inclusion_predicate_sql
-    end
-
-    def exclusion_predicate_sql
-      value.exclusion_predicate_sql
-    end
-
-    def equality_predicate_sql
-      value.equality_predicate_sql
-    end
-
-    def inequality_predicate_sql
-      value.inequality_predicate_sql
-    end
-
-    def to_sql(formatter = Sql::WhereCondition.new(relation))
-      formatter.value value
-    end
-
-    def format(object)
-      object.to_sql(Sql::Value.new(relation))
-    end
-  end
-
-  class Ordering
-    def to_sql(formatter = Sql::OrderClause.new(relation))
-      formatter.ordering self
-    end
-  end
-
-  class Ascending < Ordering
-    def direction_sql; 'ASC' end
-  end
-
-  class Descending < Ordering
-    def direction_sql; 'DESC' end
-  end
-
-  class Expression < Attribute
-    def to_sql(formatter = Sql::SelectClause.new(relation))
-      formatter.expression self
-    end
-  end
-
-  class Count < Expression
-    def function_sql; 'COUNT' end
-  end
-
-  class Distinct < Expression
-    def function_sql; 'DISTINCT' end
-  end
-
-  class Sum < Expression
-    def function_sql; 'SUM' end
-  end
-
-  class Maximum < Expression
-    def function_sql; 'MAX' end
-  end
-
-  class Minimum < Expression
-    def function_sql; 'MIN' end
-  end
-
-  class Average < Expression
-    def function_sql; 'AVG' end
-  end
-end

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

@@ -1,5 +0,0 @@
-module Arel
-  class Alias < Compound
-    include Recursion::BaseCase
-  end
-end

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

@@ -1,33 +0,0 @@
-module Arel
-  class Join
-    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
-  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
-  end
-end

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

@@ -1,65 +0,0 @@
-module Arel
-  module Relation
-    @@connection_tables_primary_keys = {}
-
-    def compiler
-      @compiler ||=  begin
-        "Arel::SqlCompiler::#{engine.adapter_name}Compiler".constantize.new(self)
-      rescue
-        Arel::SqlCompiler::GenericCompiler.new(self)
-      end
-    end
-
-    def to_sql(formatter = Sql::SelectStatement.new(self))
-      formatter.select compiler.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
-
-    protected
-
-      def from_clauses
-        sources.blank? ? table_sql(Sql::TableReference.new(self)) : sources
-      end
-
-      def select_clauses
-        attributes.collect { |a| a.to_sql(Sql::SelectClause.new(self)) }
-      end
-
-      def where_clauses
-        wheres.collect { |w| w.to_sql(Sql::WhereClause.new(self)) }
-      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
-  end
-end

data/lib/arel/engines/sql/relations/utilities/compound.rb

@@ -1,10 +0,0 @@
-module Arel
-  class Compound
-    delegate :table, :table_sql, :to => :relation
-
-    def build_query(*parts)
-      parts.compact.join(" ")
-    end
-  end
-end
-

data/lib/arel/engines/sql/relations/utilities/externalization.rb

@@ -1,14 +0,0 @@
-module Arel
-  class Externalization < Compound
-    include Recursion::BaseCase
-
-    def table_sql(formatter = Sql::TableReference.new(relation))
-      formatter.select relation.compiler.select_sql, self
-    end
-
-    # REMOVEME
-    def name
-      relation.name + '_external'
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Arel
-  class Deletion < Compound
-    def to_sql
-      compiler.delete_sql
-    end
-  end
-
-  class Insert < Compound
-    def to_sql(include_returning = true)
-      compiler.insert_sql(include_returning)
-    end
-  end
-
-  class Update < Compound
-    def to_sql
-      compiler.update_sql
-    end
-  end
-end