activerecord-sqlserver-adapter 4.1.8 → 4.2.0.pre

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -1,23 +1,23 @@
 module ActiveRecord
   module ConnectionAdapters
     class SQLServerColumn < Column
-      def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
+
+      def initialize(name, default, cast_type, sql_type = nil, null = true, sqlserver_options = {})
+        super(name, default, cast_type, sql_type, null)
         @sqlserver_options = sqlserver_options.symbolize_keys
-        super(name, default, sql_type, null)
-        @primary = @sqlserver_options[:is_identity] || @sqlserver_options[:is_primary]
+        @default_function = @sqlserver_options[:default_function]
       end
 
-      class << self
-        def string_to_binary(value)
-          "0x#{value.unpack("H*")[0]}"
+      def sql_type_for_statement
+        if is_integer? || is_real?
+          sql_type.sub(/\((\d+)?\)/, '')
+        else
+          sql_type
         end
+      end
 
-        def binary_to_string(value)
-          if value.encoding != Encoding::ASCII_8BIT
-            value = value.force_encoding(Encoding::ASCII_8BIT)
-          end
-          value
-        end
+      def table_name
+        @sqlserver_options[:table_name]
       end
 
       def is_identity?
@@ -40,77 +40,6 @@ module ActiveRecord
         @sql_type =~ /real/i
       end
 
-      def sql_type_for_statement
-        if is_integer? || is_real?
-          sql_type.sub(/\((\d+)?\)/, '')
-        else
-          sql_type
-        end
-      end
-
-      def default_function
-        @sqlserver_options[:default_function]
-      end
-
-      def table_name
-        @sqlserver_options[:table_name]
-      end
-
-      def table_klass
-        @table_klass ||= begin
-          table_name.classify.constantize
-        rescue StandardError, NameError, LoadError
-          nil
-        end
-        (@table_klass && @table_klass < ActiveRecord::Base) ? @table_klass : nil
-      end
-
-      def database_year
-        @sqlserver_options[:database_year]
-      end
-
-      private
-
-      def extract_limit(sql_type)
-        case sql_type
-        when /^smallint/i
-          2
-        when /^int/i
-          4
-        when /^bigint/i
-          8
-        when /\(max\)/, /decimal/, /numeric/
-          nil
-        else
-          super
-        end
-      end
-
-      def simplified_type(field_type)
-        case field_type
-        when /real/i              then :float
-        when /money/i             then :decimal
-        when /image/i             then :binary
-        when /bit/i               then :boolean
-        when /uniqueidentifier/i  then :uuid
-        when /datetime/i          then simplified_datetime
-        when /varchar\(max\)/     then :text
-        when /timestamp/          then :binary
-        else super
-        end
-      end
-
-      def simplified_datetime
-        if database_year >= 2008
-          :datetime
-        elsif table_klass && table_klass.coerced_sqlserver_date_columns.include?(name)
-          :date
-        elsif table_klass && table_klass.coerced_sqlserver_time_columns.include?(name)
-          :time
-        else
-          :datetime
-        end
-      end
-    end # class SQLServerColumn
-  end # module ConnectionAdapters
-end # module ActiveRecord
+    end
+  end
+end

data/lib/active_record/sqlserver_base.rb

@@ -1,5 +1,6 @@
 module ActiveRecord
   class Base
+
     def self.sqlserver_connection(config) #:nodoc:
       config = config.symbolize_keys
       config.reverse_merge! mode: :dblib
@@ -24,5 +25,6 @@ module ActiveRecord
     def self.did_lose_sqlserver_connection(connection)
       logger.info "CONNECTION LOST: #{connection.class.name}"
     end
+
   end
 end

data/lib/arel/visitors/sqlserver.rb

@@ -1,18 +1,28 @@
 module Arel
   module Visitors
     class SQLServer < Arel::Visitors::ToSql
+
+      OFFSET = " OFFSET "
+      ROWS = " ROWS"
+      FETCH = " FETCH NEXT "
+      FETCH0 = " FETCH FIRST (SELECT 0) "
+      ROWS_ONLY = " ROWS ONLY"
+
+
       private
 
       # SQLServer ToSql/Visitor (Overides)
