arel 0.4.0 → 1.0.0.rc1

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

@@ -1,17 +1,20 @@
 module Arel
   class Row
-    attributes :relation, :tuple
-    deriving :==, :initialize
+    attr_reader :tuple, :relation
+
+    def initialize relation, tuple
+      @relation = relation
+      @tuple = tuple
+    end
 
     def [](attribute)
       attribute.type_cast(tuple[relation.position_of(attribute)])
     end
 
     def slice(*attributes)
-      Row.new(relation, attributes.inject([]) do |cheese, attribute|
+      Row.new(relation, attributes.map do |attribute|
         # FIXME TESTME method chaining
-        cheese << tuple[relation.relation.position_of(attribute)]
-        cheese
+        tuple[relation.relation.position_of(attribute)]
       end)
     end
 

data/lib/arel/algebra/relations/utilities/compound.rb

@@ -2,15 +2,38 @@ module Arel
   class Compound
     include Relation
 
-    attr_reader :relation
-    delegate :joins, :join?, :inserts, :taken, :skipped, :name, :externalizable?,
-             :column_for, :engine, :sources, :locked, :table_alias,
-             :to => :relation
-
-    def self.requires(feature = nil)
-      @requires ||= nil
-      @requires = feature if feature
-      @requires
+    attr_reader :relation, :engine
+
+    def initialize relation
+      @relation    = relation
+      @engine      = relation.engine
+      @attributes  = nil
+      @wheres      = nil
+      @groupings   = nil
+      @orders      = nil
+      @havings     = nil
+      @projections = nil
+    end
+
+    def join?;           @relation.join?           end
+    def name;            @relation.name            end
+    def table_alias;     @relation.table_alias     end
+    def skipped;         @relation.skipped         end
+    def taken;           @relation.taken           end
+    def joins env;       @relation.joins env       end
+    def column_for attr; @relation.column_for attr end
+    def externalizable?; @relation.externalizable? end
+
+    def sources
+      @relation.sources
+    end
+
+    def table
+      @relation.table
+    end
+
+    def table_sql(formatter = Sql::TableReference.new(self))
+      @relation.table_sql formatter
     end
 
     [:wheres, :groupings, :orders, :havings, :projections].each do |operation_name|
@@ -25,30 +48,8 @@ module Arel
       @attributes ||= relation.attributes.bind(self)
     end
 
-    def hash
-      @hash ||= :relation.hash
-    end
-
-    def eql?(other)
-      self == other
-    end
-
-    def engine
-      requires = self.class.requires
-      engine   = relation.engine
-
-      # Temporary check of whether or not the engine supports where.
-      if requires && engine.respond_to?(:supports) && !engine.supports(requires)
-        Memory::Engine.new
-      else
-        engine
-      end
-    end
-
-  private
-
-    def arguments_from_block(relation, &block)
-      block_given?? [yield(relation)] : []
+    def unoperated_rows
+      relation.call.collect { |row| row.bind(self) }
     end
   end
 end

data/lib/arel/algebra/relations/utilities/externalization.rb

@@ -1,7 +1,10 @@
 module Arel
   class Externalization < Compound
-    attributes :relation
-    deriving :initialize, :==
+    include Recursion::BaseCase
+
+    def == other
+      super || Externalization === other && relation == other.relation
+    end
 
     def wheres
       []
@@ -10,15 +13,14 @@ module Arel
     def attributes
       @attributes ||= Header.new(relation.attributes.map { |a| a.to_attribute(self) })
     end
-  end
 
-  module Relation
-    def externalize
-      @externalized ||= externalizable?? Externalization.new(self) : self
+    def table_sql(formatter = Sql::TableReference.new(relation))
+      formatter.select relation.compiler.select_sql, self
     end
 
-    def externalizable?
-      false
+    # REMOVEME
+    def name
+      relation.name + '_external'
     end
   end
 end

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

@@ -1,36 +1,47 @@
 module Arel
-  class Deletion < Compound
-    attributes :relation
-    deriving :initialize, :==
+  class Action < Compound
+  end
 
+  class Deletion < Action
     def call
       engine.delete(self)
     end
+
+    def to_sql
+      compiler.delete_sql
+    end
   end
 
-  class Insert < Compound
-    attributes :relation, :record
-    deriving :==
+  class Insert < Action
+    attr_reader :record
 
     def initialize(relation, record)
-      @relation, @record = relation, record.bind(relation)
+      super(relation)
+      @record = record.bind(relation)
     end
 
     def call
       engine.create(self)
     end
-  end
 
-  class Update < Compound
-    attributes :relation, :assignments
-    deriving :==
+    def eval
+      unoperated_rows + [Row.new(self, record.values.collect(&:value))]
+    end
 
-    def initialize(relation, assignments)
-      @relation, @assignments = relation, assignments.bind(relation)
+    def to_sql(include_returning = true)
+      compiler.insert_sql(include_returning)
     end
+  end
+
+  class Update < Insert
+    alias :assignments :record
 
     def call
       engine.update(self)
     end
+
+    def to_sql
+      compiler.update_sql
+    end
   end
 end

data/lib/arel/algebra/value.rb

@@ -1,7 +1,22 @@
 module Arel
   class Value
-    attributes :value, :relation
-    deriving :initialize, :==
+    attr_reader :value, :relation
+
+    def initialize value, relation
+      @value = value
+      @relation = relation
+    end
+
+    def == other
+      super ||
+        Value === other &&
+        value == other.value &&
+        relation == other.relation
+    end
+
+    def eval(row)
+      value
+    end
 
     def bind(relation)
       Value.new(value, relation)
@@ -10,5 +25,29 @@ module Arel
     def to_ordering
       self
     end
+
+    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
 end

data/lib/arel/engines/memory.rb

@@ -1,4 +1,2 @@
 require 'arel/engines/memory/relations'
-require 'arel/engines/memory/primitives'
 require 'arel/engines/memory/engine'
-require 'arel/engines/memory/predicates'

data/lib/arel/engines/memory/engine.rb

@@ -1,16 +1,10 @@
 module Arel
   module Memory
     class Engine
-      module CRUD
-        def read(relation)
-          relation.eval
-        end
-
-        def create(relation)
-          relation.eval
-        end
+      def read(relation)
+        relation.eval
       end
-      include CRUD
+      alias :create :read
     end
   end
 end

data/lib/arel/engines/memory/relations.rb

@@ -1,5 +1,2 @@
 require 'arel/engines/memory/relations/array'
 require 'arel/engines/memory/relations/operations'
-require 'arel/engines/memory/relations/writes'
-require 'arel/engines/memory/relations/compound'
-

data/lib/arel/engines/memory/relations/array.rb

@@ -2,12 +2,14 @@ module Arel
   class Array
     include Relation
 
-    attributes :array,  :attribute_names_and_types
+    attr_reader :array, :attribute_names_and_types
     include Recursion::BaseCase
-    deriving :==, :initialize
 
     def initialize(array, attribute_names_and_types)
-      @array, @attribute_names_and_types = array, attribute_names_and_types
+      @array                     = array
+      @attribute_names_and_types = attribute_names_and_types
+      @engine                    = nil
+      @attributes                = nil
     end
 
     def engine

data/lib/arel/engines/memory/relations/operations.rb

@@ -1,67 +1,9 @@
 module Arel
-  class Where < Compound
-    def eval
-      unoperated_rows.select { |row| predicates.all? { |p| p.eval(row) } }
-    end
-  end
-
-  class Order < Compound
-    def eval
-      unoperated_rows.sort do |row1, row2|
-        ordering = orders.detect { |o| o.eval(row1, row2) != 0 } || orders.last
-        ordering.eval(row1, row2)
-      end
-    end
-  end
-
-  class Project < Compound
-    def eval
-      unoperated_rows.collect { |r| r.slice(*projections) }
-    end
-  end
-
-  class Take < Compound
-    def eval
-      unoperated_rows[0, taken]
-    end
-  end
-
-  class Skip < Compound
-    def eval
-      unoperated_rows[skipped..-1]
-    end
-  end
-
-  class From < Compound
-    def eval
-      unoperated_rows[sources..-1]
-    end
-  end
-
-  class Group < Compound
-    def eval
-      raise NotImplementedError
-    end
-  end
-
   class Alias < Compound
-    def eval
-      unoperated_rows
-    end
-  end
+    include Recursion::BaseCase
 
-  class Join
     def eval
-      result = []
-      relation1.call.each do |row1|
-        relation2.call.each do |row2|
-          combined_row = row1.combine(row2, self)
-          if predicates.all? { |p| p.eval(combined_row) }
-            result << combined_row
-          end
-        end
-      end
-      result
+      unoperated_rows
     end
   end
 end

data/lib/arel/engines/sql.rb

@@ -1,8 +1,6 @@
 require 'arel/engines/sql/attributes'
 require 'arel/engines/sql/engine'
 require 'arel/engines/sql/relations'
-require 'arel/engines/sql/primitives'
-require 'arel/engines/sql/predicates'
 require 'arel/engines/sql/formatters'
 require 'arel/engines/sql/core_extensions'
 require 'arel/engines/sql/christener'

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

@@ -1,13 +1,19 @@
 module Arel
   module Sql
     class Christener
+      def initialize
+        @names = {}
+      end
+
       def name_for(relation)
-        @used_names ||= Hash.new(0)
-        (@relation_names ||= Hash.new do |hash, relation|
-          name =  relation.table_alias ? relation.table_alias : relation.name
-          @used_names[name] += 1
-          hash[relation] = name + (@used_names[name] > 1 ? "_#{@used_names[name]}" : '')
-        end)[relation.table]
+        table = relation.table
+        name = table.table_alias || table.name
+        list = @names[name] ||= []
+
+        list << table unless list.include? table
+
+        idx = list.index table
+        name + (idx == 0 ? '' : "_#{idx + 1}")
       end
     end
   end

data/lib/arel/engines/sql/compilers/oracle_compiler.rb

@@ -3,12 +3,20 @@ module Arel
     class OracleCompiler < GenericCompiler
 
       def select_sql
-        where_clauses_array = where_clauses
+        select_clauses = relation.select_clauses
+        from_clauses = relation.from_clauses
+        joins = relation.joins(self)
+        where_clauses = relation.where_clauses
+        order_clauses = relation.order_clauses
+        group_clauses = relation.group_clauses
+        having_clauses = relation.having_clauses
+        taken = relation.taken
+        skipped = relation.skipped
         if limit_or_offset = !taken.blank? || !skipped.blank?
-          # if need to select first records without ORDER BY and GROUP BY
+          # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
           # then can use simple ROWNUM in WHERE clause
-          if skipped.blank? && groupings.blank? && orders.blank?
-            where_clauses_array << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && groupings.blank? && orders.blank?
+          if skipped.blank? && group_clauses.blank? && order_clauses.blank? && select_clauses[0] !~ /^DISTINCT /
+            where_clauses << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && group_clauses.blank? && order_clauses.blank?
             limit_or_offset = false
           end
         end
@@ -16,13 +24,13 @@ module Arel
         # when limit or offset subquery is used then cannot use FOR UPDATE directly
         # and need to construct separate subquery for primary key
         if use_subquery_for_lock = limit_or_offset && !locked.blank?
-          quoted_primary_key = engine.quote_column_name(primary_key)
+          quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
         end
         select_attributes_string = use_subquery_for_lock ? quoted_primary_key : select_clauses.join(', ')
 
         # OracleEnhanced adapter workaround when ORDER BY is used with columns not
         # present in DISTINCT columns list
-        order_clauses_array = if select_attributes_string =~ /DISTINCT.*FIRST_VALUE/ && !orders.blank?
+        order_clauses_array = if select_attributes_string =~ /DISTINCT.*FIRST_VALUE/ && !order_clauses.blank?
           order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
           order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{'DESC' if s =~ /\bdesc$/i}" }
         else
@@ -32,14 +40,14 @@ module Arel
         query = build_query \
           "SELECT     #{select_attributes_string}",
           "FROM       #{from_clauses}",
-          (joins(self)                                   unless joins(self).blank? ),
-          ("WHERE     #{where_clauses_array.join(" AND ")}"    unless where_clauses_array.blank?      ),
-          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
-          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
+          (joins                                         unless joins.blank?               ),
+          ("WHERE     #{where_clauses.join(' AND ')}"    unless where_clauses.blank?       ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless group_clauses.blank?       ),
+          ("HAVING    #{having_clauses.join(' AND ')}"   unless having_clauses.blank?      ),
           ("ORDER BY  #{order_clauses_array.join(', ')}" unless order_clauses_array.blank? )
 
         # Use existing method from oracle_enhanced adapter to implement limit and offset using subqueries
-        engine.add_limit_offset!(query, :limit => taken, :offset => skipped) if limit_or_offset
+        engine.connection.add_limit_offset!(query, :limit => taken, :offset => skipped) if limit_or_offset
 
         if use_subquery_for_lock
           build_query \
@@ -55,25 +63,27 @@ module Arel
       end
 
       def delete_sql
-        where_clauses_array = wheres.collect(&:to_sql)
-        where_clauses_array << "ROWNUM <= #{taken}" unless taken.blank?
+        where_clauses = relation.wheres.collect(&:to_sql)
+        taken = relation.taken
+        where_clauses << "ROWNUM <= #{taken}" unless taken.blank?
         build_query \
           "DELETE",
-          "FROM #{table_sql}",
-          ("WHERE #{where_clauses_array.join(' AND ')}" unless where_clauses_array.blank? )
+          "FROM #{relation.table_sql}",
+          ("WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank? )
       end
 
     protected
 
       def build_update_conditions_sql
         conditions = ""
-        where_clauses_array = wheres.collect(&:to_sql)
+        where_clauses = relation.wheres.collect(&:to_sql)
+        taken = relation.taken
         # if need to select first records without ORDER BY
         # then can use simple ROWNUM in WHERE clause
-        if !taken.blank? && orders.blank?
-          where_clauses_array << "ROWNUM <= #{taken}"
+        if !taken.blank? && relation.orders.blank?
+          where_clauses << "ROWNUM <= #{taken}"
         end
-        conditions << " WHERE #{where_clauses_array.join(' AND ')}" unless where_clauses_array.blank?
+        conditions << " WHERE #{where_clauses.join(' AND ')}" unless where_clauses.blank?
         unless taken.blank?
           conditions = limited_update_conditions(conditions, taken)
         end
@@ -81,12 +91,13 @@ module Arel
       end
 
       def limited_update_conditions(conditions, taken)
+        order_clauses = relation.order_clauses
         # need to add ORDER BY only if just taken ones should be updated
-        conditions << " ORDER BY #{order_clauses.join(', ')}" unless orders.blank?
-        quoted_primary_key = engine.quote_column_name(primary_key)
-        subquery = "SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions}"
+        conditions << " ORDER BY #{order_clauses.join(', ')}" unless order_clauses.blank?
+        quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
+        subquery = "SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name relation.table.name} #{conditions}"
         # Use existing method from oracle_enhanced adapter to get taken records when ORDER BY is used
-        engine.add_limit_offset!(subquery, :limit => taken) unless orders.blank?
+        engine.connection.add_limit_offset!(subquery, :limit => taken) unless order_clauses.blank?
         "WHERE #{quoted_primary_key} IN (#{subquery})"
       end