activerecord-sqlserver-adapter 5.2.1 → 7.0.0.0

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

@@ -1,9 +1,27 @@
+# frozen_string_literal: true
+
 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:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
+        end
 
         def execute(sql, name = nil)
+          sql = transform_query(sql)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+          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
@@ -11,8 +29,16 @@ module ActiveRecord
           end
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
-          sp_executesql(sql, name, binds, prepare: prepare)
+        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false)
+          sql = transform_query(sql)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+          mark_transaction_written_if_write(sql)
+
+          sp_executesql(sql, name, binds, prepare: prepare, async: async)
         end
 
         def exec_insert(sql, name = nil, binds = [], pk = nil, _sequence_name = nil)
@@ -24,17 +50,17 @@ module ActiveRecord
         end
 
         def exec_delete(sql, name, binds)
-          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
           super(sql, name, binds).rows.first.first
         end
 
         def exec_update(sql, name, binds)
-          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
           super(sql, name, binds).rows.first.first
         end
 
         def begin_db_transaction
-          do_execute 'BEGIN TRANSACTION'
+          do_execute "BEGIN TRANSACTION", "TRANSACTION"
         end
 
         def transaction_isolation_levels
@@ -47,33 +73,35 @@ module ActiveRecord
         end
 
         def set_transaction_isolation_level(isolation_level)
-          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}"
+          do_execute "SET TRANSACTION ISOLATION LEVEL #{isolation_level}", "TRANSACTION"
         end
 
         def commit_db_transaction
-          do_execute 'COMMIT TRANSACTION'
+          do_execute "COMMIT TRANSACTION", "TRANSACTION"
         end
 
         def exec_rollback_db_transaction
-          do_execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+          do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION", "TRANSACTION"
         end
 
         include Savepoints
 
         def create_savepoint(name = current_savepoint_name)
-          do_execute "SAVE TRANSACTION #{name}"
+          do_execute "SAVE TRANSACTION #{name}", "TRANSACTION"
         end
 
         def exec_rollback_to_savepoint(name = current_savepoint_name)
-          do_execute "ROLLBACK TRANSACTION #{name}"
+          do_execute "ROLLBACK TRANSACTION #{name}", "TRANSACTION"
         end
 
         def release_savepoint(name = current_savepoint_name)
         end
 
-        def case_sensitive_comparison(table, attribute, column, value)
+        def case_sensitive_comparison(attribute, value)
+          column = column_for_attribute(attribute)
+
           if column.collation && !column.case_sensitive?
-            table[attribute].eq(Arel::Nodes::Bin.new(value))
+            attribute.eq(Arel::Nodes::Bin.new(value))
           else
             super
           end
@@ -89,12 +117,12 @@ module ActiveRecord
             end
           end
 
-          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
-          total_sql = Array.wrap(combine_multi_statements(table_deletes + fixture_inserts))
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}" }
+          total_sqls = Array.wrap(table_deletes + fixture_inserts)
 
           disable_referential_integrity do
             transaction(requires_new: true) do
-              total_sql.each do |sql|
+              total_sqls.each do |sql|
                 execute sql, "Fixtures Load"
                 yield if block_given?
               end
@@ -107,11 +135,6 @@ module ActiveRecord
         end
         private :can_perform_case_insensitive_comparison_for?
 
-        def combine_multi_statements(total_sql)
-          total_sql
-        end
-        private :combine_multi_statements
-
         def default_insert_value(column)
           if column.is_identity?
             table_name = quote(quote_table_name(column.table_name))
@@ -122,21 +145,39 @@ module ActiveRecord
         end
         private :default_insert_value
 
+        def build_insert_sql(insert) # :nodoc:
+          sql = +"INSERT #{insert.into}"
+
+          if returning = insert.send(:insert_all).returning
+            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}"
+          sql
+        end
+
         # === 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(', ')
+                 end.join(", ")
           sql = "EXEC #{proc_name} #{vars}".strip
-          name = 'Execute Procedure'
+          name = "Execute Procedure"
           log(sql, name) do
             case @connection_options[:mode]
             when :dblib
