activerecord-sqlserver-adapter 3.2.18 → 4.0.0

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -0,0 +1,116 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLServerColumn < Column
+      def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
+        @sqlserver_options = sqlserver_options.symbolize_keys
+        super(name, default, sql_type, null)
+        @primary = @sqlserver_options[:is_identity] || @sqlserver_options[:is_primary]
+      end
+
+      class << self
+        def string_to_binary(value)
+          "0x#{value.unpack("H*")[0]}"
+        end
+
+        def binary_to_string(value)
+          if value.encoding != Encoding::ASCII_8BIT
+            value = value.force_encoding(Encoding::ASCII_8BIT)
+          end
+          value
+        end
+      end
+
+      def is_identity?
+        @sqlserver_options[:is_identity]
+      end
+
+      def is_primary?
+        @sqlserver_options[:is_primary]
+      end
+
+      def is_utf8?
+        @sql_type =~ /nvarchar|ntext|nchar/i
+      end
+
+      def is_integer?
+        @sql_type =~ /int/i
+      end
+
+      def is_real?
+        @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

data/lib/active_record/sqlserver_base.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  class Base
+    def self.sqlserver_connection(config) #:nodoc:
+      config = config.symbolize_keys
+      config.reverse_merge! mode: :dblib
+      mode = config[:mode].to_s.downcase.underscore.to_sym
+      case mode
+      when :dblib
+        require 'tiny_tds'
+      when :odbc
+        raise ArgumentError, 'Missing :dsn configuration.' unless config.key?(:dsn)
+        require 'odbc'
+        require 'active_record/connection_adapters/sqlserver/core_ext/odbc'
+      else
+        raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+      end
+      ConnectionAdapters::SQLServerAdapter.new(nil, logger, nil, config.merge(mode: mode))
+    end
+
+    def self.did_retry_sqlserver_connection(connection, count)
+      logger.info "CONNECTION RETRY: #{connection.class.name} retry ##{count}."
+    end
+
+    def self.did_lose_sqlserver_connection(connection)
+      logger.info "CONNECTION LOST: #{connection.class.name}"
+    end
+  end
+end

data/lib/active_record/sqlserver_test_case.rb

@@ -0,0 +1,17 @@
+require 'active_record/test_case.rb'
+
+# TODO: I'm struggling to figure out how to unsubscribe from only one 'sql.active_record'
+# This is a temporary hack until we can just get the sqlserver_ignored regex in rails
+ActiveSupport::Notifications.notifier.listeners_for('sql.active_record').each do |listener|
+  if listener.inspect =~ /ActiveRecord::SQLCounter/
+    ActiveSupport::Notifications.unsubscribe(listener)
+  end
+end
+
+module ActiveRecord
+  class SQLCounter
+    sqlserver_ignored =  [/SELECT SCOPE_IDENTITY/, /INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS)/, /SELECT @@version/, /SELECT @@TRANCOUNT/, /(BEGIN|COMMIT|ROLLBACK|SAVE) TRANSACTION/]
+    ignored_sql.concat sqlserver_ignored
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end

data/lib/arel/arel_sqlserver.rb

@@ -0,0 +1,5 @@
+require 'arel'
+require 'arel/select_manager_sqlserver'
+require 'arel/nodes_sqlserver'
+require 'arel/visitors/sqlserver'
+require 'arel/visitors/bind_visitor'

data/lib/arel/nodes_sqlserver.rb

@@ -0,0 +1,14 @@
+module Arel
+  module Nodes
+    # Extending the Ordering class to be comparison friendly which allows us to call #uniq on a
+    # collection of them. See SelectManager#order for more details.
+    class Ordering < Arel::Nodes::Unary
+      def eql?(other)
+        # Arel::Nodes::Ascending or Arel::Nodes::Desecnding
+        other.is_a?(Arel::Nodes::Ordering) &&
+        expr == other.expr
+      end
+      alias_method :==, :eql?
+    end
+  end
+end

data/lib/arel/select_manager_sqlserver.rb

