activerecord-sqlserver-adapter 8.0.10 → 8.1.0

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

@@ -11,13 +11,12 @@ module ActiveRecord
             "datetime"
           end
 
-          def serialize(value)
+          def serialize(_value)
             value = super
             return value unless value.acts_like?(:time)
 
             datetime = "#{value.to_formatted_s(:_sqlserver_datetime)}.#{quote_fractional(value)}"
-
-            Data.new datetime, self
+            Data.new(datetime, self)
           end
 
           def deserialize(value)
@@ -37,7 +36,7 @@ module ActiveRecord
           def fast_string_to_time(string)
             time = ActiveSupport::TimeZone["UTC"].strptime(string, fast_string_to_time_format)
             new_time(time.year, time.month, time.day, time.hour,
-                     time.min, time.sec, Rational(time.nsec, 1_000))
+              time.min, time.sec, Rational(time.nsec, 1_000))
           rescue ArgumentError
             super
           end

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

@@ -20,7 +20,7 @@ module ActiveRecord
           end
 
           def apply_seconds_precision(value)
-            value.change usec: 0 if value
+            value&.change(usec: 0)
           end
         end
       end

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

@@ -7,13 +7,12 @@ module ActiveRecord
         class Time < ActiveRecord::Type::Time
           include TimeValueFractional2
 
-          def serialize(value)
+          def serialize(_value)
             value = super
             return value unless value.acts_like?(:time)
 
             time = "#{value.to_formatted_s(:_sqlserver_time)}.#{quote_fractional(value)}"
-
-            Data.new time, self
+            Data.new(time, self)
           end
 
           def deserialize(value)
@@ -34,12 +33,11 @@ module ActiveRecord
 
           private
 
-          def cast_value(value)
+          def cast_value(_value)
             value = super
-
             return value unless value.is_a?(::Time)
 
-            value = value.change(year: 2000, month: 01, day: 01)
+            value = value.change(year: 2000, month: 0o1, day: 0o1)
             apply_seconds_precision(value)
           end
 

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

@@ -57,7 +57,7 @@ module ActiveRecord
 
           def seconds_precision(value)
             seconds = super
-            seconds > fractional_max ? fractional_scale_max : seconds
+            (seconds > fractional_max) ? fractional_scale_max : seconds
           end
 
           def fractional_property

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

@@ -7,8 +7,6 @@ module ActiveRecord
         class Uuid < String
           ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
 
-          alias_method :serialize, :deserialize
-
           def type
             :uuid
           end

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

@@ -10,8 +10,8 @@ module ActiveRecord
         # Inspired from Rails PostgreSQL::Name adapter object in their own Utils.
         class Name
           UNQUOTED_SCANNER = /\]?\./
-          QUOTED_SCANNER   = /\A\[.*?\]\./
-          QUOTED_CHECKER   = /\A\[/
+          QUOTED_SCANNER = /\A\[.*?\]\./
+          QUOTED_CHECKER = /\A\[/
 
           attr_reader :server, :database, :schema, :object
           attr_reader :raw_name
@@ -38,7 +38,7 @@ module ActiveRecord
           end
 
           def fully_qualified_database_quoted
-            [server_quoted, database_quoted].compact.join('.')
+            [server_quoted, database_quoted].compact.join(".")
           end
 
           def fully_qualified?
@@ -65,7 +65,7 @@ module ActiveRecord
           end
 
           def quoted
-            parts.map { |p| quote(p) if p }.join('.')
+            parts.map { |p| quote(p) if p }.join(".")
           end
 
           def quoted_raw
@@ -107,32 +107,30 @@ module ActiveRecord
               @schema = @parts.first
             end
             rest = scanner.rest
-            rest = rest.start_with?(".") ? rest[1..-1] : rest[0..-1]
+            rest = rest.start_with?(".") ? rest[1..] : rest[0..]
             @object = unquote(rest)
             @parts << @object
           end
 
           def quote(part)
-            part =~ /\A\[.*\]\z/ ? part : "[#{part.to_s.gsub(']', ']]')}]"
+            /\A\[.*\]\z/.match?(part) ? part : "[#{part.to_s.gsub("]", "]]")}]"
           end
 
           def unquote(part)