-              result = @connection.execute(sql)
-              options = { as: :hash, cache_rows: true, timezone: ActiveRecord::Base.default_timezone || :utc }
+              result = ensure_established_connection! { dblib_execute(sql) }
+              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?
@@ -156,20 +197,22 @@ module ActiveRecord
 
         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?
         end
 
         def user_options
           return {} if sqlserver_azure?
-          rows = select_rows('DBCC USEROPTIONS WITH NO_INFOMSGS', 'SCHEMA')
+
+          rows = select_rows("DBCC USEROPTIONS WITH NO_INFOMSGS", "SCHEMA")
           rows = rows.first if rows.size == 2 && rows.last.empty?
           rows.reduce(HashWithIndifferentAccess.new) do |values, row|
             if row.instance_of? Hash
-              set_option = row.values[0].gsub(/\s+/, '_')
+              set_option = row.values[0].gsub(/\s+/, "_")
               user_value = row.values[1]
-            elsif  row.instance_of? Array
-              set_option = row[0].gsub(/\s+/, '_')
+            elsif row.instance_of? Array
+              set_option = row[0].gsub(/\s+/, "_")
               user_value = row[1]
             end
             values[set_option] = user_value
@@ -179,9 +222,9 @@ module ActiveRecord
 
         def user_options_dateformat
           if sqlserver_azure?
-            select_value 'SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID', 'SCHEMA'
+            select_value "SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID", "SCHEMA"
           else
-            user_options['dateformat']
+            user_options["dateformat"]
           end
         end
 
@@ -196,43 +239,44 @@ module ActiveRecord
                     WHEN 5 THEN 'SNAPSHOT' END AS [isolation_level]
                     FROM [sys].[dm_exec_sessions]
                     WHERE [session_id] = @@SPID).squish
-            select_value sql, 'SCHEMA'
+            select_value sql, "SCHEMA"
           else
-            user_options['isolation_level']
+            user_options["isolation_level"]
           end
         end
 
         def user_options_language
           if sqlserver_azure?
-            select_value 'SELECT @@LANGUAGE AS [language]', 'SCHEMA'
+            select_value "SELECT @@LANGUAGE AS [language]", "SCHEMA"
           else
-            user_options['language']
+            user_options["language"]
           end
         end
 
         def newid_function
-          select_value 'SELECT NEWID()'
+          select_value "SELECT NEWID()"
         end
 
         def newsequentialid_function
-          select_value 'SELECT NEWSEQUENTIALID()'
+          select_value "SELECT NEWSEQUENTIALID()"
         end
 
-
         protected
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        def sql_for_insert(sql, pk, binds)
           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
-                    <<-SQL.strip_heredoc
+                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
+                    <<~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
@@ -256,7 +300,10 @@ module ActiveRecord
 
         # === SQLServer Specific (Executing) ============================ #
 
-        def do_execute(sql, name = 'SQL')
+        def do_execute(sql, name = "SQL")
+          materialize_transactions
+          mark_transaction_written_if_write(sql)
+
           log(sql, name) { raw_connection_do(sql) }
         end
 
@@ -282,11 +329,12 @@ module ActiveRecord
 
         def sp_executesql_sql_type(attr)
           return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
+
           case value = attr.value_for_database
           when Numeric
-            value > 2_147_483_647 ? 'bigint'.freeze : 'int'.freeze
+            value > 2_147_483_647 ? "bigint".freeze : "int".freeze
           else
-            'nvarchar(max)'.freeze
+            "nvarchar(max)".freeze
           end
         end
 
@@ -301,16 +349,16 @@ module ActiveRecord
         end
 
         def sp_executesql_sql(sql, types, params, name)
-          if name == 'EXPLAIN'
+          if name == "EXPLAIN"
             params.each.with_index do |param, index|
               substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
               sql = sql.sub substitute_at_finder, param.to_s
             end
           else
-            types = quote(types.join(', '))
-            params = params.map.with_index{ |p, i| "@#{i} = #{p}" }.join(', ') # Only p is needed, but with @i helps explain regexp.
+            types = quote(types.join(", "))
+            params = params.map.with_index { |p, i| "@#{i} = #{p}" }.join(", ") # Only p is needed, but with @i helps explain regexp.
             sql = "EXEC sp_executesql #{quote(sql)}"