@@ -0,0 +1,62 @@
+module Arel
+  class SelectManager < Arel::TreeManager
+    AR_CA_SQLSA_NAME = 'ActiveRecord::ConnectionAdapters::SQLServerAdapter'.freeze
+
+    # 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.
+    alias_method :order_without_sqlserver, :order
+    def order(*expr)
+      return order_without_sqlserver(*expr) unless engine_activerecord_sqlserver_adapter?
+      @ast.orders.concat(expr.map do |x|
+        case x
+        when Arel::Attributes::Attribute
+          table = Arel::Table.new(x.relation.table_alias || x.relation.name)
+          e = table[x.name]
+          Arel::Nodes::Ascending.new e
+        when Arel::Nodes::Ordering
+          x
+        when String
+          x.split(',').map do |s|
+            s = x if x.strip =~ /\A\b\w+\b\(.*,.*\)(\s+(ASC|DESC))?\Z/i # Allow functions with comma(s) to pass thru.
+            s.strip!
+            d = s =~ /(ASC|DESC)\Z/i ? Regexp.last_match[1].upcase : nil
+            e = d.nil? ? s : s.mb_chars[0...-d.length].strip
+            e = Arel.sql(e)
+            d && d == 'DESC' ? Arel::Nodes::Descending.new(e) : Arel::Nodes::Ascending.new(e)
+          end
+        else
+          e = Arel.sql(x.to_s)
+          Arel::Nodes::Ascending.new e
+        end
+      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.
+    alias_method :lock_without_sqlserver, :lock
+    def lock(locking = true)
+      if engine_activerecord_sqlserver_adapter?
+        case locking
+        when true
+          locking = Arel.sql('WITH(HOLDLOCK, ROWLOCK)')
+        when Arel::Nodes::SqlLiteral
+        when String
+          locking = Arel.sql locking
+        end
+        @ast.lock = Arel::Nodes::Lock.new(locking)
+        self
+      else
+        lock_without_sqlserver(locking)
+      end
+    end
+
+    private
+
+    def engine_activerecord_sqlserver_adapter?
+      @engine.connection && @engine.connection.class.name == AR_CA_SQLSA_NAME
+    end
+  end
+end

data/lib/arel/visitors/sqlserver.rb

@@ -1,214 +1,217 @@
-require 'arel'
-
 module Arel
-
-  module Nodes
-
-    # 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::Unary
-      def hash
-        expr.hash
-      end
-      def ==(other)
-        other.is_a?(Arel::Nodes::Ordering) && self.expr == other.expr
-      end
-      def eql?(other)
-        self == other
-      end
-    end
-
-  end
-
-  class SelectManager < Arel::TreeManager
-    
-    AR_CA_SQLSA_NAME = 'ActiveRecord::ConnectionAdapters::SQLServerAdapter'.freeze
-    
-    # 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.
-    alias :order_without_sqlserver :order
-    def order(*expr)
-      return order_without_sqlserver(*expr) unless engine_activerecord_sqlserver_adapter?
-      @ast.orders.concat(expr.map{ |x|
-        case x
-        when Arel::Attributes::Attribute
-          table = Arel::Table.new(x.relation.table_alias || x.relation.name)
-          e = table[x.name]
-          Arel::Nodes::Ascending.new e
-        when Arel::Nodes::Ordering
-          x
-        when String
-          x.split(',').map do |s|
-            s = x if x.strip =~ /\A\b\w+\b\(.*,.*\)(\s+(ASC|DESC))?\Z/i # Allow functions with comma(s) to pass thru.
-            s.strip!
-            d = s =~ /(ASC|DESC)\Z/i ? $1.upcase : nil
-            e = d.nil? ? s : s.mb_chars[0...-d.length].strip
-            e = Arel.sql(e)
-            d && d == "DESC" ? Arel::Nodes::Descending.new(e) : Arel::Nodes::Ascending.new(e)
-          end
-        else
-          e = Arel.sql(x.to_s)
-          Arel::Nodes::Ascending.new e
-        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.
-    alias :lock_without_sqlserver :lock
-    def lock(locking=true)
-      if engine_activerecord_sqlserver_adapter?
-        case locking
-        when true
-          locking = Arel.sql('WITH(HOLDLOCK, ROWLOCK)')
-        when Arel::Nodes::SqlLiteral
-        when String
-          locking = Arel.sql locking
-        end
-        @ast.lock = Arel::Nodes::Lock.new(locking)
-        self
-      else
-        lock_without_sqlserver(locking)
-      end
-    end
-    
-    private
-    
-    def engine_activerecord_sqlserver_adapter?
-      @engine.connection && @engine.connection.class.name == AR_CA_SQLSA_NAME
-    end
-    
-  end
-
   module Visitors
     class SQLServer < Arel::Visitors::ToSql
-
       private
 
       # SQLServer ToSql/Visitor (Overides)
-
-      def visit_Arel_Nodes_SelectStatement(o)
+      def visit_Arel_Nodes_SelectStatement(o, a)
         if complex_count_sql?(o)
-          visit_Arel_Nodes_SelectStatementForComplexCount(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)
+          visit_Arel_Nodes_SelectStatementWithOffset(o, a)
         else
-          visit_Arel_Nodes_SelectStatementWithOutOffset(o)
+          visit_Arel_Nodes_SelectStatementWithOutOffset(o, a)
         end
       end
-      
-      def visit_Arel_Nodes_UpdateStatement(o)
+
+      def visit_Arel_Nodes_UpdateStatement(o, a)
         if o.orders.any? && o.limit.nil?
-          o.limit = Nodes::Limit.new(9223372036854775807)
+          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
         end
         super
       end
 
-      def visit_Arel_Nodes_Offset(o)
-        "WHERE [__rnt].[__rn] > (#{visit o.expr})"
+      def visit_Arel_Nodes_Offset(o, a)
+        "WHERE [__rnt].[__rn] > (#{visit o.expr, a})"
       end
 
-      def visit_Arel_Nodes_Limit(o)
-        "TOP (#{visit o.expr})"
+      def visit_Arel_Nodes_Limit(o, a)
+        "TOP (#{visit o.expr, a})"
       end
 
-      def visit_Arel_Nodes_Lock(o)
-        visit o.expr
+      def visit_Arel_Nodes_Lock(o, a)
+        visit o.expr, a
       end
-      
-      def visit_Arel_Nodes_Ordering(o)
+
+      def visit_Arel_Nodes_Ordering(o, a)
         if o.respond_to?(:direction)
-          "#{visit o.expr} #{o.ascending? ? 'ASC' : 'DESC'}"
+          "#{visit o.expr, a} #{o.ascending? ? 'ASC' : 'DESC'}"
         else
-          visit o.expr
+          visit o.expr, a
         end
       end
-      
-      def visit_Arel_Nodes_Bin(o)
-        "#{visit o.expr} #{@connection.cs_equality_operator}"
+
+      def visit_Arel_Nodes_Bin(o, a)
+        "#{visit o.expr, a} #{@connection.cs_equality_operator}"
       end
 
       # SQLServer ToSql/Visitor (Additions)
 
-      def visit_Arel_Nodes_SelectStatementWithOutOffset(o, windowed=false)
+      # 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, '')
+        end
+
+        if o.offset
+          select_frags << 'ROW_NUMBER() OVER (ORDER BY __order) AS __offset'
+        else
+          select_frags << '__order'
+        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(' ')
+        end
+
+        sql
+      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) }
-          groups = projections.map { |x| projection_without_expression(x) } if windowed_single_distinct_select_statement?(o) && groups.empty?
+          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)
-          projections = projections.map { |x| projection_without_expression(x) }
-          groups = projections.map { |x| projection_without_expression(x) }
+        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)
+            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)
-          projections = projections.map { |x| projection_without_expression(x) }
+        elsif top_one_everything_for_through_join?(o, a)
+          projections = projections.map { |x| projection_without_expression(x, a) }
         end