-      def visit_Arel_Nodes_SelectStatement(o, a)
-        if complex_count_sql?(o)
-          visit_Arel_Nodes_SelectStatementForComplexCount(o, a)
-        elsif distinct_non_present_orders?(o, a)
-          visit_Arel_Nodes_SelectStatementDistinctNonPresentOrders(o, a)
-        elsif o.offset
-          visit_Arel_Nodes_SelectStatementWithOffset(o, a)
+
+      def visit_Arel_Nodes_BindParam o, collector
+        collector.add_bind(o) { |i| "@#{i-1}" }
+      end
+
+      def visit_Arel_Nodes_Bin o, collector
+        visit o.expr, collector
+        if o.expr.val.is_a? Numeric
+          collector
         else
-          visit_Arel_Nodes_SelectStatementWithOutOffset(o, a)
+          collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
         end
       end
 
@@ -23,428 +33,145 @@ module Arel
         super
       end
 
-      def visit_Arel_Nodes_Offset(o, a)
-        "WHERE [__rnt].[__rn] > (#{visit o.expr, a})"
-      end
-
-      def visit_Arel_Nodes_Limit(o, a)
-        "TOP (#{visit o.expr, a})"
+      def visit_Arel_Nodes_Lock o, collector
+        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
+        collector << SPACE
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Lock(o, a)
-        visit o.expr, a
+      def visit_Arel_Nodes_Offset o, collector
+        collector << OFFSET
+        visit o.expr, collector
+        collector << ROWS
       end
 
-      def visit_Arel_Nodes_Ordering(o, a)
-        if o.respond_to?(:direction)
-          "#{visit o.expr, a} #{o.ascending? ? 'ASC' : 'DESC'}"
+      def visit_Arel_Nodes_Limit o, collector
+        if node_value(o) == 0
+          collector << FETCH0
+          collector << ROWS_ONLY
         else
-          visit o.expr, a
+          collector << FETCH
+          visit o.expr, collector
+          collector << ROWS_ONLY
         end
       end
 
-      def visit_Arel_Nodes_Bin(o, a)
-        "#{visit o.expr, a} #{@connection.cs_equality_operator}"
-      end
-
-      # SQLServer ToSql/Visitor (Additions)
-
-      # This constructs a query using DENSE_RANK() and ROW_NUMBER() to allow
-      # ordering a DISTINCT set of data by columns in another table that are
-      # not part of what we actually want to be DISTINCT. Without this, it is
-      # possible for the DISTINCT qualifier combined with TOP to return fewer
-      # rows than were requested.
-      def visit_Arel_Nodes_SelectStatementDistinctNonPresentOrders(o, a)
-        core = o.cores.first
-        projections = core.projections
-        groups = core.groups
-        orders = o.orders.uniq
-
-        select_frags = projections.map do |x|
-          frag = projection_to_sql_remove_distinct(x, core, a)
-          # Remove the table specifier
-          frag.gsub!(/^[^\.]*\./, '')
-          # If there is an alias, remove everything but
-          frag.gsub(/^.*\sAS\s+/i, '')
+      def visit_Arel_Nodes_SelectStatement o, collector
+        @select_statement = o
+        if o.with
+          collector = visit o.with, collector
+          collector << SPACE
         end
-
-        if o.offset
-          select_frags << 'ROW_NUMBER() OVER (ORDER BY __order) AS __offset'
-        else
-          select_frags << '__order'
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore(x, c)
+        }
+        collector = visit_Orders_And_Let_Fetch_Happen o, collector
+        collector = visit_Make_Fetch_Happen o, collector
+        collector
+      ensure
+        @select_statement = nil
+      end
+
+      def visit_Arel_Nodes_JoinSource o, collector
+        if o.left
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
         end
-
-        projection_list = projections.map { |x| projection_to_sql_remove_distinct(x, core, a) }.join(', ')
-
-        sql = [
-          ('SELECT'),
-          (visit(core.set_quantifier, a) if core.set_quantifier && !o.offset),
-          (visit(o.limit, a) if o.limit && !o.offset),
-          (select_frags.join(', ')),
-          ('FROM ('),
-            ('SELECT'),
-            (
-              [
-                (projection_list),
-                (', DENSE_RANK() OVER ('),
-                  ("ORDER BY #{orders.map { |x| visit(x, a) }.join(', ')}" unless orders.empty?),
-                (') AS __order'),
-                (', ROW_NUMBER() OVER ('),
-                  ("PARTITION BY #{projection_list}" if !orders.empty?),
-                  (" ORDER BY #{orders.map { |x| visit(x, a) }.join(', ')}" unless orders.empty?),
-                (') AS __joined_row_num')
-              ].join('')
-            ),
-            (source_with_lock_for_select_statement(o, a)),
-            ("WHERE #{core.wheres.map { |x| visit(x, a) }.join ' AND ' }" unless core.wheres.empty?),
-            ("GROUP BY #{groups.map { |x| visit(x, a) }.join ', ' }" unless groups.empty?),
-            (visit(core.having, a) if core.having),
-          (') AS __sq'),
-          ('WHERE __joined_row_num = 1'),
-          ('ORDER BY __order' unless o.offset)
-        ].compact.join(' ')
-
-        if o.offset
-          sql = [
-            ('SELECT'),
-            (visit(core.set_quantifier, a) if core.set_quantifier),
-            (visit(o.limit, a) if o.limit),
-            ('*'),
-            ('FROM (' + sql + ') AS __osq'),
-            ("WHERE __offset > #{visit(o.offset.expr, a)}"),
-            ('ORDER BY __offset')
-          ].join(' ')
+        if o.right.any?
+          collector << " " if o.left
+          collector = inject_join o.right, collector, ' '
         end
