arel 0.1.0

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

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

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

@@ -0,0 +1,85 @@
+module Arel
+  class SqlLiteral < String
+    def relation
+      nil
+    end
+    
+    def to_sql(formatter = nil)
+      self
+    end
+  end
+
+  class Attribute
+    def column
+      original_relation.column_for(self)
+    end
+
+    def type_cast(value)
+      root.relation.format(self, value)
+    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
+    delegate :inclusion_predicate_sql, :equality_predicate_sql, :to => :value
+
+    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.rb

@@ -0,0 +1,9 @@
+require 'arel/engines/sql/relations/utilities/compound'
+require 'arel/engines/sql/relations/utilities/recursion'
+require 'arel/engines/sql/relations/utilities/externalization'
+require 'arel/engines/sql/relations/utilities/nil'
+require 'arel/engines/sql/relations/relation'
+require 'arel/engines/sql/relations/table'
+require 'arel/engines/sql/relations/operations/join'
+require 'arel/engines/sql/relations/operations/alias'
+require 'arel/engines/sql/relations/writes'

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

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

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

@@ -0,0 +1,33 @@
+module Arel
+  class Join < Relation
+    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).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(_, __ = nil)
+      relation2
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Arel
+  class Relation
+    def to_sql(formatter = Sql::SelectStatement.new(self))
+      formatter.select select_sql, self
+    end
+
+    def select_sql
+      build_query \
+        "SELECT     #{select_clauses.join(', ')}",
+        "FROM       #{table_sql(Sql::TableReference.new(self))}",
+        (joins(self)                                   unless joins(self).blank? ),
+        ("WHERE     #{where_clauses.join("\n\tAND ")}" unless wheres.blank?      ),
+        ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+        ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      ),
+        ("LIMIT     #{taken}"                          unless taken.blank?       ),
+        ("OFFSET    #{skipped}"                        unless skipped.blank?     )
+    end
+
+    def inclusion_predicate_sql
+      "IN"
+    end
+
+    def christener
+      @christener ||= Sql::Christener.new
+    end
+
+  protected
+
+    def build_query(*parts)
+      parts.compact.join("\n")
+    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 order_clauses
+      orders.collect { |o| o.to_sql(Sql::OrderClause.new(self)) }
+    end
+
+  end
+end

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

@@ -0,0 +1,52 @@
+module Arel
+  class Table < Relation
+    include Recursion::BaseCase
+
+    cattr_accessor :engine
+    attr_reader :name, :engine
+
+    def initialize(name, engine = Table.engine)
+      @name, @engine = name.to_s, engine
+    end
+
+    def attributes
+      @attributes ||= columns.collect do |column|
+        Attribute.new(self, column.name.to_sym)
+      end
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      @hash ||= :name.hash
+    end
+
+    def format(attribute, value)
+      attribute.column.type_cast(value)
+    end
+
+    def column_for(attribute)
+      has_attribute?(attribute) and columns.detect { |c| c.name == attribute.name.to_s }
+    end
+
+    def columns
+      @columns ||= engine.columns(name, "#{name} Columns")
+    end
+
+    def reset
+      @attributes = @columns = nil
+    end
+
+    def ==(other)
+      Table      === other and
+      name       ==  other.name
+    end
+  end
+end
+
+def Table(name, engine = Arel::Table.engine)
+  Arel::Table.new(name, engine)
+end
+

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

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

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

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

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

@@ -0,0 +1,6 @@
+module Arel
+  class Nil < Relation
+    def table_sql(formatter = nil); '' end
+    def name; '' end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Arel
+  module Recursion
+    module BaseCase
+      def table
+        self
+      end
+
+      def table_sql(formatter = Sql::TableReference.new(self))
+        formatter.table self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Arel
+  class Deletion < Compound
+    def to_sql(formatter = nil)
+      build_query \
+        "DELETE",
+        "FROM #{table_sql}",
+        ("WHERE #{wheres.collect(&:to_sql).join('\n\tAND ')}" unless wheres.blank? ),
+        ("LIMIT #{taken}"                                     unless taken.blank?  )
+    end
+  end
+
+  class Insert < Compound
+    def to_sql(formatter = nil)
+      build_query \
+        "INSERT",
+        "INTO #{table_sql}",
+        "(#{record.keys.collect { |key| engine.quote_column_name(key.name) }.join(', ')})",
+        "VALUES (#{record.collect { |key, value| key.format(value) }.join(', ')})"
+    end
+  end
+
+  class Update < Compound
+    def to_sql(formatter = nil)
+      build_query \
+        "UPDATE #{table_sql} SET",
+        assignment_sql,
+        ("WHERE #{wheres.collect(&:to_sql).join('\n\tAND ')}"  unless wheres.blank? ),
+        ("LIMIT #{taken}"                                      unless taken.blank?  )
+    end
+
+  protected
+
+    def assignment_sql
+      assignments.collect do |attribute, value|
+        "#{engine.quote_column_name(attribute.name)} = #{attribute.format(value)}"
+      end.join(",\n")
+    end
+  end
+end

data/lib/arel/session.rb

@@ -0,0 +1,48 @@
+module Arel
+  class Session
+    class << self
+      attr_accessor :instance
+      alias_method :manufacture, :new
+
+      def start
+        if @started
+          yield
+        else
+          begin
+            @started = true
+            @instance = manufacture
+            metaclass.send :alias_method, :new, :instance
+            yield
+          ensure
+            metaclass.send :alias_method, :new, :manufacture
+            @started = false
+          end
+        end
+      end
+    end
+
+    module CRUD
+      def create(insert)
+        insert.call
+        insert
+      end
+
+      def read(select)
+        (@read ||= Hash.new do |hash, select|
+          hash[select] = select.call
+        end)[select]
+      end
+
+      def update(update)
+        update.call
+        update
+      end
+
+      def delete(delete)
+        delete.call
+        delete
+      end
+    end
+    include CRUD
+  end
+end

data/spec/arel/algebra/unit/predicates/binary_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper')
+
+module Arel
+  describe Binary do
+    before do
+      @relation = Table.new(:users)
+      @attribute1 = @relation[:id]
+      @attribute2 = @relation[:name]
+      class ConcreteBinary < Binary
+      end
+    end
+
+    describe '#bind' do
+      before do
+        @another_relation = @relation.alias
+      end
+
+      describe 'when both operands are attributes' do
+        it "manufactures an expression with the attributes bound to the relation" do
+          ConcreteBinary.new(@attribute1, @attribute2).bind(@another_relation). \
+            should == ConcreteBinary.new(@another_relation[@attribute1], @another_relation[@attribute2])
+        end
+      end
+
+      describe 'when an operand is a value' do
+        it "manufactures an expression with unmodified values" do
+          ConcreteBinary.new(@attribute1, "asdf").bind(@another_relation). \
+            should == ConcreteBinary.new(@attribute1.find_correlate_in(@another_relation), "asdf".find_correlate_in(@another_relation))
+        end
+      end
+    end
+  end
+end