-        [ ("SELECT" if !windowed),
-          (visit(core.set_quantifier) if core.set_quantifier && !windowed),
-          (visit(o.limit) if o.limit && !windowed),
-          (projections.map{ |x| v = visit(x); v == "1" ? "1 AS [__wrp]" : v }.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)
+        [
+          ('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)
+      def visit_Arel_Nodes_SelectStatementWithOffset(o, a)
         core = o.cores.first
-        o.limit ||= Arel::Nodes::Limit.new(9223372036854775807)
+        o.limit ||= Arel::Nodes::Limit.new(9_223_372_036_854_775_807)
         orders = rowtable_orders(o)
-        [ "SELECT",
-          (visit(o.limit) if o.limit && !windowed_single_distinct_select_statement?(o)),
-          (rowtable_projections(o).map{ |x| visit(x) }.join(', ')),
-          "FROM (",
-            "SELECT #{core.set_quantifier ? 'DISTINCT DENSE_RANK()' : '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),
-          "ORDER BY [__rnt].[__rn] ASC"
+        [
+          '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 ' '
       end
 
-      def visit_Arel_Nodes_SelectStatementForComplexCount(o)
+      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) 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)
+        [
+          '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 source_with_lock_for_select_statement(o)
+      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
+
+      def source_with_lock_for_select_statement(o, a)
         core = o.cores.first
-        source = "FROM #{visit(core.source).strip}" if core.source
+        source = "FROM #{visit(core.source, a).strip}" if core.source
         if source && o.lock
-          lock = visit o.lock
+          lock = visit o.lock, a
           index = source.match(/FROM [\w\[\]\.]+/)[0].mb_chars.length
           source.insert index, " #{lock}"
         else
@@ -226,7 +229,7 @@ module Arel
         # 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|
+        table_finder = lambda do |x|
           case x
           when Arel::Table
             x
@@ -235,7 +238,7 @@ module Arel
           when Arel::Nodes::Join
             table_finder.call(x.left)
           end
-        }
+        end
         table_finder.call(core.froms)
       end
 
@@ -246,25 +249,88 @@ module Arel
           ((p1.respond_to?(:distinct) && p1.distinct) ||
             p1.respond_to?(:include?) && p1.include?('DISTINCT'))
       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)
+
+          return true
+        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)
+        o.limit &&
+          o.offset &&
+          single_distinct_select_statement?(o)
       end
-      
-      def single_distinct_select_everything_statement?(o)
-        single_distinct_select_statement?(o) && visit(o.cores.first.projections.first).ends_with?(".*")
+
+      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)
-        single_distinct_select_everything_statement?(o) && 
-          (o.limit && !o.offset) && 
+
+      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)
+      def all_projections_aliased_in_select_statement?(o, a)
         projections = o.cores.first.projections
         projections.all? do |x|