-
-        sql
+        collector
       end
 
-      def visit_Arel_Nodes_SelectStatementWithOutOffset(o, a, 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, a) }
-          groups = projections.map { |x| projection_without_expression(x, a) } if windowed_single_distinct_select_statement?(o) && groups.empty?
-          groups += orders.map { |x| Arel.sql(x.expr) } if windowed_single_distinct_select_statement?(o)
-        elsif eager_limiting_select_statement?(o, a)
-          projections = projections.map { |x| projection_without_expression(x, a) }
-          groups = projections.map { |x| projection_without_expression(x, a) }
-          orders = orders.map do |x|
-            expr = Arel.sql projection_without_expression(x.expr, a)
-            x.descending? ? Arel::Nodes::Max.new([expr]) : Arel::Nodes::Min.new([expr])
-          end
-        elsif top_one_everything_for_through_join?(o, a)
-          projections = projections.map { |x| projection_without_expression(x, a) }
-        end
-        [
-          ('SELECT' unless windowed),
-          (visit(core.set_quantifier, a) if core.set_quantifier && !windowed),
-          (visit(o.limit, a) if o.limit && !windowed),
-          (projections.map do |x|
-            v = visit(x, a)
-            v == '1' ? '1 AS [__wrp]' : v
-          end.join(', ')),
-          (source_with_lock_for_select_statement(o, a)),
-          ("WHERE #{core.wheres.map { |x| visit(x, a) }.join ' AND ' }" unless core.wheres.empty?),
-          ("GROUP BY #{groups.map { |x| visit(x, a) }.join ', ' }" unless groups.empty?),
-          (visit(core.having, a) if core.having),
-          ("ORDER BY #{orders.map { |x| visit(x, a) }.join(', ')}" if !orders.empty? && !windowed)
-        ].compact.join ' '
-      end
-
-      def visit_Arel_Nodes_SelectStatementWithOffset(o, a)
-        core = o.cores.first
-        o.limit ||= Arel::Nodes::Limit.new(9_223_372_036_854_775_807)
-        orders = rowtable_orders(o)
-        [
-          'SELECT',
-          (visit(o.limit, a) if o.limit && !windowed_single_distinct_select_statement?(o)),
-          (rowtable_projections(o, a).map { |x| visit(x, a) }.join(', ')),
-          'FROM (',
-          "SELECT #{core.set_quantifier ? 'DISTINCT DENSE_RANK()' : 'ROW_NUMBER()'} OVER (ORDER BY #{orders.map { |x| visit(x, a) }.join(', ')}) AS [__rn],",
-          visit_Arel_Nodes_SelectStatementWithOutOffset(o, a, true),
-          ') AS [__rnt]',
-          (visit(o.offset, a) if o.offset),
-          'ORDER BY [__rnt].[__rn] ASC'
-        ].compact.join ' '
+      def visit_Arel_Nodes_OuterJoin o, collector
+        collector << "LEFT OUTER JOIN "
+        collector = visit o.left, collector
+        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+        collector << " "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_SelectStatementForComplexCount(o, a)
-        core = o.cores.first
-        o.limit.expr = Arel.sql("#{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, a) if o.limit),
-          "ROW_NUMBER() OVER (ORDER BY #{orders.map { |x| visit(x, a) }.join(', ')}) AS [__rn],",
-          '1 AS [count]',
-          (source_with_lock_for_select_statement(o, a)),
-          ("WHERE #{core.wheres.map { |x| visit(x, a) }.join ' AND ' }" unless core.wheres.empty?),
-          ("GROUP BY #{core.groups.map { |x| visit(x, a) }.join ', ' }" unless core.groups.empty?),
-          (visit(core.having, a) if core.having),
-          ("ORDER BY #{o.orders.map { |x| visit(x, a) }.join(', ')}" unless o.orders.empty?),
-          ') AS [__rnt]',
-          (visit(o.offset, a) if o.offset)
-        ].compact.join ' '
-      end
-
-      # SQLServer Helpers
-
-      def projection_to_sql_remove_distinct(x, core, a)
-        frag = Arel.sql(visit(x, a))
-        # In Rails 4.0.0, DISTINCT was in a projection, whereas with 4.0.1
-        # it is now stored in the set_quantifier. This moves it to the correct
-        # place so the code works on both 4.0.0 and 4.0.1.
-        if frag =~ /^\s*DISTINCT\s+/i
-          core.set_quantifier = Arel::Nodes::Distinct.new
-          frag.gsub!(/\s*DISTINCT\s+/, '')
-        end
-        frag
-      end
+      # SQLServer ToSql/Visitor (Additions)
 