-            if part && part.start_with?("[")
+            if part&.start_with?("[")
               part[1..-2]
             else
               part
             end
           end
 
-          def parts
-            @parts
-          end
+          attr_reader :parts
         end
 
         extend self
 
         def quote_string(s)
-          s.to_s.gsub(/\'/, "''")
+          s.to_s.gsub("'", "''")
         end
 
         def quote_string_single(s)
@@ -148,7 +146,7 @@ module ActiveRecord
         end
 
         def unquote_string(s)
-          s.to_s.gsub(/\'\'/, "'")
+          s.to_s.gsub("''", "'")
         end
 
         def extract_identifiers(name)

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -36,16 +36,16 @@ module ActiveRecord
     register "sqlserver", "ActiveRecord::ConnectionAdapters::SQLServerAdapter", "active_record/connection_adapters/sqlserver_adapter"
 
     class SQLServerAdapter < AbstractAdapter
-      include SQLServer::Version,
-              SQLServer::Quoting,
-              SQLServer::DatabaseStatements,
-              SQLServer::Showplan,
-              SQLServer::SchemaStatements,
-              SQLServer::DatabaseLimits,
-              SQLServer::DatabaseTasks,
-              SQLServer::Savepoints
+      include SQLServer::Savepoints
+      include SQLServer::DatabaseTasks
+      include SQLServer::DatabaseLimits
+      include SQLServer::SchemaStatements
+      include SQLServer::Showplan
+      include SQLServer::DatabaseStatements
+      include SQLServer::Quoting
+      include SQLServer::Version
 
-      ADAPTER_NAME = "SQLServer".freeze
+      ADAPTER_NAME = "SQLServer"
 
       # Default precision for 'time' (See https://docs.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql)
       DEFAULT_TIME_PRECISION = 7
@@ -62,18 +62,52 @@ module ActiveRecord
       self.use_output_inserted = true
       self.exclude_output_inserted_table_names = Concurrent::Map.new { false }
 
+      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)"}
+      }
+
       class << self
         def dbconsole(config, options = {})
           sqlserver_config = config.configuration_hash
           args = []
 
-          args += ["-d", "#{config.database}"] if config.database
-          args += ["-U", "#{sqlserver_config[:username]}"] if sqlserver_config[:username]
-          args += ["-P", "#{sqlserver_config[:password]}"] if sqlserver_config[:password]
+          args += ["-d", config.database.to_s] if config.database
+          args += ["-U", sqlserver_config[:username].to_s] if sqlserver_config[:username]
+          args += ["-P", sqlserver_config[:password].to_s] if sqlserver_config[:password]
 
           if sqlserver_config[:host]
-            host_arg = +"tcp:#{sqlserver_config[:host]}"
-            host_arg << ",#{sqlserver_config[:port]}" if sqlserver_config[:port]
+            host_arg = "tcp:#{sqlserver_config[:host]}"
+            host_arg += ",#{sqlserver_config[:port]}" if sqlserver_config[:port]
             args += ["-S", host_arg]
           end
 
@@ -83,7 +117,7 @@ module ActiveRecord
         def new_client(config)
           TinyTds::Client.new(config)
         rescue TinyTds::Error => error
-          if error.message.match(/database .* does not exist/i)
+          if /database .* does not exist/i.match?(error.message)
             raise ActiveRecord::NoDatabaseError
           else
             raise
@@ -95,6 +129,10 @@ module ActiveRecord
         rescue
           nil # Might not be in a Rails context so we fallback to `nil`.
         end
+
+        def native_database_types # :nodoc:
+          NATIVE_DATABASE_TYPES
+        end
       end
 
       def initialize(...)
@@ -143,6 +181,10 @@ module ActiveRecord
         true
       end
 
+      def supports_index_include?
+        true
+      end
+
       def supports_expression_index?
         false
       end
@@ -223,6 +265,10 @@ module ActiveRecord
         false
       end
 
+      def supports_virtual_columns?
+        true
+      end
+
       def return_value_after_insert?(column) # :nodoc:
         column.is_primary? || column.is_identity?
       end