-          visit(x).split(',').all? { |y| y.include?(' AS ') }
+          visit(x, a).split(',').all? { |y| y.include?(' AS ') }
         end
       end
 
@@ -273,12 +339,12 @@ module Arel
         core.projections.any? { |x| Arel::Nodes::Function === x }
       end
 
-      def eager_limiting_select_statement?(o)
+      def eager_limiting_select_statement?(o, a)
         core = o.cores.first
-        single_distinct_select_statement?(o) && 
-          (o.limit && !o.offset) && 
-          core.groups.empty? && 
-          !single_distinct_select_everything_statement?(o)
+        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)
@@ -293,7 +359,7 @@ module Arel
           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
@@ -320,22 +386,22 @@ module Arel
         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)
+        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)
+      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) if o.limit
-              p.gsub! /\[?#{tn}\]?\./, '[__rnt].'
+              p.insert 0, visit(o.limit, a) if o.limit
+              p.gsub!(/\[?#{tn}\]?\./, '[__rnt].')
               p.strip!
             end
           end
@@ -343,14 +409,14 @@ module Arel
           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.gsub! /\[?#{tn}\]?\./, '[__rnt].'
+              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)
+        elsif join_in_select_statement?(o) && all_projections_aliased_in_select_statement?(o, a)
           core.projections.map do |x|
-            Arel.sql visit(x).split(',').map{ |y| y.split(' AS ').last.strip }.join(', ')
+            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)}")]
@@ -360,7 +426,6 @@ module Arel
       end
 
       def rowtable_orders(o)
-        core = o.cores.first
         if !o.orders.empty?
           o.orders
         else
@@ -371,19 +436,17 @@ module Arel
       end
 
       # TODO: We use this for grouping too, maybe make Grouping objects vs SqlLiteral.
-      def projection_without_expression(projection)
-        Arel.sql(visit(projection).split(',').map do |x|
+      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.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