-      def source_with_lock_for_select_statement(o, a)
-        core = o.cores.first
-        source = "FROM #{visit(core.source, a).strip}" if core.source
-        if source && o.lock
-          lock = visit o.lock, a
-          index = source.match(/FROM [\w\[\]\.]+/)[0].mb_chars.length
-          source.insert index, " #{lock}"
-        else
-          source
+      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
+        if select_statement_lock?
+          collector = visit @select_statement.lock, collector
+          collector << SPACE if options[:space]
         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 do |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
+        collector
+      end
+
+      def visit_Orders_And_Let_Fetch_Happen o, collector
+        make_Fetch_Possible_And_Deterministic o
+        unless o.orders.empty?
+          collector << SPACE
+          collector << ORDER_BY
+          len = o.orders.length - 1
+          o.orders.each_with_index { |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          }
         end
-        table_finder.call(core.froms)
+        collector
       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'))
+      def visit_Make_Fetch_Happen o, collector
+        o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
+        collector = visit o.offset, collector if o.offset
+        collector = visit o.limit, collector if o.limit
+        collector
       end
 
-      # Determine if the SELECT statement is asking for DISTINCT results,
-      # but is using columns not part of the SELECT list in the ORDER BY.
-      # This is necessary because SQL Server requires all ORDER BY entries
-      # be in the SELECT list with DISTINCT. However, these ordering columns
-      # can cause duplicate rows, which affect when using a limit.
-      def distinct_non_present_orders?(o, a)
-        projections = o.cores.first.projections
-
-        sq = o.cores.first.set_quantifier
-        p1 = projections.first
-
-        found_distinct = sq && sq.class.to_s =~ /Distinct/
-        if (p1.respond_to?(:distinct) && p1.distinct) || (p1.respond_to?(:include?) && p1.include?('DISTINCT'))
-          found_distinct = true
-        end
-
-        return false if !found_distinct || o.orders.uniq.empty?
-
-        tables_all_columns = []
-        expressions = projections.map do |p|
-          visit(p, a).split(',').map do |x|
-            x.strip!
-            # Rails 4.0.0 included DISTINCT in the first projection
-            x.gsub!(/\s*DISTINCT\s+/, '')
-            # Aliased column names
-            x.gsub!(/\s+AS\s+\w+/i, '')
-            # Identifier quoting
-            x.gsub!(/\[|\]/, '')
-            star_match = /^(\w+)\.\*$/.match(x)
-            tables_all_columns << star_match[1] if star_match
-            x.strip.downcase
-          end.join(', ')
-        end
-
-        # Make sure each order by is in the select list, otherwise there needs
-        # to be a subquery with row_numbe()
-        o.orders.uniq.each do |order|
-          order = visit(order, a)
-          order.strip!
-
-          order.gsub!(/\s+(asc|desc)/i, '')
-          # Identifier quoting
-          order.gsub!(/\[|\]/, '')
-
-          order.strip!
-          order.downcase!
-
-          # If we selected all columns from a table, the order is ok
-          table_match = /^(\w+)\.\w+$/.match(order)
-          next if table_match && tables_all_columns.include?(table_match[1])
-
-          next if expressions.include?(order)
+      # SQLServer Helpers
 
