activerecord-sqlserver-adapter 6.1.0.0 → 7.0.0.0.rc1

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -10,7 +10,6 @@ require "active_record/connection_adapters/sqlserver/core_ext/explain"
 require "active_record/connection_adapters/sqlserver/core_ext/explain_subscriber"
 require "active_record/connection_adapters/sqlserver/core_ext/attribute_methods"
 require "active_record/connection_adapters/sqlserver/core_ext/finder_methods"
-require "active_record/connection_adapters/sqlserver/core_ext/query_methods"
 require "active_record/connection_adapters/sqlserver/core_ext/preloader"
 require "active_record/connection_adapters/sqlserver/version"
 require "active_record/connection_adapters/sqlserver/type"
@@ -106,7 +105,23 @@ module ActiveRecord
         end
 
         def config_appname(config)
-          config[:appname] || configure_application_name || Rails.application.class.name.split("::").first rescue nil
+          if instance_methods.include?(:configure_application_name)
+            ActiveSupport::Deprecation.warn <<~MSG.squish
+            Configuring the application name used by TinyTDS by overriding the
+            `ActiveRecord::ConnectionAdapters::SQLServerAdapter#configure_application_name`
+            instance method is no longer supported. The application name should configured
+            using the `appname` setting in the `database.yml` file instead. Consult the
+            README for further information."
+            MSG
+          end
+
+          config[:appname] || rails_application_name
+        end
+
+        def rails_application_name
+          Rails.application.class.name.split("::").first
+        rescue
+          nil # Might not be in a Rails context so we fallback to `nil`.
         end
 
         def config_login_timeout(config)
@@ -362,97 +377,107 @@ module ActiveRecord
         version_year
       end
 
-      protected
-
-      # === Abstract Adapter (Misc Support) =========================== #
-
-      def initialize_type_map(m = type_map)
-        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)
-          precision = extract_precision(sql_type)
-          if scale == 0
-            SQLServer::Type::DecimalWithoutScale.new(precision: precision)
-          else
-            SQLServer::Type::Decimal.new(precision: precision, scale: scale)
+      class << self
+        protected
+
+        def initialize_type_map(m)
+          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)
+            precision = extract_precision(sql_type)
+            if scale == 0
+              SQLServer::Type::DecimalWithoutScale.new(precision: precision)
+            else
+              SQLServer::Type::Decimal.new(precision: precision, scale: scale)
+            end
           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
-
-        # Approximate Numerics
-        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|
-          precision = extract_precision(sql_type)
-          if precision
-            SQLServer::Type::DateTime2.new precision: precision
-          else
-            SQLServer::Type::DateTime.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
+
+          # Date and Time
+          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
+            else
+              SQLServer::Type::DateTime.new
+            end
           end
+          m.register_type %r{\Adatetimeoffset}i do |sql_type|
+            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|
+            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
+
+          # 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
+
+          # 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
+
+          # Other Data Types
+          m.register_type              "uniqueidentifier",  SQLServer::Type::Uuid.new
+          m.register_type              "timestamp",         SQLServer::Type::Timestamp.new
         end
-        m.register_type %r{\Adatetimeoffset}i do |sql_type|
-          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|
-          precision = extract_precision(sql_type) || DEFAULT_TIME_PRECISION
-          SQLServer::Type::Time.new precision: precision
-        end
+      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
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
 
-        # 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
+      protected
 
-        # 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
+      # === Abstract Adapter (Misc Support) =========================== #
 
-        # Other Data Types
-        m.register_type              "uniqueidentifier",  SQLServer::Type::Uuid.new
-        m.register_type              "timestamp",         SQLServer::Type::Timestamp.new
+      def type_map
+        TYPE_MAP
       end
 
       def translate_exception(e, message:, sql:, binds:)
         case message
         when /(SQL Server client is not connected)|(failed to execute statement)/i
           ConnectionNotEstablished.new(message)
-        when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
+        when /(cannot insert duplicate key .* with unique index) | (violation of (unique|primary) key constraint)/i
           RecordNotUnique.new(message, sql: sql, binds: binds)
         when /(conflicted with the foreign key constraint) | (The DELETE statement conflicted with the REFERENCE constraint)/i
           InvalidForeignKey.new(message, sql: sql, binds: binds)
         when /has been chosen as the deadlock victim/i
           DeadlockVictim.new(message, sql: sql, binds: binds)
         when /database .* does not exist/i
-          NoDatabaseError.new(message, sql: sql, binds: binds)
+          NoDatabaseError.new(message)
         when /data would be truncated/
           ValueTooLong.new(message, sql: sql, binds: binds)
         when /connection timed out/
@@ -484,8 +509,6 @@ module ActiveRecord
         end
       end
 
-      def configure_application_name; end
-
       def initialize_dateformatter
         @database_dateformat = user_options_dateformat
         a, b, c = @database_dateformat.each_char.to_a

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -2,48 +2,87 @@
 
 module ActiveRecord
   module ConnectionAdapters
-    class SQLServerColumn < Column
-      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **sqlserver_options)
-        @sqlserver_options = sqlserver_options
-        super
-      end
+    module SQLServer
+      class Column < ConnectionAdapters::Column
+        delegate :is_identity, :is_primary, :table_name, :ordinal_position, to: :sql_type_metadata
 