@@ -238,13 +284,20 @@ module ActiveRecord
       # === Abstract Adapter (Connection Management) ================== #
 
       def active?
-        @raw_connection&.active?
+        if @raw_connection&.active?
+          verified!
+          true
+        end
       rescue *connection_errors
         false
       end
 
       def reconnect
-        @raw_connection&.close rescue nil
+        begin
+          @raw_connection&.close
+        rescue
+          nil
+        end
         @raw_connection = nil
         @spid = nil
         @collation = nil
@@ -255,7 +308,11 @@ module ActiveRecord
       def disconnect!
         super
 
-        @raw_connection&.close rescue nil
+        begin
+          @raw_connection&.close
+        rescue
+          nil
+        end
         @raw_connection = nil
         @spid = nil
         @collation = nil
@@ -324,13 +381,6 @@ module ActiveRecord
         self.class::VERSION
       end
 
-      def combine_bind_parameters(from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil)
-        result = from_clause + join_clause + where_clause + having_clause
-        result << offset if offset
-        result << limit if limit
-        result
-      end
-
       def get_database_version # :nodoc:
         version_year
       end
@@ -345,21 +395,21 @@ module ActiveRecord
         protected
 
         def initialize_type_map(m)
-          m.register_type              %r{.*}, SQLServer::Type::UnicodeString.new
+          m.register_type %r{.*}, SQLServer::Type::UnicodeString.new
 
           # Exact Numerics
-          register_class_with_limit m, "bigint(8)",         SQLServer::Type::BigInteger
-          m.alias_type                 "bigint",            "bigint(8)"
-          register_class_with_limit m, "int(4)",            SQLServer::Type::Integer
-          m.alias_type                 "integer",           "int(4)"
-          m.alias_type                 "int",               "int(4)"
-          register_class_with_limit m, "smallint(2)",       SQLServer::Type::SmallInteger
-          m.alias_type                 "smallint",          "smallint(2)"
-          register_class_with_limit m, "tinyint(1)",        SQLServer::Type::TinyInteger
-          m.alias_type                 "tinyint",           "tinyint(1)"
-          m.register_type              "bit",               SQLServer::Type::Boolean.new
-          m.register_type              %r{\Adecimal}i do |sql_type|
-            scale     = extract_scale(sql_type)
+          register_class_with_limit m, "bigint(8)", SQLServer::Type::BigInteger
+          m.alias_type "bigint", "bigint(8)"
+          register_class_with_limit m, "int(4)", SQLServer::Type::Integer
+          m.alias_type "integer", "int(4)"
+          m.alias_type "int", "int(4)"
+          register_class_with_limit m, "smallint(2)", SQLServer::Type::SmallInteger
+          m.alias_type "smallint", "smallint(2)"
+          register_class_with_limit m, "tinyint(1)", SQLServer::Type::TinyInteger
+          m.alias_type "tinyint", "tinyint(1)"
+          m.register_type "bit", SQLServer::Type::Boolean.new
+          m.register_type %r{\Adecimal}i do |sql_type|
+            scale = extract_scale(sql_type)
             precision = extract_precision(sql_type)
             if scale == 0
               SQLServer::Type::DecimalWithoutScale.new(precision: precision)
@@ -367,17 +417,17 @@ module ActiveRecord
               SQLServer::Type::Decimal.new(precision: precision, scale: scale)
             end
           end
-          m.alias_type                 %r{\Anumeric}i,      "decimal"
-          m.register_type              "money",             SQLServer::Type::Money.new
-          m.register_type              "smallmoney",        SQLServer::Type::SmallMoney.new
+          m.alias_type %r{\Anumeric}i, "decimal"
+          m.register_type "money", SQLServer::Type::Money.new
+          m.register_type "smallmoney", SQLServer::Type::SmallMoney.new
 
           # Approximate Numerics
-          m.register_type              "float",             SQLServer::Type::Float.new
-          m.register_type              "real",              SQLServer::Type::Real.new
+          m.register_type "float", SQLServer::Type::Float.new
+          m.register_type "real", SQLServer::Type::Real.new
 
           # Date and Time