-          return true
+      def node_value(node)
+        case node.expr
+        when NilClass then nil
+        when Numeric then node.expr
+        when Arel::Nodes::Unary then node.expr.expr
         end
-
-        # We didn't find anything in the order by no being selected
-        false
       end
 
-      def windowed_single_distinct_select_statement?(o)
-        o.limit &&
-          o.offset &&
-          single_distinct_select_statement?(o)
+      def select_statement_lock?
+        @select_statement && @select_statement.lock
       end
 
-      def single_distinct_select_everything_statement?(o, a)
-        single_distinct_select_statement?(o) &&
-          visit(o.cores.first.projections.first, a).ends_with?('.*')
-      end
-
-      def top_one_everything_for_through_join?(o, a)
-        single_distinct_select_everything_statement?(o, a) &&
-          (o.limit && !o.offset) &&
-          join_in_select_statement?(o)
-      end
-
-      def all_projections_aliased_in_select_statement?(o, a)
-        projections = o.cores.first.projections
-        projections.all? do |x|
-          visit(x, a).split(',').all? { |y| y.include?(' AS ') }
+      def make_Fetch_Possible_And_Deterministic o
+        return if o.limit.nil? && o.offset.nil?
+        t = table_From_Statement o
+        pk = primary_Key_From_Table t
+        return unless pk
+        if o.orders.empty?
+          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
+          o.orders = [pk.asc]
         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, a)
+      def table_From_Statement o
         core = o.cores.first
-        single_distinct_select_statement?(o) &&
-          (o.limit && !o.offset) &&
-          core.groups.empty? &&
-          !single_distinct_select_everything_statement?(o, a)
-      end
-
-      def join_in_select_statement?(o)
-        core = o.cores.first
-        core.source.right.any? { |x| Arel::Nodes::Join === x }
-      end
-
-      def complex_count_sql?(o)
-        core = o.cores.first
-        core.projections.size == 1 &&
-          Arel::Nodes::Count === core.projections.first &&
-          o.limit &&
-          !join_in_select_statement?(o)
-      end
-
-      def select_primary_key_sql?(o)
-        core = o.cores.first
-        return false if core.projections.size != 1
-        p = core.projections.first
-        t = table_from_select_statement(o)
-        Arel::Attributes::Attribute === p && t.primary_key && t.primary_key.name == p.name
-      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, a)
-        core = o.cores.first
-        if windowed_single_distinct_select_statement?(o) && core.groups.blank?
-          tn = table_from_select_statement(o).name
-          core.projections.map do |x|
-            x.dup.tap do |p|
-              p.sub! 'DISTINCT', ''
-              p.insert 0, visit(o.limit, a) if o.limit
-              p.gsub!(/\[?#{tn}\]?\./, '[__rnt].')
-              p.strip!
-            end
-          end
-        elsif 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, a)}".strip if o.limit
-              p.gsub!(/\[?#{tn}\]?\./, '[__rnt].')
-              p.strip!
-            end
-          end
-        elsif join_in_select_statement?(o) && all_projections_aliased_in_select_statement?(o, a)
-          core.projections.map do |x|
-            Arel.sql visit(x, a).split(',').map { |y| y.split(' AS ').last.strip }.join(', ')
-          end
-        elsif select_primary_key_sql?(o)
-          [Arel.sql("[__rnt].#{quote_column_name(core.projections.first.name)}")]
-        else
-          [Arel.sql('[__rnt].*')]
+        if Arel::Table === core.from
+          core.from
+        elsif Arel::Nodes::SqlLiteral === core.from
+          Arel::Table.new(core.from)
+        elsif Arel::Nodes::JoinSource === core.source
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
         end
       end
 
-      def rowtable_orders(o)
-        if !o.orders.empty?
-          o.orders
-        else
-          t = table_from_select_statement(o)
-          c = t.primary_key || t.columns.first
-          [c.asc]
-        end.uniq
+      def primary_Key_From_Table t
+        return unless t
+        return t.primary_key if t.primary_key
+        if engine_pk = t.engine.primary_key
+          pk = t.engine.arel_table[engine_pk]
+          return pk if pk
+        end
+        pk = t.engine.connection.schema_cache.primary_keys(t.engine.table_name)
+        return pk if pk
+        column_name = t.engine.columns.first.try(:name)
+        column_name ? t[column_name] : nil
       end
 
-      # TODO: We use this for grouping too, maybe make Grouping objects vs SqlLiteral.
-      def projection_without_expression(projection, a)
-        Arel.sql(visit(projection, a).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