activerecord-sqlserver-adapter 3.0.7 → 3.0.8

data/CHANGELOG

@@ -1,4 +1,9 @@
 
+* 3.0.8 *
+
+* Support for ActiveRecord v3.0.3 and ARel v2.0.7
+
+
 * 3.0.7 * 
 
 * Properly quote table names when reflecting on views.

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,3 +1,4 @@
+require 'arel/visitors/sqlserver'
 require 'active_record'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
@@ -163,7 +164,7 @@ module ActiveRecord
       include Sqlserver::Errors
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '3.0.7'.freeze
+      VERSION                     = '3.0.8'.freeze
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS          = [2005,2008].freeze
       

data/lib/arel/visitors/sqlserver.rb

@@ -0,0 +1,342 @@
+module Arel
+  
+  module Nodes
+    
+    # See the SelectManager#lock method on why this custom class is needed.
+    class LockWithSQLServer < Arel::Nodes::Unary
+    end
+    
+    # In versions of ActiveRecord prior to v3.0.3 limits and offset were always integers via 
+    # a #to_i. Somewhere between ActiveRecord and ARel this is not happening anymore nor are they 
+    # in agreement which should be responsible. Since we need to make sure that these are visited 
+    # correctly and that we can do math with them, these are here to cast to integers.
+    class Limit < Arel::Nodes::Unary
+      def initialize expr
+        @expr = expr.to_i
+      end
+    end
+    class Offset < Arel::Nodes::Unary
+      def initialize expr
+        @expr = expr.to_i
+      end
+    end
+    
+    # Extending the Ordering class to be comparrison friendly which allows us to call #uniq on a
+    # collection of them. See SelectManager#order for more details.
+    class Ordering < Arel::Nodes::Binary
+      def hash
+        expr.hash
+      end
+      def ==(other)
+        self.class == other.class && self.expr == other.expr
+      end
+      def eql?(other)
+        self == other
+      end
+    end  
+    
+  end
+  
+  class SelectManager < Arel::TreeManager
+    
+    alias :lock_without_sqlserver :lock
+    
+    # Getting real Ordering objects is very important for us. We need to be able to call #uniq on 
+    # a colleciton of them reliably as well as using their true object attributes to mutate them 
+    # to grouping objects for the inner sql during a select statment with an offset/rownumber. So this
+    # is here till ActiveRecord & ARel does this for us instead of using SqlLiteral objects.
+    def order(*exprs)
+      @ast.orders.concat(exprs.map{ |x|
+        case x
+        when Arel::Attributes::Attribute
+          c = engine.connection
+          tn = x.relation.table_alias || x.relation.name
+          expr = Arel::Nodes::SqlLiteral.new "#{c.quote_table_name(tn)}.#{c.quote_column_name(x.name)}"
+          Arel::Nodes::Ordering.new expr
+        when String
+          x.split(',').map do |s|
+            expr, direction = s.split
+            expr = Arel::Nodes::SqlLiteral.new(expr)
+            direction = direction =~ /desc/i ? :desc : :asc
+            Arel::Nodes::Ordering.new expr, direction
+          end
+        else
+          expr = Arel::Nodes::SqlLiteral.new x.to_s
+          Arel::Nodes::Ordering.new expr
+        end
+      }.flatten)
+      self
+    end
+    
+    # A friendly over ride that allows us to put a special lock object that can have a default or pass 
+    # custom string hints down. See the visit_Arel_Nodes_LockWithSQLServer delegation method.
+    def lock(locking=true)
+      if Arel::Visitors::SQLServer === @visitor
+        @ast.lock = Arel::Nodes::LockWithSQLServer.new(locking)
+        self
+      else
+        lock_without_sqlserver(locking)
+      end
+    end
+    
+  end
+  
+  module Visitors
+    class SQLServer < Arel::Visitors::ToSql
+      
+      private
+      
+      # SQLServer ToSql/Visitor (Overides)
+      
+      def visit_Arel_Nodes_SelectStatement(o)
+        if complex_count_sql?(o)
+          visit_Arel_Nodes_SelectStatementForComplexCount(o)
+        elsif o.offset
+          visit_Arel_Nodes_SelectStatementWithOffset(o)
+        else
+          visit_Arel_Nodes_SelectStatementWithOutOffset(o)
+        end
+      end
+      
+      def visit_Arel_Nodes_Offset(o)
+        "WHERE [__rnt].[__rn] > #{visit o.expr}"
+      end
+      
+      def visit_Arel_Nodes_Limit(o)
+        "TOP (#{visit o.expr})"
+      end
+      
+      def visit_Arel_Nodes_Lock o
+        "WITH(HOLDLOCK, ROWLOCK)"
+      end
+      
+      def visit_Arel_Nodes_LockWithSQLServer o
+        case o.expr
+        when TrueClass
+          "WITH(HOLDLOCK, ROWLOCK)"
+        when String
+          o.expr
+        else
+          ""
+        end
+      end
+      
+      
+      # SQLServer ToSql/Visitor (Additions)
+      
+      def visit_Arel_Nodes_SelectStatementWithOutOffset(o, windowed=false)
+        find_and_fix_uncorrelated_joins_in_select_statement(o)
+        core = o.cores.first
+        projections = core.projections
+        groups = core.groups
+        orders = o.orders.uniq
+        if windowed
+          projections = function_select_statement?(o) ? projections : projections.map { |x| projection_without_expression(x) }
+        elsif eager_limiting_select_statement?(o)
+          groups = projections.map { |x| projection_without_expression(x) }
+          projections = projections.map { |x| projection_without_expression(x) }
+          orders = orders.map do |x|
+            expr = Arel::Nodes::SqlLiteral.new projection_without_expression(x.expr)
+            x.descending? ? Arel::Nodes::Max.new([expr]) : Arel::Nodes::Min.new([expr])
+          end
+        end
+        [ ("SELECT" if !windowed),
+          (visit(o.limit) if o.limit && !windowed),
+          (projections.map{ |x| visit(x) }.join(', ')),
+          (source_with_lock_for_select_statement(o)),
+          ("WHERE #{core.wheres.map{ |x| visit(x) }.join ' AND ' }" unless core.wheres.empty?),
+          ("GROUP BY #{groups.map { |x| visit x }.join ', ' }" unless groups.empty?),
+          (visit(core.having) if core.having),
+          ("ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}" if !orders.empty? && !windowed)
+        ].compact.join ' '
+      end
+      
+      def visit_Arel_Nodes_SelectStatementWithOffset(o)
+        orders = rowtable_orders(o)
+        [ "SELECT",
+          (visit(o.limit) if o.limit && !single_distinct_select_statement?(o)),
+          (rowtable_projections(o).map{ |x| visit(x) }.join(', ')),
+          "FROM (",
+            "SELECT ROW_NUMBER() OVER (ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}) AS [__rn],",
+            visit_Arel_Nodes_SelectStatementWithOutOffset(o,true),
+          ") AS [__rnt]",
+          (visit(o.offset) if o.offset),
+        ].compact.join ' '
+      end
+      
+      def visit_Arel_Nodes_SelectStatementForComplexCount(o)
+        core = o.cores.first
+        o.limit.expr = o.limit.expr + (o.offset ? o.offset.expr : 0) if o.limit
+        orders = rowtable_orders(o)
+        [ "SELECT COUNT([count]) AS [count_id]",
+          "FROM (",
+            "SELECT",
+            (visit(o.limit) if o.limit),
+            "ROW_NUMBER() OVER (ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}) AS [__rn],",
+            "1 AS [count]",
+            (source_with_lock_for_select_statement(o)),
+            ("WHERE #{core.wheres.map{ |x| visit(x) }.join ' AND ' }" unless core.wheres.empty?),
+            ("GROUP BY #{core.groups.map { |x| visit x }.join ', ' }" unless core.groups.empty?),
+            (visit(core.having) if core.having),
+            ("ORDER BY #{o.orders.map{ |x| visit(x) }.join(', ')}" if !o.orders.empty?),
+          ") AS [__rnt]",
+          (visit(o.offset) if o.offset)
+        ].compact.join ' '
+      end
+      
+      
+      # SQLServer Helpers
+      
+      def source_with_lock_for_select_statement(o)
+        # TODO: [ARel 2.2] Use #from/#source vs. #froms
+        core = o.cores.first
+        source = "FROM #{visit core.froms}" if core.froms
+        if source && o.lock
+          lock = visit o.lock
+          index = source.match(/FROM [\w\[\]\.]+/)[0].length
+          source.insert index, " #{lock}" 
+        else
+          source
+        end
+      end
+      
+      def table_from_select_statement(o)
+        core = o.cores.first
+        # TODO: [ARel 2.2] Use #from/#source vs. #froms
+        # if Arel::Table === core.from
+        #   core.from
+        # elsif Arel::Nodes::SqlLiteral === core.from
+        #   Arel::Table.new(core.from, @engine)
+        # elsif Arel::Nodes::JoinSource === core.source
+        #   Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+        # end
+        table_finder = lambda { |x|
+          case x
+          when Arel::Table
+            x
+          when Arel::Nodes::SqlLiteral
+            Arel::Table.new(x, @engine)
+          when Arel::Nodes::Join
+            table_finder.call(x.left)
+          end
+        }
+        table_finder.call(core.froms)   
+      end
+      
+      def single_distinct_select_statement?(o)
+        projections = o.cores.first.projections
+        p1 = projections.first
+        projections.size == 1 && 
+          ((p1.respond_to?(:distinct) && p1.distinct) || 
+            p1.respond_to?(:include?) && p1.include?('DISTINCT'))
+      end
+      
+      def all_projections_aliased_in_select_statement?(o)
+        projections = o.cores.first.projections
+        projections.all? do |x|
+          x.split(',').all? { |y| y.include?(' AS ') }
+        end
+      end
+      
+      def function_select_statement?(o)
+        core = o.cores.first
+        core.projections.any? { |x| Arel::Nodes::Function === x }
+      end
+      
+      def eager_limiting_select_statement?(o)
+        core = o.cores.first
+        single_distinct_select_statement?(o) && (o.limit && !o.offset) && core.groups.empty?
+      end
+      
+      def join_in_select_statement?(o)
+        core = o.cores.first
+        # TODO: [ARel 2.2] Use #from/#source vs. #froms
+        # core.source.right.any? { |x| Arel::Nodes::Join === x }
+        Arel::Nodes::Join === core.froms
+      end
+      
+      def complex_count_sql?(o)
+        core = o.cores.first
+        core.projections.size == 1 &&
+          Arel::Nodes::Count === core.projections.first && 
+          (o.limit || !core.wheres.empty?) &&
+          !join_in_select_statement?(o)
+      end
+      
+      def find_and_fix_uncorrelated_joins_in_select_statement(o)
+        core = o.cores.first
+        # TODO: [ARel 2.2] Use #from/#source vs. #froms
+        # return if !join_in_select_statement?(o) || core.source.right.size != 2
+        # j1 = core.source.right.first
+        # j2 = core.source.right.second
+        # return unless Arel::Nodes::OuterJoin === j1 && Arel::Nodes::StringJoin === j2
+        # j1_tn = j1.left.name
+        # j2_tn = j2.left.match(/JOIN \[(.*)\].*ON/).try(:[],1)
+        # return unless j1_tn == j2_tn
+        # crltd_tn = "#{j1_tn}_crltd"
+        # j1.left.table_alias = crltd_tn
+        # j1.right.expr.left.relation.table_alias = crltd_tn
+        return if !join_in_select_statement?(o) || !(Arel::Nodes::StringJoin === core.froms)
+        j1 = core.froms.left
+        j2 = core.froms.right
+        return unless Arel::Nodes::OuterJoin === j1 && Arel::Nodes::SqlLiteral === j2 && j2.include?('JOIN ')
+        j1_tn = j1.right.name
+        j2_tn = j2.match(/JOIN \[(.*)\].*ON/).try(:[],1)
+        return unless j1_tn == j2_tn
+        on_index = j2.index(' ON ')
+        j2.insert on_index, " AS [#{j2_tn}_crltd]"
+        j2.sub! "[#{j2_tn}].", "[#{j2_tn}_crltd]."
+      end
+      
+      def rowtable_projections(o)
+        core = o.cores.first
+        if single_distinct_select_statement?(o)
+          tn = table_from_select_statement(o).name
+          core.projections.map do |x|
+            x.dup.tap do |p|
+              p.sub! 'DISTINCT', "DISTINCT #{visit(o.limit)}".strip if o.limit
+              p.sub! /\[#{tn}\]\./, '[__rnt].'
+              p.strip!
+            end
+          end
+        elsif join_in_select_statement?(o) && all_projections_aliased_in_select_statement?(o)
+          core.projections.map do |x|
+            Arel::Nodes::SqlLiteral.new x.split(',').map{ |y| y.split(' AS ').last.strip }.join(', ')
+          end
+        elsif function_select_statement?(o)
+          # TODO: [ARel 2.2] Use Arel.star
+          [Arel::Nodes::SqlLiteral.new '*']
+        else
+          tn = table_from_select_statement(o).name
+          core.projections.map { |x| x.gsub /\[#{tn}\]\./, '[__rnt].' }
+        end
+      end
+      
+      def rowtable_orders(o)
+        core = o.cores.first
+        if !o.orders.empty?
+          o.orders
+        elsif join_in_select_statement?(o)
+          [table_from_select_statement(o).primary_key.asc]
+        else
+          [table_from_select_statement(o).primary_key.asc]
+        end.uniq
+      end
+      
+      # TODO: We use this for grouping too, maybe make Grouping objects vs SqlLiteral.
+      def projection_without_expression(projection)
+        Arel::Nodes::SqlLiteral.new(projection.split(',').map do |x|
+          x.strip!
+          x.sub!(/^(COUNT|SUM|MAX|MIN|AVG)\s*(\((.*)\))?/,'\3')
+          x.sub!(/^DISTINCT\s*/,'')
+          x.sub!(/TOP\s*\(\d+\)\s*/i,'')
+          x.strip
+        end.join(', '))
+      end
+      
+    end
+  end
+  
+end
+
+Arel::Visitors::VISITORS['sqlserver'] = Arel::Visitors::SQLServer

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 23
   prerelease: false
   segments: 
   - 3
   - 0
-  - 7
-  version: 3.0.7
+  - 8
+  version: 3.0.8
 platform: ruby
 authors: 
 - Ken Collins
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-01 00:00:00 -05:00
+date: 2011-01-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,12 +30,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 1
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 3
+        version: 3.0.3
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -46,12 +46,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 1
         segments: 
-        - 1
-        - 0
+        - 2
         - 0
-        version: 1.0.0
+        - 7
+        version: 2.0.7
   type: :runtime
   version_requirements: *id002
 description: SQL Server 2005 and 2008 Adapter For ActiveRecord
@@ -76,7 +76,7 @@ files:
 - lib/active_record/connection_adapters/sqlserver/schema_statements.rb
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/activerecord-sqlserver-adapter.rb
-- lib/arel/engines/sql/compilers/sqlserver_compiler.rb
+- lib/arel/visitors/sqlserver.rb
 has_rdoc: true
 homepage: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter
 licenses: []

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

@@ -1,267 +0,0 @@
-module Arel
-  class Lock < Compound
-    def initialize(relation, locked)
-      super(relation)
-      @locked = true == locked ? "WITH(HOLDLOCK, ROWLOCK)" : locked
-    end
-  end
-end
-
-module Arel
-  module SqlCompiler
-    class SQLServerCompiler < GenericCompiler
-      
-      def select_sql
-        if complex_count_sql?
-          select_sql_with_complex_count
-        elsif relation.skipped
-          select_sql_with_skipped
-        else
-          select_sql_without_skipped
-        end
-      end
-      
-      def delete_sql
-        build_query \
-          "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 complex_count_sql?
-        projections = relation.projections
-        projections.first.is_a?(Arel::Count) && projections.size == 1 &&
-          (relation.taken.present? || relation.wheres.present?) && relation.joins(self).blank?
-      end
-      
-      def taken_only?
-        relation.taken.present? && relation.skipped.blank?
-      end
-      
-      def taken_clause
-        "TOP (#{relation.taken.to_i}) "
-      end
-      
-      def expression_select?
-        relation.select_clauses.any? { |sc| sc.match /(COUNT|SUM|MAX|MIN|AVG)\s*\(.*\)/ }
-      end
-      
-      def eager_limiting_select?
-        single_distinct_select? && taken_only? && relation.group_clauses.blank?
-      end
-      
-      def single_distinct_select?
-        relation.select_clauses.size == 1 && relation.select_clauses.first.to_s.include?('DISTINCT')
-      end
-      
-      def all_select_clauses_aliased?
-        relation.select_clauses.all? do |sc|
-          sc.split(',').all? { |c| c.include?(' AS ') }
-        end
-      end
-      
-      def select_sql_with_complex_count
-        joins   = correlated_safe_joins
-        wheres  = relation.where_clauses
-        groups  = relation.group_clauses
-        havings = relation.having_clauses
-        orders  = relation.order_clauses
-        taken   = relation.taken.to_i
-        skipped = relation.skipped.to_i
-        top_clause = "TOP (#{taken+skipped}) " if relation.taken.present?
-        build_query \
-          "SELECT COUNT([count]) AS [count_id]",
-          "FROM (",
-            "SELECT #{top_clause}ROW_NUMBER() OVER (ORDER BY #{unique_orders(rowtable_order_clauses).join(', ')}) AS [__rn],",
-            "1 AS [count]",
-            "FROM #{relation.from_clauses}",
-            (locked unless locked.blank?),
-            (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 #{unique_orders(orders).join(', ')}" unless orders.blank?),
-          ") AS [__rnt]",
-          "WHERE [__rnt].[__rn] > #{relation.skipped.to_i}"
-      end
-      
-      def select_sql_without_skipped(windowed=false)
-        selects = relation.select_clauses
-        joins   = correlated_safe_joins
-        wheres  = relation.where_clauses
-        groups  = relation.group_clauses
-        havings = relation.having_clauses
-        orders  = relation.order_clauses
-        if windowed
-          selects = expression_select? ? selects : selects.map{ |sc| clause_without_expression(sc) }          
-        elsif eager_limiting_select?
-          groups = selects.map { |sc| clause_without_expression(sc) }
-          selects = selects.map { |sc| "#{taken_clause}#{clause_without_expression(sc)}" }
-          orders = orders.map do |oc|
-            oc.split(',').reject(&:blank?).map do |c|
-              max = c =~ /desc\s*/i
-              c = clause_without_expression(c).sub(/(asc|desc)/i,'').strip
-              max ? "MAX(#{c})" : "MIN(#{c})"
-            end.join(', ')
-          end
-        elsif taken_only?
-          fsc = "#{taken_clause}#{selects.first}"
-          selects = selects.tap { |sc| sc.shift ; sc.unshift(fsc) }
-        end
-        build_query(
-          (windowed ? selects.join(', ') : "SELECT #{selects.join(', ')}"),
-          "FROM #{relation.from_clauses}",
-          (locked unless locked.blank?),
-          (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 #{unique_orders(orders).join(', ')}" if orders.present? && !windowed))
-      end
-      
-      def select_sql_with_skipped
-        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 #{unique_orders(rowtable_order_clauses).join(', ')}) AS [__rn],",
-            select_sql_without_skipped(true),
-          ") AS [__rnt]",
-          "WHERE [__rnt].[__rn] > #{relation.skipped.to_i}"
-      end
-      
-      def rowtable_select_clauses
-        if single_distinct_select?
-          ::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 relation.join? && all_select_clauses_aliased?
-          relation.select_clauses.map do |sc|
-            sc.split(',').map { |c| c.split(' AS ').last.strip  }.join(', ')
-          end
-        elsif expression_select?
-          ['*']
-        else
-          relation.select_clauses.map do |sc|
-            sc.gsub /\[#{relation.table.name}\]\./, '[__rnt].'
-          end
-        end
-      end
-      
-      def rowtable_order_clauses
-        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("#{relation.table.name}.#{relation.primary_key}")]
-        end
-      end
-      
-      def limited_update_conditions(conditions,taken)
-        quoted_primary_key = engine.connection.quote_column_name(relation.primary_key)
-        conditions = " #{conditions}".strip
-        build_query \
-          "WHERE #{quoted_primary_key} IN",
-          "(SELECT #{taken_clause if relation.taken.present?}#{quoted_primary_key} FROM #{engine.connection.quote_table_name(relation.table.name)}#{conditions})"
-      end
-      
-      def quote(value)
-        engine.connection.quote_column_name(value)
-      end
-      
-      def pk_for_table(table_name)
-        engine.connection.primary_key(table_name)
-      end
-      
-      def clause_without_expression(clause)
-        clause.to_s.split(',').map do |c|
-          c.strip!
-          c.sub!(/^(COUNT|SUM|MAX|MIN|AVG)\s*(\((.*)\))?/,'\3')
-          c.sub!(/^DISTINCT\s*/,'')
-          c.sub!(/TOP\s*\(\d+\)\s*/i,'')
-          c.strip
-        end.join(', ')
-      end
-      
-      def unqualify_table_name(table_name)
-        table_name.to_s.split('.').last.tr('[]','')
-      end
-      
-      def table_name_from_select_clause(sc)
-        parts = clause_without_expression(sc).split('.')
-        tn = parts.third ? parts.second : (parts.second ? parts.first : nil)
-        tn ? tn.tr('[]','') : nil
-      end
-
-      def table_names_from_select_clauses
-        relation.select_clauses.map do |sc|
-          sc.split(',').map { table_name_from_select_clause(sc) }
-        end.flatten.compact.uniq
-      end
-      
-      def unique_orders(orders)
-        existing_columns = {}
-        orders.inject([]) do |queued_orders, order|
-          table_column, dir = clause_without_expression(order).split
-          table_column = table_column.tr('[]','').split('.')
-          table, column = table_column.size == 2 ? table_column : table_column.unshift('')
-          existing_columns[table] ||= []
-          unless existing_columns[table].include?(column)
-            existing_columns[table] << column
-            queued_orders << order 
-          end
-          queued_orders
-        end
-      end
-      
-      def correlated_safe_joins
-        joins = relation.joins(self)
-        if joins.present?
-          find_and_fix_uncorrelated_joins
-          relation.joins(self)
-        else
-          joins
-        end
-      end
-      
-      def find_and_fix_uncorrelated_joins
-        join_relation = relation
-        while join_relation.present?
-          return join_relation if uncorrelated_inner_join_relation?(join_relation)
-          join_relation = join_relation.relation rescue nil
-        end
-      end
-
-      def uncorrelated_inner_join_relation?(r)
-        if r.is_a?(Arel::StringJoin) && r.relation1.is_a?(Arel::OuterJoin) && 
-            r.relation2.is_a?(String) && r.relation2.starts_with?('INNER JOIN')
-          outter_join_table1 = r.relation1.relation1.table
-          outter_join_table2 = r.relation1.relation2.table
-          string_join_table_info = r.relation2.split(' ON ').first.sub('INNER JOIN ','')
-          return nil if string_join_table_info.include?(' AS ') # Assume someone did something right.
-          string_join_table_name = unqualify_table_name(string_join_table_info)
-          uncorrelated_table1 = string_join_table_name == outter_join_table1.name && string_join_table_name == outter_join_table1.alias.name
-          uncorrelated_table2 = string_join_table_name == outter_join_table2.name && string_join_table_name == outter_join_table2.alias.name
-          if uncorrelated_table1 || uncorrelated_table2
-            on_index = r.relation2.index(' ON ')
-            r.relation2.insert on_index, " AS [#{string_join_table_name}_crltd]"
-            r.relation2.sub! "[#{string_join_table_name}].", "[#{string_join_table_name}_crltd]."
-            return r
-          else
-            return nil
-          end
-        end
-      rescue
-        nil
-      end
-      
-    end
-  end
-end