-            sql << ", #{types}, #{params}" unless params.empty?
+            sql += ", #{types}, #{params}" unless params.empty?
           end
           sql
         end
@@ -318,7 +366,8 @@ module ActiveRecord
         def raw_connection_do(sql)
           case @connection_options[:mode]
           when :dblib
-            @connection.execute(sql).do
+            result = ensure_established_connection! { dblib_execute(sql) }
+            result.do
           end
         ensure
           @update_sql = false
@@ -336,8 +385,10 @@ module ActiveRecord
 
         def exclude_output_inserted_table_name?(table_name, sql)
           return false unless exclude_output_inserted_table_names?
+
           table_name ||= get_table_name(sql)
           return false unless table_name
+
           self.class.exclude_output_inserted_table_names[table_name]
         end
 
@@ -366,8 +417,8 @@ module ActiveRecord
 
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name = 'SQL', binds = [], options = {})
-          log(sql, name, binds) { _raw_select(sql, options) }
+        def raw_select(sql, name = "SQL", binds = [], options = {})
+          log(sql, name, binds, async: options[:async]) { _raw_select(sql, options) }
         end
 
         def _raw_select(sql, options = {})
@@ -380,7 +431,7 @@ module ActiveRecord
         def raw_connection_run(sql)
           case @connection_options[:mode]
           when :dblib
-            @connection.execute(sql)
+            ensure_established_connection! { dblib_execute(sql) }
           end
         end
 
@@ -399,7 +450,7 @@ module ActiveRecord
 
         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)
@@ -415,6 +466,20 @@ module ActiveRecord
           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)
+          end
+        end
+
+        def ensure_established_connection!
+          raise TinyTds::Error, 'SQL Server client is not connected' unless @connection
+
+          yield
+        end
       end
     end
   end

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseTasks
-
         def create_database(database, options = {})
           name = SQLServer::Utils.extract_identifiers(database)
           db_options = create_database_options(options)
@@ -17,7 +18,7 @@ module ActiveRecord
         end
 
         def current_database
-          select_value 'SELECT DB_NAME()'
+          select_value "SELECT DB_NAME()"
         end
 
         def charset
@@ -30,20 +31,20 @@ module ActiveRecord
 
         private
 
-        def create_database_options(options={})
+        def create_database_options(options = {})
           keys  = [:collate]
           copts = @connection_options
           options = {
             collate: copts[:collation]
           }.merge(options.symbolize_keys).select { |_, v|
             v.present?
-          }.slice(*keys).map { |k,v|
+          }.slice(*keys).map { |k, v|
             "#{k.to_s.upcase} #{v}"
-          }.join(' ')
+          }.join(" ")
           options
         end
 
-        def create_database_edition_options(options={})
+        def create_database_edition_options(options = {})
           keys  = [:maxsize, :edition, :service_objective]
           copts = @connection_options
           edition_options = {
@@ -52,17 +53,13 @@ module ActiveRecord
             service_objective: copts[:azure_service_objective]
           }.merge(options.symbolize_keys).select { |_, v|
             v.present?
-          }.slice(*keys).map { |k,v|
+          }.slice(*keys).map { |k, v|
             "#{k.to_s.upcase} = #{v}"
-          }.join(', ')
+          }.join(", ")
           edition_options = "( #{edition_options} )" if edition_options.present?
           edition_options
         end
-
       end
     end
   end
 end
-
-
-

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

@@ -1,7 +1,6 @@
-module ActiveRecord
+# frozen_string_literal: true
 
+module ActiveRecord
   class DeadlockVictim < WrappedDatabaseException
   end
-
-
 end

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

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Quoting
-
-        QUOTED_TRUE  = '1'.freeze
-        QUOTED_FALSE = '0'.freeze
-        QUOTED_STRING_PREFIX = 'N'.freeze
+        QUOTED_TRUE  = "1".freeze
+        QUOTED_FALSE = "0".freeze
+        QUOTED_STRING_PREFIX = "N".freeze
 
         def fetch_type_metadata(sql_type, sqlserver_options = {})
           cast_type = lookup_cast_type(sql_type)
