activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -4,45 +4,66 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseStatements
-        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback, :waitfor) # :nodoc:
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback, :waitfor, :use) # :nodoc:
         private_constant :READ_QUERY
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
+
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          log(sql, name, async: async) do |notification_payload|
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = if id_insert_table_name = query_requires_identity_insert?(sql)
+                         with_identity_insert_enabled(id_insert_table_name, conn) { internal_raw_execute(sql, conn, perform_do: true) }
+                       else
+                         internal_raw_execute(sql, conn, perform_do: true)
+                       end
+              verified!
+              notification_payload[:row_count] = result
+              result
+            end
+          end
         end
 
-        def execute(sql, name = nil)
-          if preventing_writes? && write_query?(sql)
-            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
-          end
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false)
+          sql = transform_query(sql)
 
-          materialize_transactions
+          check_if_write_query(sql)
           mark_transaction_written_if_write(sql)
 
-          if id_insert_table_name = query_requires_identity_insert?(sql)
-            with_identity_insert_enabled(id_insert_table_name) { do_execute(sql, name) }
-          else
-            do_execute(sql, name)
+          unless without_prepared_statement?(binds)
+            types, params = sp_executesql_types_and_parameters(binds)
+            sql = sp_executesql_sql(sql, types, params, name)
           end
-        end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          if preventing_writes? && write_query?(sql)
-            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          log(sql, name, binds, async: async) do |notification_payload|
+            with_raw_connection do |conn|
+              result = if id_insert_table_name = query_requires_identity_insert?(sql)
+                         # If the table name is a view, we need to get the base table name for enabling identity insert.
+                         id_insert_table_name = view_table_name(id_insert_table_name) if view_exists?(id_insert_table_name)
+
+                         with_identity_insert_enabled(id_insert_table_name, conn) do
+                           internal_exec_sql_query(sql, conn)
+                         end
+                       else
+                         internal_exec_sql_query(sql, conn)
+                       end
+
+              verified!
+              notification_payload[:row_count] = result.count
+              result
+            end
           end
-
-          materialize_transactions
-          mark_transaction_written_if_write(sql)
-
-          sp_executesql(sql, name, binds, prepare: prepare)
         end
 
-        def exec_insert(sql, name = nil, binds = [], pk = nil, _sequence_name = nil)
-          if id_insert_table_name = exec_insert_requires_identity?(sql, pk, binds)
-            with_identity_insert_enabled(id_insert_table_name) { super(sql, name, binds, pk) }
-          else
-            super(sql, name, binds, pk)
-          end
+        def internal_exec_sql_query(sql, conn)
+          handle = internal_raw_execute(sql, conn)
+          handle_to_names_and_values(handle, ar_result: true)
+        ensure
+          finish_statement_handle(handle)
         end
 
         def exec_delete(sql, name, binds)
@@ -56,7 +77,7 @@ module ActiveRecord
         end
 
         def begin_db_transaction
-          do_execute "BEGIN TRANSACTION", "TRANSACTION"
+          internal_execute("BEGIN TRANSACTION", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         def transaction_isolation_levels
@@ -64,33 +85,20 @@ module ActiveRecord
         end
 
         def begin_isolated_db_transaction(isolation)
-          set_transaction_isolation_level transaction_isolation_levels.fetch(isolation)
+          set_transaction_isolation_level(transaction_isolation_levels.fetch(isolation))
           begin_db_transaction
         end
 
         def set_transaction_isolation_level(isolation_level)
-          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}", "TRANSACTION"
+          internal_execute("SET TRANSACTION ISOLATION LEVEL #{isolation_level}", "TRANSACTION", allow_retry: true, materialize_transactions: false)
         end
 
         def commit_db_transaction
