[Rails3] Arel compatibility for current rails/arel. Added gem path so we can test against in development Arel. Numerous updates to the compiler for recent performance changes.

Author: metaskills

Gemfile

@@ -1,6 +1,8 @@
 source :rubygems
 
 gemspec :path => ENV['RAILS_SOURCE']
+gem 'arel', :path => ENV['AREL'] if ENV['AREL']
+
 
 group :development do
   gem 'rake', '>= 0.8.7'

lib/arel/engines/sql/compilers/sqlserver_compiler.rb

@@ -1,8 +1,8 @@
 module Arel
   class Lock < Compound
-    def initialize(relation, locked, &block)
-      @relation = relation
-      @locked   = locked.blank? ? "WITH(HOLDLOCK, ROWLOCK)" : locked
+    def initialize(relation, locked)
+      super(relation)
+      @locked = true == locked ? "WITH(HOLDLOCK, ROWLOCK)" : locked
     end
   end
 end
@@ -12,88 +12,94 @@ module SqlCompiler
     class SQLServerCompiler < GenericCompiler
 
       def select_sql
-        skipped ? select_sql_with_skipped : select_sql_without_skipped
+        relation.skipped ? select_sql_with_skipped : select_sql_without_skipped
       end
 
       def delete_sql
         build_query \
-          "DELETE #{taken_clause if taken.present?}".strip,
-          "FROM #{table_sql}",
-          ("WHERE #{wheres.collect(&:to_sql).join(' AND ')}" unless wheres.blank? )
+          "DELETE #{taken_clause if relation.taken.present?}".strip,
+          "FROM #{relation.table_sql}",
+          ("WHERE #{relation.wheres.collect(&:to_sql).join(' AND ')}" unless relation.wheres.blank? )
       end
 
 
       protected
 
       def taken_only?
-        taken.present? && skipped.blank?
+        relation.taken.present? && relation.skipped.blank?
       end
 
       def taken_clause
-        "TOP (#{taken.to_i}) "
+        "TOP (#{relation.taken.to_i}) "
       end
 
       def single_distinct_select?
-        select_clauses.size == 1 && select_clauses.first.include?('DISTINCT')
+        relation.select_clauses.size == 1 && relation.select_clauses.first.include?('DISTINCT')
       end
 
       def select_sql_without_skipped(windowed=false)
-        select_clause = windowed ? select_clauses.map{ |sc| bare_select_clause(sc) }.join(', ') : 
-          "SELECT #{taken_clause if taken_only?}#{select_clauses.join(', ')}"
+        joins   = relation.joins(self)
+        wheres  = relation.where_clauses
+        groups  = relation.group_clauses
+        havings = relation.having_clauses
+        orders  = relation.order_clauses
+        select_clause = windowed ? relation.select_clauses.map{ |sc| bare_select_clause(sc) }.join(', ') : 
+          "SELECT #{taken_clause if taken_only?}#{relation.select_clauses.join(', ')}"
         build_query(
           select_clause,
-          "FROM #{from_clauses}",
+          "FROM #{relation.from_clauses}",
           (locked unless locked.blank?),
-          (joins(self) unless joins(self).blank?),
-          ("WHERE #{where_clauses.join(' AND ')}" unless wheres.blank?),
-          ("GROUP BY #{group_clauses.join(', ')}" unless groupings.blank?),
-          ("HAVING #{having_clauses.join(' AND ')}" unless havings.blank?),
-          ("ORDER BY #{order_clauses.join(', ')}" if orders.present? && !windowed))
+          (joins unless joins.blank?),
+          ("WHERE #{wheres.join(' AND ')}" unless wheres.blank?),
+          ("GROUP BY #{groups.join(', ')}" unless groups.blank?),
+          ("HAVING #{havings.join(' AND ')}" unless havings.blank?),
+          ("ORDER BY #{orders.join(', ')}" if orders.present? && !windowed))
       end
 
       def select_sql_with_skipped
-        tc = taken_clause if taken.present? && !single_distinct_select?
+        tc = taken_clause if relation.taken.present? && !single_distinct_select?
         build_query \
           "SELECT #{tc}#{rowtable_select_clauses.join(', ')}",
           "FROM (",
             "SELECT ROW_NUMBER() OVER (ORDER BY #{rowtable_order_clauses.join(', ')}) AS [rn],",
             select_sql_without_skipped(true),
           ") AS [_rnt]",
-          "WHERE [_rnt].[rn] > #{skipped.to_i}"
+          "WHERE [_rnt].[rn] > #{relation.skipped.to_i}"
       end
 
       def rowtable_select_clauses
         if single_distinct_select?
-          ::Array.wrap(select_clauses.first.dup.tap do |sc|
-            sc.sub! 'DISTINCT', "DISTINCT #{taken_clause if taken.present?}".strip
+          ::Array.wrap(relation.select_clauses.first.dup.tap do |sc|
+            sc.sub! 'DISTINCT', "DISTINCT #{taken_clause if relation.taken.present?}".strip
             sc.sub! table_name_from_select_clause(sc), '_rnt'
             sc.strip!
           end)
-        elsif join?
+        elsif relation.join?
 
         else
-          select_clauses.map do |sc| 
-            sc.gsub /\[#{table.name}\]\./, '[_rnt].'
+          relation.select_clauses.map do |sc| 
+            sc.gsub /\[#{relation.table.name}\]\./, '[_rnt].'
           end
         end
       end
 
       def rowtable_order_clauses
-        if order_clauses.present?
-          order_clauses
-        elsif join?
+        orders = relation.order_clauses
+        if orders.present?
+          orders
+        elsif relation.join?
           table_names_from_select_clauses.map { |tn| quote("#{tn}.#{pk_for_table(tn)}") }
         else
-          [quote("#{table.name}.#{primary_key}")]
+          [quote("#{relation.table.name}.#{relation.primary_key}")]
         end
       end
 
       def limited_update_conditions(conditions,taken)
-        quoted_primary_key = engine.quote_column_name(primary_key)
+        quoted_primary_key = engine.quote_column_name(relation.primary_key)
         conditions = " #{conditions}".strip
         build_query \
           "WHERE #{quoted_primary_key} IN",
-          "(SELECT #{taken_clause if taken.present?}#{quoted_primary_key} FROM #{engine.connection.quote_table_name(table.name)}#{conditions})"
+          "(SELECT #{taken_clause if relation.taken.present?}#{quoted_primary_key} FROM #{engine.connection.quote_table_name(relation.table.name)}#{conditions})"
       end
 
       def quote(value)
@@ -116,7 +122,7 @@ def table_name_from_select_clause(sc)
       end
 
       def table_names_from_select_clauses
-        select_clauses.map{ |sc| table_name_from_select_clause(sc) }.compact.uniq
+        relation.select_clauses.map{ |sc| table_name_from_select_clause(sc) }.compact.uniq
       end
 
     end