arel 0.4.0 → 1.0.0.rc1

data/README.markdown

@@ -180,3 +180,27 @@ As you can see, we're completely missing data for user with id 3. `dumpty` has n
     FROM users
     LEFT OUTER JOIN (SELECT user_id, count(*) as cnt FROM photos GROUP BY user_id) AS photos_aggregation
       ON photos_aggregation.user_id = users.id
+
+## ActiveRecord Adapter Support
+
+Arel provides built-in support for the following ActiveRecord DB adapters:
+
+* IBM DB
+* MySQL
+* Oracle
+* PostgreSQL
+* SQLite
+
+You can add support for other adapters by defining a SQL compiler at the appropriate place.  Here's an example: let's say
+you've got a YourSQL adapter.  Create a file at `yoursql/arel_compiler.rb` somewhere on the load path (presumably in
+the YourSQL adapter gem).  The contents of that file can be as simple as:
+
+    module Arel
+      module SqlCompiler
+        class YourSQLCompiler < GenericCompiler
+        end
+      end
+    end
+
+Override any methods as necessary.  See examples at
+[lib/arel/engines/sql/compilers](http://github.com/rails/arel/tree/master/lib/arel/engines/sql/compilers/).

data/lib/arel.rb

@@ -1,10 +1,12 @@
 require 'active_support/inflector'
-require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
 
+require 'arel/recursion/base_case'
+
 module Arel
   require 'arel/algebra'
+  require 'arel/sql_literal'
   require 'arel/engines'
   require 'arel/version'
 

data/lib/arel/algebra/attributes/attribute.rb

@@ -3,14 +3,42 @@ require 'set'
 module Arel
   class TypecastError < StandardError ; end
   class Attribute
-    attributes :relation, :name, :alias, :ancestor
-    deriving :==
-    delegate :engine, :christener, :to => :relation
+    attr_reader :relation, :name, :alias, :ancestor, :hash
+    attr_reader :history
 
     def initialize(relation, name, options = {})
-      @relation, @name, @alias, @ancestor = relation, name, options[:alias], options[:ancestor]
+      @relation = relation # this is actually a table (I think)
+      @name     = name
+      @alias    = options[:alias]
+      @ancestor = options[:ancestor]
+      @history  = [self] + (@ancestor ? @ancestor.history : [])
+      @root = @history.last
+      @original_relation = nil
+      @original_attribute = nil
+
+      # FIXME: I think we can remove this eventually
+      @hash     = name.hash + root.relation.class.hash
     end
 
+    def engine
+      @relation.engine
+    end
+
+    def christener
+      @relation.christener
+    end
+
+    def == other
+      super ||
+        Attribute === other &&
+        @name      == other.name &&
+        @alias     == other.alias &&
+        @ancestor  == other.ancestor &&
+        @relation  == other.relation
+    end
+
+    alias :eql? :==
+
     def named?(hypothetical_name)
       (@alias || name).to_s == hypothetical_name.to_s
     end
@@ -19,190 +47,184 @@ module Arel
       false
     end
 
-    def inspect
-      "<Attribute #{name}>"
+    def eval(row)
+      row[self]
     end
 
-    module Transformations
-      def self.included(klass)
-        klass.send :alias_method, :eql?, :==
-      end
-
-      def hash
-        @hash ||= name.hash + root.relation.hash
-      end
+    def as(aliaz = nil)
+      Attribute.new(relation, name, :alias => aliaz, :ancestor => self)
+    end
 
-      def as(aliaz = nil)
-        Attribute.new(relation, name, :alias => aliaz, :ancestor => self)
-      end
+    def bind(new_relation)
+      relation == new_relation ? self : Attribute.new(new_relation, name, :alias => @alias, :ancestor => self)
+    end
 
-      def bind(new_relation)
-        relation == new_relation ? self : Attribute.new(new_relation, name, :alias => @alias, :ancestor => self)
-      end
+    def to_attribute(relation)
+      bind(relation)
+    end
 
-      def to_attribute(relation)
-        bind(relation)
-      end
+    def join?
+      relation.join?
     end
-    include Transformations
 
-    module Congruence
-      def history
-        @history ||= [self] + (ancestor ? ancestor.history : [])
-      end
+    def root
+      history.last
+    end
 
-      def join?
-        relation.join?
-      end
+    def original_relation
+      @original_relation ||= original_attribute.relation
+    end
 
-      def root
-        history.last
-      end
+    def original_attribute
+      @original_attribute ||= history.detect { |a| !a.join? }
+    end
 
-      def original_relation
-        @original_relation ||= original_attribute.relation
-      end
+    def find_correlate_in(relation)
+      relation[self] || self
+    end
 
-      def original_attribute
-        @original_attribute ||= history.detect { |a| !a.join? }
-      end
+    def descends_from?(other)
+      history.include?(other)
+    end
 
-      def find_correlate_in(relation)
-        relation[self] || self
-      end
+    def /(other)
+      other ? (history & other.history).size : 0
+    end
 
-      def descends_from?(other)
-        history.include?(other)
-      end
+    PREDICATES = [
+      :eq, :eq_any, :eq_all, :not_eq, :not_eq_any, :not_eq_all, :lt, :lt_any,
+      :lt_all, :lteq, :lteq_any, :lteq_all, :gt, :gt_any, :gt_all, :gteq,
+      :gteq_any, :gteq_all, :matches, :matches_any, :matches_all, :not_matches,
+      :not_matches_any, :not_matches_all, :in, :in_any, :in_all, :not_in,
+      :not_in_any, :not_in_all
+    ]
 
-      def /(other)
-        other ? (history & other.history).size : 0
+    Predications = Class.new do
+      def self.instance_methods *args
+        warn "this module is deprecated, please use the PREDICATES constant"
+        PREDICATES
       end
     end
-    include Congruence
 
-    module Predications
-      def eq(other)
-        Predicates::Equality.new(self, other)
-      end
+    def eq(other)
+      Predicates::Equality.new(self, other)
+    end
 
-      def eq_any(*others)
-        Predicates::Any.build(Predicates::Equality, self, *others)
-      end
+    def eq_any(*others)
+      Predicates::Any.build(Predicates::Equality, self, *others)
+    end
 
-      def eq_all(*others)
-        Predicates::All.build(Predicates::Equality, self, *others)
-      end
+    def eq_all(*others)
+      Predicates::All.build(Predicates::Equality, self, *others)
+    end
 
-      def not_eq(other)
-        Predicates::Inequality.new(self, other)
-      end
+    def not_eq(other)
+      Predicates::Inequality.new(self, other)
+    end
 
-      def not_eq_any(*others)
-        Predicates::Any.build(Predicates::Inequality, self, *others)
-      end
+    def not_eq_any(*others)
+      Predicates::Any.build(Predicates::Inequality, self, *others)
+    end
 
-      def not_eq_all(*others)
-        Predicates::All.build(Predicates::Inequality, self, *others)
-      end
+    def not_eq_all(*others)
+      Predicates::All.build(Predicates::Inequality, self, *others)
+    end
 
-      def lt(other)
-        Predicates::LessThan.new(self, other)
-      end
+    def lt(other)
+      Predicates::LessThan.new(self, other)
+    end
 
-      def lt_any(*others)
-        Predicates::Any.build(Predicates::LessThan, self, *others)
-      end
+    def lt_any(*others)
+      Predicates::Any.build(Predicates::LessThan, self, *others)
+    end
 
-      def lt_all(*others)
-        Predicates::All.build(Predicates::LessThan, self, *others)
-      end
+    def lt_all(*others)
+      Predicates::All.build(Predicates::LessThan, self, *others)
+    end
 
-      def lteq(other)
-        Predicates::LessThanOrEqualTo.new(self, other)
-      end
+    def lteq(other)
+      Predicates::LessThanOrEqualTo.new(self, other)
+    end
 
-      def lteq_any(*others)
-        Predicates::Any.build(Predicates::LessThanOrEqualTo, self, *others)
-      end
+    def lteq_any(*others)
+      Predicates::Any.build(Predicates::LessThanOrEqualTo, self, *others)
+    end
 
-      def lteq_all(*others)
-        Predicates::All.build(Predicates::LessThanOrEqualTo, self, *others)
-      end
+    def lteq_all(*others)
+      Predicates::All.build(Predicates::LessThanOrEqualTo, self, *others)
+    end
 
-      def gt(other)
-        Predicates::GreaterThan.new(self, other)
-      end
+    def gt(other)
+      Predicates::GreaterThan.new(self, other)
+    end
 
-      def gt_any(*others)
-        Predicates::Any.build(Predicates::GreaterThan, self, *others)
-      end
+    def gt_any(*others)
+      Predicates::Any.build(Predicates::GreaterThan, self, *others)
+    end
 
-      def gt_all(*others)
-        Predicates::All.build(Predicates::GreaterThan, self, *others)
-      end
+    def gt_all(*others)
+      Predicates::All.build(Predicates::GreaterThan, self, *others)
+    end
 
-      def gteq(other)
-        Predicates::GreaterThanOrEqualTo.new(self, other)
-      end
+    def gteq(other)
+      Predicates::GreaterThanOrEqualTo.new(self, other)
+    end
 
-      def gteq_any(*others)
-        Predicates::Any.build(Predicates::GreaterThanOrEqualTo, self, *others)
-      end
+    def gteq_any(*others)
+      Predicates::Any.build(Predicates::GreaterThanOrEqualTo, self, *others)
+    end
 
-      def gteq_all(*others)
-        Predicates::All.build(Predicates::GreaterThanOrEqualTo, self, *others)
-      end
+    def gteq_all(*others)
+      Predicates::All.build(Predicates::GreaterThanOrEqualTo, self, *others)
+    end
 
-      def matches(other)
-        Predicates::Match.new(self, other)
-      end
+    def matches(other)
+      Predicates::Match.new(self, other)
+    end
 
-      def matches_any(*others)
-        Predicates::Any.build(Predicates::Match, self, *others)
-      end
+    def matches_any(*others)
+      Predicates::Any.build(Predicates::Match, self, *others)
+    end
 
-      def matches_all(*others)
-        Predicates::All.build(Predicates::Match, self, *others)
-      end
+    def matches_all(*others)
+      Predicates::All.build(Predicates::Match, self, *others)
+    end
 
-      def not_matches(other)
-        Predicates::NotMatch.new(self, other)
-      end
+    def not_matches(other)
+      Predicates::NotMatch.new(self, other)
+    end
 
-      def not_matches_any(*others)
-        Predicates::Any.build(Predicates::NotMatch, self, *others)
-      end
+    def not_matches_any(*others)
+      Predicates::Any.build(Predicates::NotMatch, self, *others)
+    end
 
-      def not_matches_all(*others)
-        Predicates::All.build(Predicates::NotMatch, self, *others)
-      end
+    def not_matches_all(*others)
+      Predicates::All.build(Predicates::NotMatch, self, *others)
+    end
 
-      def in(other)
-        Predicates::In.new(self, other)
-      end
+    def in(other)
+      Predicates::In.new(self, other)
+    end
 
-      def in_any(*others)
-        Predicates::Any.build(Predicates::In, self, *others)
-      end
+    def in_any(*others)
+      Predicates::Any.build(Predicates::In, self, *others)
+    end
 
-      def in_all(*others)
-        Predicates::All.build(Predicates::In, self, *others)
-      end
+    def in_all(*others)
+      Predicates::All.build(Predicates::In, self, *others)
+    end
 
-      def not_in(other)
-        Predicates::NotIn.new(self, other)
-      end
+    def not_in(other)
+      Predicates::NotIn.new(self, other)
+    end
 
-      def not_in_any(*others)
-        Predicates::Any.build(Predicates::NotIn, self, *others)
-      end
+    def not_in_any(*others)
+      Predicates::Any.build(Predicates::NotIn, self, *others)
+    end
 
-      def not_in_all(*others)
-        Predicates::All.build(Predicates::NotIn, self, *others)
-      end
+    def not_in_all(*others)
+      Predicates::All.build(Predicates::NotIn, self, *others)
     end
-    include Predications
 
     module Expressions
       def count(distinct = false)
@@ -266,5 +288,17 @@ module Arel
       end
     end
     include Types
+
+    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
 end

data/lib/arel/algebra/core_extensions.rb

@@ -1,4 +1,3 @@
 require 'arel/algebra/core_extensions/object'
-require 'arel/algebra/core_extensions/class'
 require 'arel/algebra/core_extensions/symbol'
 require 'arel/algebra/core_extensions/hash'

data/lib/arel/algebra/core_extensions/hash.rb

@@ -1,11 +1,7 @@
-module Arel
-  module HashExtensions
-    def bind(relation)
-      inject({}) do |bound, (key, value)|
-        bound.merge(key.bind(relation) => value.bind(relation))
-      end
-    end
-
-    Hash.send(:include, self)
+class Hash
+  def bind(relation)
+    Hash[map { |key, value|
+      [key.bind(relation), value.bind(relation)]
+    }]
   end
 end