-          do_execute "COMMIT TRANSACTION", "TRANSACTION"
+          internal_execute("COMMIT TRANSACTION", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         def exec_rollback_db_transaction
-          do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION", "TRANSACTION"
-        end
-
-        include Savepoints
-
-        def create_savepoint(name = current_savepoint_name)
-          do_execute "SAVE TRANSACTION #{name}", "TRANSACTION"
-        end
-
-        def exec_rollback_to_savepoint(name = current_savepoint_name)
-          do_execute "ROLLBACK TRANSACTION #{name}", "TRANSACTION"
-        end
-
-        def release_savepoint(name = current_savepoint_name)
+          internal_execute("IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION", "TRANSACTION", allow_retry: false, materialize_transactions: true)
         end
 
         def case_sensitive_comparison(attribute, value)
@@ -145,7 +153,12 @@ module ActiveRecord
           sql = +"INSERT #{insert.into}"
 
           if returning = insert.send(:insert_all).returning
-            sql << " OUTPUT " << returning.map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
+            returning_sql = if returning.is_a?(String)
+                              returning
+                            else
+                              returning.map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
+                            end
+            sql << " OUTPUT #{returning_sql}"
           end
 
           sql << " #{insert.values_list}"
@@ -155,42 +168,44 @@ module ActiveRecord
         # === SQLServer Specific ======================================== #
 
         def execute_procedure(proc_name, *variables)
-          materialize_transactions
-
           vars = if variables.any? && variables.first.is_a?(Hash)
                    variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
                  else
                    variables.map { |v| quote(v) }
                  end.join(", ")
           sql = "EXEC #{proc_name} #{vars}".strip
-          name = "Execute Procedure"
-          log(sql, name) do
-            case @connection_options[:mode]
-            when :dblib
-              result = ensure_established_connection! { dblib_execute(sql) }
-              options = { as: :hash, cache_rows: true, timezone: ActiveRecord::Base.default_timezone || :utc }
+
+          log(sql, "Execute Procedure") do |notification_payload|
+            with_raw_connection do |conn|
+              result = internal_raw_execute(sql, conn)
+              verified!
+              options = { as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc }
+
               result.each(options) do |row|
                 r = row.with_indifferent_access
                 yield(r) if block_given?
               end
-              result.each.map { |row| row.is_a?(Hash) ? row.with_indifferent_access : row }
+
+              result = result.each.map { |row| row.is_a?(Hash) ? row.with_indifferent_access : row }
+              notification_payload[:row_count] = result.count
+              result
             end
           end
         end
 
-        def with_identity_insert_enabled(table_name)
+        def with_identity_insert_enabled(table_name, conn)
           table_name = quote_table_name(table_name)
-          set_identity_insert(table_name, true)
+          set_identity_insert(table_name, conn, true)
           yield
         ensure
-          set_identity_insert(table_name, false)
+          set_identity_insert(table_name, conn, false)
         end
 
         def use_database(database = nil)
           return if sqlserver_azure?
 
-          name = SQLServer::Utils.extract_identifiers(database || @connection_options[:database]).quoted
-          do_execute "USE #{name}" unless name.blank?
+          name = SQLServer::Utils.extract_identifiers(database || @connection_parameters[:database]).quoted
+          execute("USE #{name}", "SCHEMA") unless name.blank?
         end
 
         def user_options
@@ -254,59 +269,56 @@ module ActiveRecord
 
         protected
 
-        def sql_for_insert(sql, pk, binds)
+        def sql_for_insert(sql, pk, binds, returning)
           if pk.nil?
             table_name = query_requires_identity_insert?(sql)
             pk = primary_key(table_name)
           end
 
           sql = if pk && use_output_inserted? && !database_prefix_remote_server?
-                  quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
                   table_name ||= get_table_name(sql)
                   exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
 
                   if exclude_output_inserted
-                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
+                    pk_and_types = Array(pk).map do |subkey|
+                      {
+                        quoted: SQLServer::Utils.extract_identifiers(subkey).quoted,
+                        id_sql_type: exclude_output_inserted_id_sql_type(subkey, exclude_output_inserted)
+                      }
+                    end
+
                     <<~SQL.squish
-                      DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
-                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
-                      SELECT CAST(#{quoted_pk} AS #{id_sql_type}) FROM @ssaIdInsertTable
+                      DECLARE @ssaIdInsertTable table (#{pk_and_types.map { |pk_and_type| "#{pk_and_type[:quoted]} #{pk_and_type[:id_sql_type]}"}.join(", ") });
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT #{ pk_and_types.map { |pk_and_type| "INSERTED.#{pk_and_type[:quoted]}" }.join(", ") } INTO @ssaIdInsertTable"}
+                      SELECT #{pk_and_types.map {|pk_and_type| "CAST(#{pk_and_type[:quoted]} AS #{pk_and_type[:id_sql_type]}) #{pk_and_type[:quoted]}"}.join(", ")} FROM @ssaIdInsertTable
                     SQL
                   else
-                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                    returning_columns = returning || Array(pk)
+
+                    if returning_columns.any?
+                      returning_columns_statements = returning_columns.map { |c| " INSERTED.#{SQLServer::Utils.extract_identifiers(c).quoted}" }
+                      sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT" + returning_columns_statements.join(",")
+                    else
+                      sql
+                    end
                   end
                 else
                   "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
                 end
-          super
+
+          [sql, binds]
         end
 
         # === SQLServer Specific ======================================== #
 
-        def set_identity_insert(table_name, enable = true)
-          do_execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+        def set_identity_insert(table_name, conn, enable)
+          internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}", conn , perform_do: true)
         rescue Exception
           raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
         end
 
         # === SQLServer Specific (Executing) ============================ #
 
-        def do_execute(sql, name = "SQL")
-          materialize_transactions
-          mark_transaction_written_if_write(sql)
-
-          log(sql, name) { raw_connection_do(sql) }
-        end
-
-        def sp_executesql(sql, name, binds, options = {})
-          options[:ar_result] = true if options[:fetch] != :rows
-          unless without_prepared_statement?(binds)
-            types, params = sp_executesql_types_and_parameters(binds)
-            sql = sp_executesql_sql(sql, types, params, name)
-          end
-          raw_select sql, name, binds, options
-        end
-
         def sp_executesql_types_and_parameters(binds)
           types, params = [], []
           binds.each_with_index do |attr, index|
@@ -319,10 +331,17 @@ module ActiveRecord
         end
 
         def sp_executesql_sql_type(attr)
-          return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
+          if attr.respond_to?(:type)
+            return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
 
-          case value = attr.value_for_database
-          when Numeric
+            if attr.type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType) && attr.type.instance_variable_get(:@cast_type).respond_to?(:sqlserver_type)
+              return attr.type.instance_variable_get(:@cast_type).sqlserver_type
+            end
+          end
+
+          value = active_model_attribute?(attr) ? attr.value_for_database : attr
+
+          if value.is_a?(Numeric)
             value > 2_147_483_647 ? "bigint".freeze : "int".freeze
           else
             "nvarchar(max)".freeze
@@ -330,15 +349,20 @@ module ActiveRecord
         end
 
         def sp_executesql_sql_param(attr)
+          return quote(attr) unless active_model_attribute?(attr)
+
           case value = attr.value_for_database
-          when Type::Binary::Data,
-               ActiveRecord::Type::SQLServer::Data
+          when Type::Binary::Data, ActiveRecord::Type::SQLServer::Data
             quote(value)
           else
             quote(type_cast(value))
           end
         end
 
+        def active_model_attribute?(type)
+          type.is_a?(::ActiveModel::Attribute)
+        end
+
         def sp_executesql_sql(sql, types, params, name)
           if name == "EXPLAIN"
             params.each.with_index do |param, index|
@@ -351,17 +375,7 @@ module ActiveRecord
             sql = "EXEC sp_executesql #{quote(sql)}"
             sql += ", #{types}, #{params}" unless params.empty?
           end
-          sql
-        end
-
-        def raw_connection_do(sql)
-          case @connection_options[:mode]
-          when :dblib
-            result = ensure_established_connection! { dblib_execute(sql) }
-            result.do
-          end
-        ensure
-          @update_sql = false
+          sql.freeze
         end
 
         # === SQLServer Specific (Identity Inserts) ===================== #
@@ -383,23 +397,23 @@ module ActiveRecord
           self.class.exclude_output_inserted_table_names[table_name]
         end
 
-        def exec_insert_requires_identity?(sql, pk, binds)
-          query_requires_identity_insert?(sql)
+        def exclude_output_inserted_id_sql_type(pk, exclude_output_inserted)
+          return "bigint" if exclude_output_inserted.is_a?(TrueClass)
+          return exclude_output_inserted[pk.to_sym] if exclude_output_inserted.is_a?(Hash)
+          exclude_output_inserted
         end
 
         def query_requires_identity_insert?(sql)
-          if insert_sql?(sql)
-            table_name = get_table_name(sql)
-            id_column = identity_columns(table_name).first
-            # id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
-            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? table_name : false
-          else
-            false
-          end
+          return false unless insert_sql?(sql)
+
+          raw_table_name = get_raw_table_name(sql)
+          id_column = identity_columns(raw_table_name).first
+
+          id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? SQLServer::Utils.extract_identifiers(raw_table_name).quoted : false
         end
 
         def insert_sql?(sql)
-          !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
+          !(sql =~ /\A\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
         end
 
         def identity_columns(table_name)
@@ -408,68 +422,42 @@ module ActiveRecord
 
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name = "SQL", binds = [], options = {})
-          log(sql, name, binds) { _raw_select(sql, options) }
-        end
-
-        def _raw_select(sql, options = {})
-          handle = raw_connection_run(sql)
-          handle_to_names_and_values(handle, options)
+        def _raw_select(sql, conn)
+          handle = internal_raw_execute(sql, conn)
+          handle_to_names_and_values(handle, fetch: :rows)
         ensure
           finish_statement_handle(handle)
         end
 
-        def raw_connection_run(sql)
-          case @connection_options[:mode]
-          when :dblib
-            ensure_established_connection! { dblib_execute(sql) }
-          end
-        end
-
-        def handle_more_results?(handle)
-          case @connection_options[:mode]
-          when :dblib
-          end
-        end
-
         def handle_to_names_and_values(handle, options = {})
-          case @connection_options[:mode]
-          when :dblib
-            handle_to_names_and_values_dblib(handle, options)
-          end
-        end
-
-        def handle_to_names_and_values_dblib(handle, options = {})
           query_options = {}.tap do |qo|
-            qo[:timezone] = ActiveRecord::Base.default_timezone || :utc
+            qo[:timezone] = ActiveRecord.default_timezone || :utc
             qo[:as] = (options[:ar_result] || options[:fetch] == :rows) ? :array : :hash
           end
           results = handle.each(query_options)
-          columns = lowercase_schema_reflection ? handle.fields.map { |c| c.downcase } : handle.fields
+
+          columns = handle.fields
+          # If query returns multiple result sets, only return the columns of the last one.
+          columns = columns.last if columns.any? && columns.all? { |e| e.is_a?(Array) }
+          columns = columns.map(&:downcase) if lowercase_schema_reflection
+
           options[:ar_result] ? ActiveRecord::Result.new(columns, results) : results
         end
 
         def finish_statement_handle(handle)
-          case @connection_options[:mode]
-          when :dblib
-            handle.cancel if handle
-          end
+          handle.cancel if handle
           handle
         end
 
-        def dblib_execute(sql)
-          @connection.execute(sql).tap do |result|
-            # TinyTDS returns false instead of raising an exception if connection fails.
-            # Getting around this by raising an exception ourselves while this PR
-            # https://github.com/rails-sqlserver/tiny_tds/pull/469 is not released.
-            raise TinyTds::Error, "failed to execute statement" if result.is_a?(FalseClass)
+        # TinyTDS returns false instead of raising an exception if connection fails.
+        # Getting around this by raising an exception ourselves while PR
+        # https://github.com/rails-sqlserver/tiny_tds/pull/469 is not released.
+        def internal_raw_execute(sql, conn, perform_do: false)
+          result = conn.execute(sql).tap do |_result|
+            raise TinyTds::Error, "failed to execute statement" if _result.is_a?(FalseClass)
           end
-        end
 
-        def ensure_established_connection!
-          raise TinyTds::Error, 'SQL Server client is not connected' unless @connection
-
-          yield
+          perform_do ? result.do : result
         end
       end
     end

data/lib/active_record/connection_adapters/sqlserver/database_tasks.rb

@@ -8,13 +8,13 @@ module ActiveRecord
           name = SQLServer::Utils.extract_identifiers(database)
           db_options = create_database_options(options)
           edition_options = create_database_edition_options(options)
-          do_execute "CREATE DATABASE #{name} #{db_options} #{edition_options}"
+          execute "CREATE DATABASE #{name} #{db_options} #{edition_options}"
         end
 
         def drop_database(database)
           name = SQLServer::Utils.extract_identifiers(database)
-          do_execute "ALTER DATABASE #{name} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
-          do_execute "DROP DATABASE #{name}"
+          execute "ALTER DATABASE #{name} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
+          execute "DROP DATABASE #{name}"
         end
 
         def current_database
@@ -33,7 +33,7 @@ module ActiveRecord
 
         def create_database_options(options = {})
           keys  = [:collate]
-          copts = @connection_options
+          copts = @connection_parameters
           options = {
             collate: copts[:collation]
           }.merge(options.symbolize_keys).select { |_, v|
@@ -46,7 +46,7 @@ module ActiveRecord
 
         def create_database_edition_options(options = {})
           keys  = [:maxsize, :edition, :service_objective]
-          copts = @connection_options
+          copts = @connection_parameters
           edition_options = {
             maxsize: copts[:azure_maxsize],
             edition: copts[:azure_edition],

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -4,18 +4,62 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Quoting
-        QUOTED_TRUE  = "1".freeze
-        QUOTED_FALSE = "0".freeze
-        QUOTED_STRING_PREFIX = "N".freeze
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+                  ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\]) | \w+\((?:|\g<2>)\))
+                )
+                (?:\s+AS\s+(?:\w+|\[\w+\]))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+                  ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\]) | \w+\((?:|\g<2>)\))
+                )
+                (?:\s+COLLATE\s+\w+)?
+                (?:\s+ASC|\s+DESC)?
+                (?:\s+NULLS\s+(?:FIRST|LAST))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= SQLServer::Utils.extract_identifiers(name).quoted
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= SQLServer::Utils.extract_identifiers(name).quoted
+          end
+        end
 
         def fetch_type_metadata(sql_type, sqlserver_options = {})
           cast_type = lookup_cast_type(sql_type)