-          m.register_type              "date",              SQLServer::Type::Date.new
-          m.register_type              %r{\Adatetime} do |sql_type|
+          m.register_type "date", SQLServer::Type::Date.new
+          m.register_type %r{\Adatetime} do |sql_type|
             precision = extract_precision(sql_type)
             if precision
               SQLServer::Type::DateTime2.new precision: precision
@@ -389,34 +439,34 @@ module ActiveRecord
             precision = extract_precision(sql_type)
             SQLServer::Type::DateTimeOffset.new precision: precision
           end
-          m.register_type              "smalldatetime", SQLServer::Type::SmallDateTime.new
-          m.register_type              %r{\Atime}i do |sql_type|
+          m.register_type "smalldatetime", SQLServer::Type::SmallDateTime.new
+          m.register_type %r{\Atime}i do |sql_type|
             precision = extract_precision(sql_type) || DEFAULT_TIME_PRECISION
             SQLServer::Type::Time.new precision: precision
           end
 
           # Character Strings
-          register_class_with_limit m, %r{\Achar}i,         SQLServer::Type::Char
-          register_class_with_limit m, %r{\Avarchar}i,      SQLServer::Type::Varchar
-          m.register_type              "varchar(max)",      SQLServer::Type::VarcharMax.new
-          m.register_type              "text",              SQLServer::Type::Text.new
+          register_class_with_limit m, %r{\Achar}i, SQLServer::Type::Char
+          register_class_with_limit m, %r{\Avarchar}i, SQLServer::Type::Varchar
+          m.register_type "varchar(max)", SQLServer::Type::VarcharMax.new
+          m.register_type "text", SQLServer::Type::Text.new
 
           # Unicode Character Strings
-          register_class_with_limit m, %r{\Anchar}i,        SQLServer::Type::UnicodeChar
-          register_class_with_limit m, %r{\Anvarchar}i,     SQLServer::Type::UnicodeVarchar
-          m.alias_type                 "string",            "nvarchar(4000)"
-          m.register_type              "nvarchar(max)",     SQLServer::Type::UnicodeVarcharMax.new
-          m.register_type              "nvarchar(max)",     SQLServer::Type::UnicodeVarcharMax.new
-          m.register_type              "ntext",             SQLServer::Type::UnicodeText.new
+          register_class_with_limit m, %r{\Anchar}i, SQLServer::Type::UnicodeChar
+          register_class_with_limit m, %r{\Anvarchar}i, SQLServer::Type::UnicodeVarchar
+          m.alias_type "string", "nvarchar(4000)"
+          m.register_type "nvarchar(max)", SQLServer::Type::UnicodeVarcharMax.new
+          m.register_type "nvarchar(max)", SQLServer::Type::UnicodeVarcharMax.new
+          m.register_type "ntext", SQLServer::Type::UnicodeText.new
 
           # Binary Strings
-          register_class_with_limit m, %r{\Abinary}i,       SQLServer::Type::Binary
-          register_class_with_limit m, %r{\Avarbinary}i,    SQLServer::Type::Varbinary
-          m.register_type              "varbinary(max)",    SQLServer::Type::VarbinaryMax.new
+          register_class_with_limit m, %r{\Abinary}i, SQLServer::Type::Binary
+          register_class_with_limit m, %r{\Avarbinary}i, SQLServer::Type::Varbinary
+          m.register_type "varbinary(max)", SQLServer::Type::VarbinaryMax.new
 
           # Other Data Types
-          m.register_type              "uniqueidentifier",  SQLServer::Type::Uuid.new
-          m.register_type              "timestamp",         SQLServer::Type::Timestamp.new
+          m.register_type "uniqueidentifier", SQLServer::Type::Uuid.new
+          m.register_type "timestamp", SQLServer::Type::Timestamp.new
         end
       end
 
@@ -452,6 +502,8 @@ module ActiveRecord
           NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Arithmetic overflow error/
           RangeError.new(message, sql: sql, binds: binds, connection_pool: @pool)
+        when /statement conflicted with the CHECK constraint/
+          CheckViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
         else
           super
         end
@@ -471,10 +523,10 @@ module ActiveRecord
 
         [a, b, c].each { |f| f.upcase! if f == "y" }
         dateformat = "%#{a}-%#{b}-%#{c}"