-          SQLServer::SqlTypeMetadata.new(
+          simple_type = SqlTypeMetadata.new(
             sql_type: sql_type,
             type: cast_type.type,
             limit: cast_type.limit,
             precision: cast_type.precision,
-            scale: cast_type.scale,
-            sqlserver_options: sqlserver_options
+            scale: cast_type.scale
           )
+
+          SQLServer::TypeMetadata.new(simple_type, **sqlserver_options)
         end
 
         def quote_string(s)
@@ -61,17 +63,53 @@ module ActiveRecord
         end
 
         def quoted_date(value)
-          if value.acts_like?(:date)
-            Type::Date.new.serialize(value)
-          else value.acts_like?(:time)
+          if value.acts_like?(:time)
             Type::DateTime.new.serialize(value)
+          elsif value.acts_like?(:date)
+            Type::Date.new.serialize(value)
+          else
+            value
           end
         end
 
+        def column_name_matcher
+          COLUMN_NAME
+        end
 
-        private
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
 
-        def _quote(value)
+        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
+
+        def quote(value)
           case value
           when Type::Binary::Data
             "0x#{value.hex}"
@@ -84,7 +122,7 @@ module ActiveRecord
           end
         end
 
-        def _type_cast(value)
+        def type_cast(value)
           case value
           when ActiveRecord::Type::SQLServer::Data
             value.to_s
@@ -92,7 +130,6 @@ module ActiveRecord
             super
           end
         end
-
       end
     end
   end

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

@@ -1,20 +1,52 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
-      class SchemaCreation < AbstractAdapter::SchemaCreation
-
+      class SchemaCreation < SchemaCreation
         private
 
+        def supports_index_using?
+          false
+        end
+
         def visit_TableDefinition(o)
+          if_not_exists = o.if_not_exists
+
           if o.as
             table_name = quote_table_name(o.temporary ? "##{o.name}" : o.name)
             query = o.as.respond_to?(:to_sql) ? o.as.to_sql : o.as
             projections, source = query.match(%r{SELECT\s+(.*)?\s+FROM\s+(.*)?}).captures
-            select_into = "SELECT #{projections} INTO #{table_name} FROM #{source}"
+            sql = "SELECT #{projections} INTO #{table_name} FROM #{source}"
           else
             o.instance_variable_set :@as, nil
-            super
+            o.instance_variable_set :@if_not_exists, false
+            sql = super
+          end
+
+          if if_not_exists
+            o.instance_variable_set :@if_not_exists, true
+            table_name = o.temporary ? "##{o.name}" : o.name
+            sql = "IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='#{table_name}' and xtype='U') #{sql}"
           end
+
+          sql
+        end
+
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = []
+          sql << "IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = '#{o.index.name}')" if o.if_not_exists
+          sql << "CREATE"
+          sql << "UNIQUE" if index.unique
+          sql << index.type.upcase if index.type
+          sql << "INDEX"
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "(#{quoted_columns(index)})"
+          sql << "WHERE #{index.where}" if index.where
+
+          sql.join(" ")
         end
 
         def add_column_options!(sql, options)
@@ -22,6 +54,9 @@ module ActiveRecord
           if options[:null] == false
             sql << " NOT NULL"
           end
+          if options[:collation].present?
+            sql << " COLLATE #{options[:collation]}"
+          end
           if options[:is_identity] == true
             sql << " IDENTITY(1,1)"
           end
@@ -34,7 +69,7 @@ module ActiveRecord
         def action_sql(action, dependency)
           case dependency
           when :restrict
-            raise ArgumentError, <<-MSG.strip_heredoc
+            raise ArgumentError, <<~MSG.squish
               '#{dependency}' is not supported for :on_update or :on_delete.
               Supported values are: :nullify, :cascade
             MSG
@@ -50,7 +85,6 @@ module ActiveRecord
         def options_primary_key_with_nil_default?(options)
           options[:primary_key] && options.include?(:default) && options[:default].nil?
         end
-
       end
     end
   end