activerecord-sqlserver-adapter 8.0.10 → 8.1.0

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

@@ -4,10 +4,6 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module SchemaStatements
-        def native_database_types
-          @native_database_types ||= initialize_native_database_types.freeze
-        end
-
         def create_table(table_name, **options)
           res = super
           clear_cache!
@@ -36,19 +32,24 @@ module ActiveRecord
         end
 
         def indexes(table_name)
-          data = select("EXEC sp_helpindex #{quote(table_name)}", "SCHEMA") rescue []
+          data = begin
+            select("EXEC sp_helpindex #{quote(table_name)}", "SCHEMA")
+          rescue
+            []
+          end
 
           data.reduce([]) do |indexes, index|
-            if index['index_description'].match?(/primary key/)
+            if index["index_description"].match?(/primary key/)
               indexes
             else
-              name    = index['index_name']
-              unique  = index['index_description'].match?(/unique/)
-              where   = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}", "SCHEMA")
-              orders  = {}
+              name = index["index_name"]
+              unique = index["index_description"].match?(/unique/)
+              where = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}", "SCHEMA")
+              include_columns = index_include_columns(table_name, name)
+              orders = {}
               columns = []
 
-              index['index_keys'].split(",").each do |column|
+              index["index_keys"].split(",").each do |column|
                 column.strip!
 
                 if column.end_with?("(-)")
@@ -59,43 +60,75 @@ module ActiveRecord
                 columns << column
               end
 
-              indexes << IndexDefinition.new(table_name, name, unique, columns, where: where, orders: orders)
+              indexes << IndexDefinition.new(table_name, name, unique, columns, where: where, orders: orders, include: include_columns.presence)
             end
           end
         end
 
+        def index_include_columns(table_name, index_name)
+          sql = <<~SQL
+            SELECT
+                ic.index_id,
+                c.name AS column_name
+            FROM
+                sys.indexes i
+            JOIN
+                sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+            JOIN
+                sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+            WHERE
+                i.object_id = OBJECT_ID('#{table_name}')
+                AND i.name = '#{index_name}'
+                AND ic.is_included_column = 1;
+          SQL
+
+          select_all(sql, "SCHEMA").map { |row| row["column_name"] }
+        end
+
         def columns(table_name)
           return [] if table_name.blank?
 
-          column_definitions(table_name).map do |ci|
-            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity, :table_name
-            sql_type_metadata = fetch_type_metadata ci[:type], sqlserver_options
-            new_column(
-              ci[:name],
-              ci[:default_value],
-              sql_type_metadata,
-              ci[:null],
-              ci[:default_function],
-              ci[:collation],
-              nil,
-              sqlserver_options
-            )
+          definitions = column_definitions(table_name)
+          definitions.map do |field|
+            new_column_from_field(table_name, field, definitions)
           end
         end
 
-        def new_column(name, default, sql_type_metadata, null, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+        def new_column_from_field(_table_name, field, _definitions)
+          sqlserver_options = field.slice(:ordinal_position, :is_primary, :is_identity, :table_name)
+          sql_type_metadata = fetch_type_metadata(field[:type], sqlserver_options)
+          generated_type = extract_generated_type(field)
+
+          default_function = if generated_type.present?
+            field[:computed_formula]
+          else
+            field[:default_function]
+          end
+
           SQLServer::Column.new(
-            name,
-            default,
+            field[:name],
+            lookup_cast_type(field[:type]),
+            field[:default_value],
             sql_type_metadata,
-            null,
+            field[:null],
             default_function,
-            collation: collation,
-            comment: comment,
+            collation: field[:collation],
+            comment: nil,
+            generated_type: generated_type,
             **sqlserver_options
           )
         end
 
+        def extract_generated_type(field)
+          if field[:is_computed]
+            if field[:is_persisted]
+              :stored
+            else
+              :virtual
+            end
+          end
+        end
+
         def primary_keys(table_name)
           primaries = primary_keys_select(table_name)
           primaries.present? ? primaries : identity_columns(table_name).map(&:name)
@@ -104,8 +137,8 @@ module ActiveRecord
         def primary_keys_select(table_name)
           identifier = database_prefix_identifier(table_name)
           database = identifier.fully_qualified_database_quoted
-          sql = %{
-            SELECT #{lowercase_schema_reflection_sql('KCU.COLUMN_NAME')} AS [name]
+          sql = %(
+            SELECT #{lowercase_schema_reflection_sql("KCU.COLUMN_NAME")} AS [name]
             FROM #{database}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
             LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
               ON KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
@@ -113,11 +146,15 @@ module ActiveRecord
               AND KCU.CONSTRAINT_CATALOG = TC.CONSTRAINT_CATALOG
               AND KCU.CONSTRAINT_SCHEMA = TC.CONSTRAINT_SCHEMA
               AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
-            WHERE KCU.TABLE_NAME = #{prepared_statements ? '@0' : quote(identifier.object)}
-            AND KCU.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? '@1' : quote(identifier.schema))}
+            WHERE KCU.TABLE_NAME = #{prepared_statements ? "@0" : quote(identifier.object)}
+            AND KCU.TABLE_SCHEMA = #{if identifier.schema.blank?
+                                       "schema_name()"
+                                     else
+                                       (prepared_statements ? "@1" : quote(identifier.schema))
+                                     end}
             AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
             ORDER BY KCU.ORDINAL_POSITION ASC