+
           simple_type = SqlTypeMetadata.new(
-            sql_type: sql_type,
-            type: cast_type.type,
-            limit: cast_type.limit,
+            sql_type:  sql_type,
+            type:      cast_type.type,
+            limit:     cast_type.limit,
             precision: cast_type.precision,
-            scale: cast_type.scale
+            scale:     cast_type.scale
           )
 
           SQLServer::TypeMetadata.new(simple_type, **sqlserver_options)
@@ -33,13 +77,9 @@ module ActiveRecord
           SQLServer::Utils.quote_string_single_national(s)
         end
 
-        def quote_column_name(name)
-          SQLServer::Utils.extract_identifiers(name).quoted
-        end
-
         def quote_default_expression(value, column)
           cast_type = lookup_cast_type(column.sql_type)
-          if cast_type.type == :uuid && value =~ /\(\)/
+          if cast_type.type == :uuid && value.is_a?(String) && value.include?('()')
             value
           else
             super
@@ -47,7 +87,7 @@ module ActiveRecord
         end
 
         def quoted_true
-          QUOTED_TRUE
+          '1'
         end
 
         def unquoted_true
@@ -55,7 +95,7 @@ module ActiveRecord
         end
 
         def quoted_false
-          QUOTED_FALSE
+          '0'
         end
 
         def unquoted_false
@@ -72,59 +112,20 @@ module ActiveRecord
           end
         end
 
-        def column_name_matcher
-          COLUMN_NAME
-        end
-
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
-        end
-
-        COLUMN_NAME = /
-          \A
-          (
-            (?:
-              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
-            )
-            (?:\s+AS\s+(?:\w+|\[\w+\]))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        COLUMN_NAME_WITH_ORDER = /
-          \A
-          (
-            (?:
-              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
-            )
-            (?:\s+ASC|\s+DESC)?
-            (?:\s+NULLS\s+(?:FIRST|LAST))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
-        private
-
-        def _quote(value)
+        def quote(value)
           case value
           when Type::Binary::Data
             "0x#{value.hex}"
           when ActiveRecord::Type::SQLServer::Data
             value.quoted
           when String, ActiveSupport::Multibyte::Chars
-            "#{QUOTED_STRING_PREFIX}#{super}"
+            "N#{super}"
           else
             super
           end
         end
 
-        def _type_cast(value)
+        def type_cast(value)
           case value
           when ActiveRecord::Type::SQLServer::Data
             value.to_s