-        ::Date::DATE_FORMATS[:_sqlserver_dateformat]     = dateformat
-        ::Time::DATE_FORMATS[:_sqlserver_dateformat]     = dateformat
-        ::Time::DATE_FORMATS[:_sqlserver_time]           = "%H:%M:%S"
-        ::Time::DATE_FORMATS[:_sqlserver_datetime]       = "#{dateformat} %H:%M:%S"
+        ::Date::DATE_FORMATS[:_sqlserver_dateformat] = dateformat
+        ::Time::DATE_FORMATS[:_sqlserver_dateformat] = dateformat
+        ::Time::DATE_FORMATS[:_sqlserver_time] = "%H:%M:%S"
+        ::Time::DATE_FORMATS[:_sqlserver_datetime] = "#{dateformat} %H:%M:%S"
         ::Time::DATE_FORMATS[:_sqlserver_datetimeoffset] = lambda { |time|
           time.strftime "#{dateformat} %H:%M:%S.%9N #{time.formatted_offset}"
         }

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -6,12 +6,13 @@ module ActiveRecord
       class Column < ConnectionAdapters::Column
         delegate :is_identity, :is_primary, :table_name, :ordinal_position, to: :sql_type_metadata
 
-        def initialize(*, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil, **)
+        def initialize(*, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil, generated_type: nil, **)
           super
           @is_identity = is_identity
           @is_primary = is_primary
           @table_name = table_name
           @ordinal_position = ordinal_position
+          @generated_type = generated_type
         end
 
         def is_identity?
@@ -28,7 +29,19 @@ module ActiveRecord
         end
 
         def case_sensitive?
-          collation && collation.match(/_CS/)
+          collation&.match(/_CS/)
+        end
+
+        def virtual?
+          @generated_type.present?
+        end
+
+        def virtual_stored?
+          @generated_type == :stored
+        end
+
+        def has_default?
+          super && !virtual?
         end
 
         def init_with(coder)
@@ -55,15 +68,10 @@ module ActiveRecord
             table_name == other.table_name &&
             ordinal_position == other.ordinal_position
         end
-        alias :eql? :==
+        alias_method :eql?, :==
 
         def hash
-          Column.hash ^
-            super.hash ^
-            is_identity?.hash ^
-            is_primary?.hash ^
-            table_name.hash ^
-            ordinal_position.hash
+          [Column, super, is_identity?, is_primary?, table_name, ordinal_position].hash
         end
 
         private

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -28,7 +28,7 @@ module ActiveRecord
         end
         establish_connection(configuration)
       rescue ActiveRecord::StatementInvalid => e
-        if /database .* already exists/i === e.message
+        if /database .* already exists/i.match?(e.message)
           raise DatabaseAlreadyExists
         else
           raise
@@ -68,7 +68,7 @@ module ActiveRecord
             "-D #{Shellwords.escape(configuration_hash[:database])}",
             "-U #{Shellwords.escape(configuration_hash[:username])}",
             "-P #{Shellwords.escape(configuration_hash[:password])}",
-            "-o #{Shellwords.escape(filename)}",
+            "-o #{Shellwords.escape(filename)}"
           ]
           table_args = connection.tables.map { |t| Shellwords.escape(t) }
           command.concat(table_args)
@@ -79,8 +79,8 @@ module ActiveRecord
           dump = File.read(filename)
           dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
           dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
-          dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
-          dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
+          dump.gsub!("nvarchar(8000)", "nvarchar(4000)")      # Fix nvarchar(8000) column defs
+          dump.gsub!("nvarchar(-1)", "nvarchar(max)")         # Fix nvarchar(-1) column defs
           dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
           File.open(filename, "w") { |file| file.puts dump }
         end
@@ -124,7 +124,7 @@ module ActiveRecord
         def configuration_host_ip(configuration)
           return nil unless configuration.host
 
-          Socket::getaddrinfo(configuration.host, "echo", Socket::AF_INET)[0][3]
+          Socket.getaddrinfo(configuration.host, "echo", Socket::AF_INET)[0][3]
         end
 
         def local_ipaddr?(host_ip)