-          }.gsub(/[[:space:]]/, " ")
+          ).gsub(/[[:space:]]/, " ")
 
           binds = []
           nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
@@ -160,10 +197,10 @@ module ActiveRecord
           column_object = schema_cache.columns(table_name).find { |c| c.name.to_s == column_name.to_s }
           without_constraints = options.key?(:default) || options.key?(:limit)
           default = if !options.key?(:default) && column_object
-                      column_object.default
-                    else
-                      options[:default]
-                    end
+            column_object.default
+          else
+            options[:default]
+          end
 
           if without_constraints || (column_object && column_object.type != type.to_sym)
             remove_default_constraint(table_name, column_name)
@@ -213,7 +250,7 @@ module ActiveRecord
         end
 
         def rename_index(table_name, old_name, new_name)
-          raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters" if new_name.length > index_name_length
+          raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long (#{new_name.length} characters); the limit is #{index_name_length} characters" if new_name.length > index_name_length
 
           identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{old_name}")
           execute_procedure :sp_rename, identifier.quoted, new_name, "INDEX"
@@ -241,7 +278,7 @@ module ActiveRecord
           identifier = SQLServer::Utils.extract_identifiers(table_name)
           fk_info = execute_procedure :sp_fkeys, nil, identifier.schema, nil, identifier.object, identifier.schema
 
-          grouped_fk = fk_info.group_by { |row| row["FK_NAME"] }.values.each { |group| group.sort_by! { |row| row["KEY_SEQ"] } }
+          grouped_fk = fk_info.group_by { |row| row["FK_NAME"] }.values.each { |group| group.sort_by! { |row| row["KEY_SEQ"] } }.reverse
           grouped_fk.map do |group|
             row = group.first
             options = {
@@ -293,20 +330,20 @@ module ActiveRecord
         end
 
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
-          type_limitable = %w(string integer float char nchar varchar nvarchar binary_basic).include?(type.to_s)
+          type_limitable = %w[string integer float char nchar varchar nvarchar binary_basic].include?(type.to_s)
           limit = nil unless type_limitable
 
           case type.to_s
           when "integer"
             case limit
-            when 1          then  "tinyint"
-            when 2          then  "smallint"
-            when 3..4, nil  then  "integer"
-            when 5..8       then  "bigint"
+            when 1 then "tinyint"
+            when 2 then "smallint"
+            when 3..4, nil then "integer"
+            when 5..8 then "bigint"
             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
             end
           when "time" # https://learn.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql
-            column_type_sql = type.to_s
+            column_type_sql = type.to_s.dup
             if precision
               if (0..7) === precision
                 column_type_sql << "(#{precision})"
@@ -343,18 +380,18 @@ module ActiveRecord
         # In SQL Server only the first column added should have the `ADD` keyword.
         def add_timestamps(table_name, **options)
           fragments = add_timestamps_for_alter(table_name, **options)
-          fragments[1..].each { |fragment| fragment.sub!('ADD ', '') }
-          execute "ALTER TABLE #{quote_table_name(table_name)} #{fragments.join(', ')}"
+          fragments[1..].each { |fragment| fragment.sub!("ADD ", "") }
+          execute "ALTER TABLE #{quote_table_name(table_name)} #{fragments.join(", ")}"
         end
 
         def columns_for_distinct(columns, orders)
           order_columns = orders.reject(&:blank?).map { |s|
-                            s = visitor.compile(s) unless s.is_a?(String)
-                            s.gsub(/\s+(?:ASC|DESC)\b/i, "")
-                             .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
-                            }
-                            .reject(&:blank?)
-                            .reject { |s| columns.include?(s) }
+            s = visitor.compile(s) unless s.is_a?(String)
+            s.gsub(/\s+(?:ASC|DESC)\b/i, "")
+              .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
+          }
+            .reject(&:blank?)
+            .reject { |s| columns.include?(s) }
 
           order_columns_aliased = order_columns.map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
@@ -402,24 +439,33 @@ module ActiveRecord
         # Returns an array of schema names.
         def schema_names
           sql = <<~SQL.squish
-           SELECT name
-            FROM sys.schemas
-            WHERE
-            name NOT LIKE 'db_%' AND
-            name NOT IN ('INFORMATION_SCHEMA', 'sys', 'guest')
+            SELECT name
+             FROM sys.schemas
+             WHERE
+             name NOT LIKE 'db_%' AND
+             name NOT IN ('INFORMATION_SCHEMA', 'sys', 'guest')
           SQL
 
           query_values(sql, "SCHEMA")
         end
 
+        def quoted_include_columns_for_index(column_names) # :nodoc:
+          return quote_column_name(column_names) if column_names.is_a?(Symbol)
+
+          quoted_columns = column_names.each_with_object({}) do |name, result|
+            result[name.to_sym] = quote_column_name(name).dup
+          end
+          add_options_for_index_columns(quoted_columns).values.join(", ")
+        end
+
         private
 
         def data_source_sql(name = nil, type: nil)
           scope = quoted_scope(name, type: type)
 
-          table_schema  = lowercase_schema_reflection_sql('TABLE_SCHEMA')
-          table_name    = lowercase_schema_reflection_sql('TABLE_NAME')
-          database      = scope[:database].present? ? "#{scope[:database]}." : ""
+          table_schema = lowercase_schema_reflection_sql("TABLE_SCHEMA")
+          table_name = lowercase_schema_reflection_sql("TABLE_NAME")
+          database = scope[:database].present? ? "#{scope[:database]}." : ""
           table_catalog = scope[:database].present? ? quote(scope[:database]) : "DB_NAME()"
 
           sql = "SELECT "
@@ -449,46 +495,10 @@ module ActiveRecord
 
         # === SQLServer Specific ======================================== #
 
-        def initialize_native_database_types
-          {
-            primary_key: "bigint NOT NULL IDENTITY(1,1) PRIMARY KEY",
-            primary_key_nonclustered: "bigint NOT NULL IDENTITY(1,1) PRIMARY KEY NONCLUSTERED",
-            integer: { name: "int", limit: 4 },
-            bigint: { name: "bigint" },
-            boolean: { name: "bit" },
-            decimal: { name: "decimal" },
-            money: { name: "money" },
-            smallmoney: { name: "smallmoney" },
-            float: { name: "float" },
-            real: { name: "real" },
-            date: { name: "date" },
-            datetime: { name: "datetime" },
-            datetime2: { name: "datetime2" },
-            datetimeoffset: { name: "datetimeoffset" },
-            smalldatetime: { name: "smalldatetime" },
-            timestamp: { name: "datetime2(6)" },
-            time: { name: "time" },
-            char: { name: "char" },
-            varchar: { name: "varchar", limit: 8000 },
-            varchar_max: { name: "varchar(max)" },
-            text_basic: { name: "text" },
-            nchar: { name: "nchar" },
-            string: { name: "nvarchar", limit: 4000 },
-            text: { name: "nvarchar(max)" },
-            ntext: { name: "ntext" },
-            binary_basic: { name: "binary" },
-            varbinary: { name: "varbinary", limit: 8000 },
-            binary: { name: "varbinary(max)" },
-            uuid: { name: "uniqueidentifier" },
-            ss_timestamp: { name: "timestamp" },
-            json: { name: "nvarchar(max)" }
-          }
-        end
-
         def column_definitions(table_name)
-          identifier      = database_prefix_identifier(table_name)
-          database        = identifier.fully_qualified_database_quoted
-          view_exists     = view_exists?(table_name)
+          identifier = database_prefix_identifier(table_name)
+          database = identifier.fully_qualified_database_quoted
+          view_exists = view_exists?(table_name)
 
           if view_exists
             sql = <<~SQL
@@ -510,40 +520,30 @@ module ActiveRecord
           results = internal_exec_query(sql, "SCHEMA", binds)
           raise ActiveRecord::StatementInvalid, "Table '#{table_name}' doesn't exist" if results.empty?
 
-          columns = results.map do |ci|
-            col = {
-              name:               ci["name"],
-              numeric_scale:      ci["numeric_scale"],
-              numeric_precision:  ci["numeric_precision"],
-              datetime_precision: ci["datetime_precision"],
-              collation:          ci["collation"],
-              ordinal_position:   ci["ordinal_position"],
-              length:             ci["length"]
-            }
+          results.map do |ci|
+            col = ci.slice("name", "numeric_scale", "numeric_precision", "datetime_precision", "collation", "ordinal_position", "length", "is_computed", "is_persisted", "computed_formula").symbolize_keys
 
             col[:table_name] = view_exists ? view_table_name(table_name) : table_name
             col[:type] = column_type(ci: ci)
-            col[:default_value], col[:default_function] = default_value_and_function(default: ci['default_value'],
-                                                                                     name: ci['name'],
-                                                                                     type: col[:type],
-                                                                                     original_type: ci['type'],
-                                                                                     view_exists: view_exists,
-                                                                                     table_name: table_name,
-                                                                                     default_functions: default_functions)
-
-            col[:null] = ci['is_nullable'].to_i == 1
-            col[:is_primary] = ci['is_primary'].to_i == 1
-
-            if [true, false].include?(ci['is_identity'])
-              col[:is_identity] = ci['is_identity']
+            col[:default_value], col[:default_function] = default_value_and_function(default: ci["default_value"],
+              name: ci["name"],
+              type: col[:type],
+              original_type: ci["type"],
+              view_exists: view_exists,
+              table_name: table_name,
+              default_functions: default_functions)
+
+            col[:null] = ci["is_nullable"].to_i == 1
+            col[:is_primary] = ci["is_primary"].to_i == 1
+
+            col[:is_identity] = if [true, false].include?(ci["is_identity"])
+              ci["is_identity"]
             else
-              col[:is_identity] = ci['is_identity'].to_i == 1
+              ci["is_identity"].to_i == 1
             end
 
             col
           end
-
-          columns
         end
 
         def default_value_and_function(default:, name:, type:, original_type:, view_exists:, table_name:, default_functions:)
@@ -565,9 +565,9 @@ module ActiveRecord
             [nil, nil]
           else
             type = case type
-                   when /smallint|int|bigint/ then original_type
-                   else type
-                   end
+            when /smallint|int|bigint/ then original_type
+            else type
+            end
             value = default.match(/\A\((.*)\)\Z/m)[1]
             value = select_value("SELECT CAST(#{value} AS #{type}) AS value", "SCHEMA")
             [value, nil]
@@ -575,21 +575,21 @@ module ActiveRecord
         end
 
         def column_type(ci:)
-          case ci['type']
+          case ci["type"]
           when /^bit|image|text|ntext|datetime$/
-            ci['type']
+            ci["type"]
           when /^datetime2|datetimeoffset$/i
-            "#{ci['type']}(#{ci['datetime_precision']})"
+            "#{ci["type"]}(#{ci["datetime_precision"]})"
           when /^time$/i
-            "#{ci['type']}(#{ci['datetime_precision']})"
+            "#{ci["type"]}(#{ci["datetime_precision"]})"
           when /^numeric|decimal$/i
-            "#{ci['type']}(#{ci['numeric_precision']},#{ci['numeric_scale']})"
+            "#{ci["type"]}(#{ci["numeric_precision"]},#{ci["numeric_scale"]})"
           when /^float|real$/i
-            "#{ci['type']}"
+            ci["type"]
           when /^char|nchar|varchar|nvarchar|binary|varbinary|bigint|int|smallint$/
-            ci['length'].to_i == -1 ? "#{ci['type']}(max)" : "#{ci['type']}(#{ci['length']})"
+            (ci["length"].to_i == -1) ? "#{ci["type"]}(max)" : "#{ci["type"]}(#{ci["length"]})"
           else
-            ci['type']
+            ci["type"]
           end
         end
 
@@ -610,8 +610,8 @@ module ActiveRecord
 
           %{
             SELECT
-              #{lowercase_schema_reflection_sql('o.name')} AS [table_name],
-              #{lowercase_schema_reflection_sql('c.name')} AS [name],
+              #{lowercase_schema_reflection_sql("o.name")} AS [table_name],
+              #{lowercase_schema_reflection_sql("c.name")} AS [name],
               t.name AS [type],
               d.definition AS [default_value],
               CASE
@@ -641,7 +641,10 @@ module ActiveRecord
                 WHEN ic.object_id IS NOT NULL
                 THEN 1
               END AS [is_primary],
-              c.is_identity AS [is_identity]
+              c.is_identity AS [is_identity],
+              c.is_computed AS [is_computed],
+              cc.is_persisted AS [is_persisted],
+              cc.definition AS [computed_formula]
             FROM #{database}.sys.columns c
             INNER JOIN #{database}.sys.objects o
               ON c.object_id = o.object_id
@@ -660,6 +663,9 @@ module ActiveRecord
               ON k.parent_object_id = ic.object_id
               AND k.unique_index_id = ic.index_id
               AND c.column_id = ic.column_id
+            LEFT OUTER JOIN #{database}.sys.computed_columns cc
+              ON c.object_id = cc.object_id
+              AND c.column_id = cc.column_id
             WHERE
               o.Object_ID = Object_ID(#{object_id_arg})
               AND s.name = #{schema_name}
@@ -687,7 +693,7 @@ module ActiveRecord
           execute_procedure(:sp_helpconstraint, table_name, "nomsg").flatten.select do |row|
             row["constraint_type"] == "DEFAULT on column #{column_name}"
           end.each do |row|
-            execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{row['constraint_name']}"
+            execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{row["constraint_name"]}"
           end
         end
 
@@ -718,11 +724,11 @@ module ActiveRecord
               .split(/\bSELECT\b(?![^\[]*\])/i)[0]
               .match(/\s*([^(]*)/i)[0]
           elsif s.match?(/^\s*UPDATE\s+.*/i)
-            s.match(/UPDATE\s+([^\(\s]+)\s*/i)[1]
+            s.match(/UPDATE\s+([^(\s]+)\s*/i)[1]
           elsif s.match?(/^\s*MERGE INTO.*/i)
             s.match(/^\s*MERGE\s+INTO\s+(\[?[a-z0-9_ -]+\]?\.?\[?[a-z0-9_ -]+\]?)\s+(AS|WITH|USING)/i)[1]
           else
-            s.match(/FROM[\s|\(]+((\[[^\(\]]+\])|[^\(\s]+)\s*/i)[1]
+            s.match(/FROM[\s|(]+((\[[^(\]]+\])|[^(\s]+)\s*/i)[1]
           end.strip
         end
 
@@ -746,18 +752,18 @@ module ActiveRecord
 
           @view_information[table_name] ||= begin
             identifier = SQLServer::Utils.extract_identifiers(table_name)
-            information_query_table = identifier.database.present? ? "[#{identifier.database}].[INFORMATION_SCHEMA].[VIEWS]" :  "[INFORMATION_SCHEMA].[VIEWS]"
+            information_query_table = identifier.database.present? ? "[#{identifier.database}].[INFORMATION_SCHEMA].[VIEWS]" : "[INFORMATION_SCHEMA].[VIEWS]"
 
             view_info = select_one("SELECT * FROM #{information_query_table} WITH (NOLOCK) WHERE TABLE_NAME = #{quote(identifier.object)}", "SCHEMA").to_h
 
             if view_info.present?
-              if view_info['VIEW_DEFINITION'].blank? || view_info['VIEW_DEFINITION'].length == 4000
-                view_info['VIEW_DEFINITION'] = begin
-                                                 select_values("EXEC sp_helptext #{identifier.object_quoted}", "SCHEMA").join
-                                               rescue
-                                                 warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
-                                                 nil
-                                               end
+              if view_info["VIEW_DEFINITION"].blank? || view_info["VIEW_DEFINITION"].length == 4000
+                view_info["VIEW_DEFINITION"] = begin
+                  select_values("EXEC sp_helptext #{identifier.object_quoted}", "SCHEMA").join
+                rescue
+                  warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
+                  nil
+                end
               end
             end
 
@@ -766,11 +772,11 @@ module ActiveRecord
         end
 
         def views_real_column_name(table_name, column_name)
-          view_definition = view_information(table_name)['VIEW_DEFINITION']
+          view_definition = view_information(table_name)["VIEW_DEFINITION"]
           return column_name if view_definition.blank?
 
           # Remove "CREATE VIEW ... AS SELECT ..." and then match the column name.
-          match_data = view_definition.sub(/CREATE\s+VIEW.*AS\s+SELECT\s/, '').match(/([\w-]*)\s+AS\s+#{column_name}\W/im)
+          match_data = view_definition.sub(/CREATE\s+VIEW.*AS\s+SELECT\s/, "").match(/([\w-]*)\s+AS\s+#{column_name}\W/im)
           match_data ? match_data[1] : column_name
         end
 

data/lib/active_record/connection_adapters/sqlserver/showplan/printer_table.rb

@@ -36,7 +36,7 @@ module ActiveRecord
               result.columns.each_with_index do |column, i|
                 cells_in_column = [column] + result.rows.map { |r| cast_item(r[i]) }
                 computed_width = cells_in_column.map(&:length).max
-                final_width = computed_width > max_column_width ? max_column_width : computed_width
+                final_width = (computed_width > max_column_width) ? max_column_width : computed_width
                 computed_widths << final_width
               end
             end
@@ -51,7 +51,7 @@ module ActiveRecord
             items.each_with_index do |item, i|
               cells << cast_item(item).ljust(@widths[i])
             end
-            "| #{cells.join(' | ')} |"
+            "| #{cells.join(" | ")} |"
           end
 
           def cast_item(item)

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

@@ -7,9 +7,9 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Showplan
-        OPTION_ALL  = "SHOWPLAN_ALL"
+        OPTION_ALL = "SHOWPLAN_ALL"
         OPTION_TEXT = "SHOWPLAN_TEXT"
-        OPTION_XML  = "SHOWPLAN_XML"
+        OPTION_XML = "SHOWPLAN_XML"
         OPTIONS = [OPTION_ALL, OPTION_TEXT, OPTION_XML]
 
         def explain(arel, binds = [], options = [])
@@ -30,10 +30,10 @@ module ActiveRecord
         end
 
         def set_showplan_option(enable = true)
-          sql = "SET #{showplan_option} #{enable ? 'ON' : 'OFF'}"
+          sql = "SET #{showplan_option} #{enable ? "ON" : "OFF"}"
           raw_execute(sql, "SCHEMA")
-        rescue Exception
-          raise ActiveRecordError, "#{showplan_option} could not be turned #{enable ? 'ON' : 'OFF'}, perhaps you do not have SHOWPLAN permissions?"
+        rescue
+          raise ActiveRecordError, "#{showplan_option} could not be turned #{enable ? "ON" : "OFF"}, perhaps you do not have SHOWPLAN permissions?"
         end
 
         def showplan_option

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

@@ -26,15 +26,10 @@ module ActiveRecord
             table_name == other.table_name &&
             ordinal_position == other.ordinal_position
         end
-        alias eql? ==
+        alias_method :eql?, :==
 
         def hash
-          TypeMetadata.hash ^
-            __getobj__.hash ^
-            is_identity.hash ^
-            is_primary.hash ^
-            table_name.hash ^
-            ordinal_position.hash
+          [TypeMetadata, __getobj__, is_identity, is_primary, table_name, ordinal_position].hash
         end
 
         private

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

@@ -109,6 +109,8 @@ module ActiveRecord
             type = :datetime2 unless options[:precision].nil?
           when :primary_key
             options[:is_identity] = true
+          when :virtual
+            type = options[:type]
           end
 
           super
@@ -117,7 +119,7 @@ module ActiveRecord
         private
 
         def valid_column_definition_options
-          super + [:is_identity]
+          super + [:is_identity, :as, :stored]
         end
       end
 

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

@@ -35,16 +35,16 @@ module ActiveRecord
 
             self.class == other.class && value == other.value
           end
-          alias :== :eql?
+          alias_method :==, :eql?
 
           def self.from_msgpack_ext(string)
-            type, value = string.chomp!("msgpack_ext").split(',')
+            type, value = string.chomp!("msgpack_ext").split(",")
 
             Data.new(value, type.constantize)
           end
 
           def to_msgpack_ext
-            [type.class.to_s, value].join(',') + "msgpack_ext"
+            [type.class.to_s, value].join(",") + "msgpack_ext"
           end
         end
       end

data/lib/active_record/connection_adapters/sqlserver/type/date.rb

@@ -9,12 +9,12 @@ module ActiveRecord
             "date"
           end
 
-          def serialize(value)
+          def serialize(_value)
             value = super
             return value unless value.acts_like?(:date)
 
-            date = super(value).to_formatted_s(:_sqlserver_dateformat)
-            Data.new date, self
+            date = super.to_formatted_s(:_sqlserver_dateformat)
+            Data.new(date, self)
           end
 
           def deserialize(value)