-      def is_identity?
-        @sqlserver_options[:is_identity]
-      end
+        def initialize(*, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil, **)
+          super
+          @is_identity = is_identity
+          @is_primary = is_primary
+          @table_name = table_name
+          @ordinal_position = ordinal_position
+        end
 
-      def is_primary?
-        @sqlserver_options[:is_primary]
-      end
+        def is_identity?
+          is_identity
+        end
 
-      def table_name
-        @sqlserver_options[:table_name]
-      end
+        def is_primary?
+          is_primary
+        end
 
-      def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar/i
-      end
+        def is_utf8?
+          sql_type =~ /nvarchar|ntext|nchar/i
+        end
 
-      def case_sensitive?
-        collation && collation.match(/_CS/)
-      end
+        def case_sensitive?
+          collation && collation.match(/_CS/)
+        end
 
-      private
-
-      # In the Rails version of this method there is an assumption that the `default` value will always be a
-      # `String` class, which must be true for the MySQL/PostgreSQL/SQLite adapters. However, in the SQL Server
-      # adapter the `default` value can also be Boolean/Date/Time/etc. Changed the implementation of this method
-      # to handle non-String `default` objects.
-      def deduplicated
-        @name = -name
-        @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
-        @default = (default.is_a?(String) ? -default : default.dup.freeze) if default
-        @default_function = -default_function if default_function
-        @collation = -collation if collation
-        @comment = -comment if comment
-
-        freeze
+        def init_with(coder)
+          @is_identity = coder["is_identity"]
+          @is_primary = coder["is_primary"]
+          @table_name = coder["table_name"]
+          @ordinal_position = coder["ordinal_position"]
+          super
+        end
+
+        def encode_with(coder)
+          coder["is_identity"] = @is_identity
+          coder["is_primary"] = @is_primary
+          coder["table_name"] = @table_name
+          coder["ordinal_position"] = @ordinal_position
+          super
+        end
+
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            is_identity? == other.is_identity? &&
+            is_primary? == other.is_primary? &&
+            table_name == other.table_name &&
+            ordinal_position == other.ordinal_position
+        end
+        alias :eql? :==
+
+        def hash
+          Column.hash ^
+            super.hash ^
+            is_identity?.hash ^
+            is_primary?.hash ^
+            table_name.hash ^
+            ordinal_position.hash
+        end
+
+        private
+
+        # In the Rails version of this method there is an assumption that the `default` value will always be a
+        # `String` class, which must be true for the MySQL/PostgreSQL/SQLite adapters. However, in the SQL Server
+        # adapter the `default` value can also be Boolean/Date/Time/etc. Changed the implementation of this method
+        # to handle non-String `default` objects.
+        def deduplicated
+          @name = -name
+          @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
+          @default = (default.is_a?(String) ? -default : default.dup.freeze) if default
+          @default_function = -default_function if default_function
+          @collation = -collation if collation
+          @comment = -comment if comment
+          freeze
+        end
       end
+
+      SQLServerColumn = SQLServer::Column
     end
   end
 end

data/lib/arel/visitors/sqlserver.rb

@@ -83,6 +83,8 @@ module Arel
           # Monkey-patch start. Add query attribute bindings rather than just values.
           column_name = o.column_name
           column_type = o.attribute.relation.type_for_attribute(o.column_name)
+          # Use cast_type on encrypted attributes. Don't encrypt them again
+          column_type = column_type.cast_type if column_type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType)
           attrs = values.map { |value| ActiveRecord::Relation::QueryAttribute.new(column_name, value, column_type) }
 
           collector.add_binds(attrs, &bind_block)
@@ -296,8 +298,21 @@ module Arel
       def primary_Key_From_Table(t)
         return unless t
 
-        column_name = @connection.schema_cache.primary_keys(t.name) ||
-          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+        primary_keys = @connection.schema_cache.primary_keys(t.name)
+        column_name = nil
+
+        case primary_keys
+        when NilClass
+          column_name = @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+        when String
+          column_name = primary_keys
+        when Array
+          candidate_columns = @connection.schema_cache.columns_hash(t.name).slice(*primary_keys).values
+          candidate_column = candidate_columns.find(&:is_identity?)
+          candidate_column ||= candidate_columns.first
+          column_name = candidate_column.try(:name)
+        end
+
         column_name ? t[column_name] : nil
       end
 

data/test/cases/adapter_test_sqlserver.rb

@@ -120,6 +120,14 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
            "expected database #{db_config.database} to exist"
   end
 
+  it "test primary key violation" do
+    Post.create!(id: 0, title: 'Setup', body: 'Create post with primary key of zero')
+
+    assert_raise ActiveRecord::RecordNotUnique do
+      Post.create!(id: 0, title: 'Test', body: 'Try to create another post with primary key of zero')
+    end
+  end
+
   describe "with different language" do
     before do
       @default_language = connection.user_options_language
@@ -377,7 +385,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert !SSTestCustomersView.columns.blank?
       assert_equal columns.size, SSTestCustomersView.columns.size
       columns.each do |colname|
-        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
+        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServer::Column,
                            SSTestCustomersView.columns_hash[colname],
                            "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
       end
@@ -404,7 +412,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert !SSTestStringDefaultsView.columns.blank?
       assert_equal columns.size, SSTestStringDefaultsView.columns.size
       columns.each do |colname|
-        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
+        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServer::Column,
                            SSTestStringDefaultsView.columns_hash[colname],
                            "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
       end