activerecord-sqlserver-adapter 6.0.1 → 6.1.1.0

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

@@ -3,9 +3,13 @@
 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
 
@@ -29,11 +33,28 @@ module ActiveRecord
           sql
         end
 
+        def visit_CreateIndexDefinition(o)
+          if_not_exists = o.if_not_exists
+
+          o.if_not_exists = false
+
+          sql = super
+
+          if if_not_exists
+            sql = "IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = '#{o.index.name}') #{sql}"
+          end
+
+          sql
+        end
+
         def add_column_options!(sql, options)
           sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
           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

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

@@ -15,7 +15,7 @@ module ActiveRecord
         private
 
         def explicit_primary_key_default?(column)
-          column.is_primary? && !column.is_identity?
+          column.type == :integer && !column.is_identity?
         end
 
         def schema_limit(column)
@@ -27,11 +27,17 @@ module ActiveRecord
         def schema_collation(column)
           return unless column.collation
 
-          column.collation if column.collation != @connection.collation
+          # use inspect to ensure collation is dumped as string. Without this it's dumped as
+          # a constant ('collation: SQL_Latin1_General_CP1_CI_AS')
+          collation = column.collation.inspect
+          # use inspect to ensure string comparison
+          default_collation = @connection.collation.inspect
+
+          collation if collation != default_collation
         end
 
         def default_primary_key?(column)
-          super && column.is_primary? && column.is_identity?
+          super && column.is_identity?
         end
       end
     end

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

@@ -27,7 +27,7 @@ module ActiveRecord
             end
           end
           if options[:if_exists] && @version_year < 2016
-            execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}"
+            execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}", "SCHEMA"
           else
             super
           end
@@ -51,7 +51,7 @@ module ActiveRecord
               index[:index_keys].split(",").each do |column|
                 column.strip!
 
-                if column.ends_with?("(-)")
+                if column.end_with?("(-)")
                   column.gsub! "(-)", ""
                   orders[column] = :desc
                 end
@@ -84,7 +84,7 @@ module ActiveRecord
         end
 
         def new_column(name, default, sql_type_metadata, null, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
-          SQLServerColumn.new(
+          SQLServer::Column.new(
             name,
             default,
             sql_type_metadata,
@@ -130,8 +130,9 @@ module ActiveRecord
           rename_table_indexes(table_name, new_name)
         end
 
-        def remove_column(table_name, column_name, type = nil, options = {})
+        def remove_column(table_name, column_name, type = nil, **options)
           raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_name.is_a? Array
+          return if options[:if_exists] == true && !column_exists?(table_name, column_name)
 
           remove_check_constraints(table_name, column_name)
           remove_default_constraint(table_name, column_name)
@@ -156,6 +157,7 @@ module ActiveRecord
           end
           sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
           alter_command = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, limit: options[:limit], precision: options[:precision], scale: options[:scale])}"
+          alter_command += " COLLATE #{options[:collation]}" if options[:collation].present?
           alter_command += " NOT NULL" if !options[:null].nil? && options[:null] == false
           sql_commands << alter_command
           if without_constraints
@@ -190,7 +192,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 #{allowed_index_name_length} characters" if new_name.length > allowed_index_name_length
+          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
 
           identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{old_name}")
           execute_procedure :sp_rename, identifier.quoted, new_name, "INDEX"
@@ -281,14 +283,33 @@ module ActiveRecord
           SQLServer::SchemaDumper.create(self, options)
         end
 
+        def create_schema(schema_name, authorization = nil)
+          sql = "CREATE SCHEMA [#{schema_name}]"
+          sql += " AUTHORIZATION [#{authorization}]" if authorization
+
+          execute sql
+        end
+
+        def change_table_schema(schema_name, table_name)
+          execute "ALTER SCHEMA [#{schema_name}] TRANSFER [#{table_name}]"
+        end
+
+        def drop_schema(schema_name)
+          execute "DROP SCHEMA [#{schema_name}]"
+        end
+
         private
 
         def data_source_sql(name = nil, type: nil)
           scope = quoted_scope name, type: type
-          table_name = lowercase_schema_reflection_sql "TABLE_NAME"
+
+          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 #{table_name}"
-          sql += " FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
-          sql += " WHERE TABLE_CATALOG = DB_NAME()"
+          sql += " FROM #{database}INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
+          sql += " WHERE TABLE_CATALOG = #{table_catalog}"
           sql += " AND TABLE_SCHEMA = #{quote(scope[:schema])}"
           sql += " AND TABLE_NAME = #{quote(scope[:name])}" if scope[:name]
           sql += " AND TABLE_TYPE = #{quote(scope[:type])}" if scope[:type]
@@ -299,6 +320,7 @@ module ActiveRecord
         def quoted_scope(name = nil, type: nil)
           identifier = SQLServer::Utils.extract_identifiers(name)
           {}.tap do |scope|
+            scope[:database] = identifier.database if identifier.database
             scope[:schema] = identifier.schema || "dbo"
             scope[:name] = identifier.object if identifier.object
             scope[:type] = type if type
@@ -310,7 +332,7 @@ module ActiveRecord
         def initialize_native_database_types
           {
             primary_key: "bigint NOT NULL IDENTITY(1,1) PRIMARY KEY",
-            primary_key_nonclustered: "int NOT NULL IDENTITY(1,1) PRIMARY KEY NONCLUSTERED",
+            primary_key_nonclustered: "bigint NOT NULL IDENTITY(1,1) PRIMARY KEY NONCLUSTERED",
             integer: { name: "int", limit: 4 },
             bigint: { name: "bigint" },
             boolean: { name: "bit" },

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

@@ -3,16 +3,45 @@
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
-      class SqlTypeMetadata < ActiveRecord::ConnectionAdapters::SqlTypeMetadata
-        def initialize(**kwargs)
-          @sqlserver_options = kwargs.extract!(:sqlserver_options)
-          super(**kwargs)
+      class TypeMetadata < DelegateClass(SqlTypeMetadata)
+        undef to_yaml if method_defined?(:to_yaml)
+
+        include Deduplicable
+
+        attr_reader :is_identity, :is_primary, :table_name, :ordinal_position
+
+        def initialize(type_metadata, is_identity: nil, is_primary: nil, table_name: nil, ordinal_position: nil)
+          super(type_metadata)
+          @is_identity = is_identity
+          @is_primary = is_primary
+          @table_name = table_name
+          @ordinal_position = ordinal_position
+        end
+
+        def ==(other)
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            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
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            is_identity.hash ^
+            is_primary.hash ^
+            table_name.hash ^
+            ordinal_position.hash
         end
 
-        protected
+        private
 
-        def attributes_for_hash
-          super + [@sqlserver_options]
+        def deduplicated
+          __setobj__(__getobj__.deduplicate)
+          super
         end
       end
     end

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

@@ -9,7 +9,6 @@ module ActiveRecord
             options[:is_identity] = true unless options.key?(:default)
           elsif type == :uuid
             options[:default] = options.fetch(:default, "NEWID()")
-            options[:primary_key] = true
           end
           super
         end

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

@@ -31,9 +31,9 @@ module ActiveRecord
     module SQLServerRealTransaction
       attr_reader :starting_isolation_level
 
-      def initialize(connection, options, **args)
+      def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
         @connection = connection
-        @starting_isolation_level = current_isolation_level if options[:isolation]
+        @starting_isolation_level = current_isolation_level if isolation
         super
       end
 

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

@@ -11,6 +11,7 @@ require "active_record/connection_adapters/sqlserver/type/small_integer"
 require "active_record/connection_adapters/sqlserver/type/tiny_integer"
 require "active_record/connection_adapters/sqlserver/type/boolean"
 require "active_record/connection_adapters/sqlserver/type/decimal"
+require "active_record/connection_adapters/sqlserver/type/decimal_without_scale"
 require "active_record/connection_adapters/sqlserver/type/money"
 require "active_record/connection_adapters/sqlserver/type/small_money"
 # Approximate Numerics

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

@@ -10,7 +10,8 @@ module ActiveRecord
           end
 
           def serialize(value)
-            return unless value.present?
+            value = super
+            return value unless value.acts_like?(:date)
 
             date = super(value).to_s(:_sqlserver_dateformat)
             Data.new date, self

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Type
+        class DecimalWithoutScale < ActiveRecord::Type::DecimalWithoutScale
+          def sqlserver_type
+            "decimal".yield_self do |type|
+              type += "(#{precision.to_i},0)" if precision
+              type
+            end
+          end
+
+          def type_cast_for_schema(value)
+            value.is_a?(BigDecimal) ? value.to_s : value.inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -92,7 +92,7 @@ module ActiveRecord
               @schema = @parts.first
             end
             rest = scanner.rest
-            rest = rest.starts_with?(".") ? rest[1..-1] : rest[0..-1]
+            rest = rest.start_with?(".") ? rest[1..-1] : rest[0..-1]
             @object = unquote(rest)
             @parts << @object
           end

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"
@@ -59,13 +58,73 @@ module ActiveRecord
       self.use_output_inserted = true
       self.exclude_output_inserted_table_names = Concurrent::Map.new { false }
 
-      def initialize(connection, logger = nil, config = {})
+      class << self
+        def new_client(config)
+          case config[:mode]
+          when :dblib
+            require "tiny_tds"
+            dblib_connect(config)
+          else
+            raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+          end
+        end
+
+        def dblib_connect(config)
+          TinyTds::Client.new(
+            dataserver:    config[:dataserver],
+            host:          config[:host],
+            port:          config[:port],
+            username:      config[:username],
+            password:      config[:password],
+            database:      config[:database],
+            tds_version:   config[:tds_version] || "7.3",
+            appname:       config_appname(config),
+            login_timeout: config_login_timeout(config),
+            timeout:       config_timeout(config),
+            encoding:      config_encoding(config),
+            azure:         config[:azure],
+            contained:     config[:contained]
+          ).tap do |client|
+            if config[:azure]
+              client.execute("SET ANSI_NULLS ON").do
+              client.execute("SET ANSI_NULL_DFLT_ON ON").do
+              client.execute("SET ANSI_PADDING ON").do
+              client.execute("SET ANSI_WARNINGS ON").do
+            else
+              client.execute("SET ANSI_DEFAULTS ON").do
+            end
+            client.execute("SET QUOTED_IDENTIFIER ON").do
+            client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+            client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+            client.execute("SET TEXTSIZE 2147483647").do
+            client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
+          end
+        rescue TinyTds::Error => e
+          raise ActiveRecord::NoDatabaseError if e.message.match(/database .* does not exist/i)
+          raise e
+        end
+
+        def config_appname(config)
+          config[:appname] || configure_application_name || Rails.application.class.name.split("::").first rescue nil
+        end
+
+        def config_login_timeout(config)
+          config[:login_timeout].present? ? config[:login_timeout].to_i : nil
+        end
+
+        def config_timeout(config)
+          config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
+        end
+
+        def config_encoding(config)
+          config[:encoding].present? ? config[:encoding] : nil
+        end
+      end
+
+      def initialize(connection, logger, _connection_options, config)
         super(connection, logger, config)
-        # Our Responsibility
         @connection_options = config
-        connect
-        initialize_dateformatter
-        use_database
+        configure_connection
       end
 
       # === Abstract Adapter ========================================== #
@@ -152,6 +211,10 @@ module ActiveRecord
         true
       end
 
+      def supports_optimizer_hints?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
@@ -222,6 +285,14 @@ module ActiveRecord
         do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
 
+      def configure_connection
+        @spid = _raw_select("SELECT @@SPID", fetch: :rows).first.first
+        @version_year = version_year
+
+        initialize_dateformatter
+        use_database
+      end
+
       # === Abstract Adapter (Misc Support) =========================== #
 
       def tables_with_referential_integrity
@@ -296,6 +367,7 @@ module ActiveRecord
 
       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)"
@@ -308,16 +380,22 @@ module ActiveRecord
         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)
+          scale     = extract_scale(sql_type)
           precision = extract_precision(sql_type)
-          SQLServer::Type::Decimal.new precision: precision, scale: scale
+          if scale == 0
+            SQLServer::Type::DecimalWithoutScale.new(precision: precision)
+          else
+            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
+
         # 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|
@@ -337,11 +415,13 @@ module ActiveRecord
           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
@@ -349,10 +429,12 @@ module ActiveRecord
         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
@@ -360,6 +442,8 @@ module ActiveRecord
 
       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
           RecordNotUnique.new(message, sql: sql, binds: binds)
         when /(conflicted with the foreign key constraint) | (The DELETE statement conflicted with the REFERENCE constraint)/i
@@ -393,78 +477,18 @@ module ActiveRecord
 
       # === SQLServer Specific (Connection Management) ================ #
 
-      def connect
-        config = @connection_options
-        @connection = case config[:mode]
-                      when :dblib
-                        dblib_connect(config)
-                      end
-        @spid = _raw_select("SELECT @@SPID", fetch: :rows).first.first
-        @version_year = version_year
-        configure_connection
-      end
-
       def connection_errors
         @connection_errors ||= [].tap do |errors|
           errors << TinyTds::Error if defined?(TinyTds::Error)
         end
       end
 
-      def dblib_connect(config)
-        TinyTds::Client.new(
-          dataserver: config[:dataserver],
-          host: config[:host],
-          port: config[:port],
-          username: config[:username],
-          password: config[:password],
-          database: config[:database],
-          tds_version: config[:tds_version] || "7.3",
-          appname: config_appname(config),
-          login_timeout: config_login_timeout(config),
-          timeout: config_timeout(config),
-          encoding: config_encoding(config),
-          azure: config[:azure],
-          contained: config[:contained]
-        ).tap do |client|
-          if config[:azure]
-            client.execute("SET ANSI_NULLS ON").do
-            client.execute("SET ANSI_NULL_DFLT_ON ON").do
-            client.execute("SET ANSI_PADDING ON").do
-            client.execute("SET ANSI_WARNINGS ON").do
-          else
-            client.execute("SET ANSI_DEFAULTS ON").do
-          end
-          client.execute("SET QUOTED_IDENTIFIER ON").do
-          client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
-          client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
-          client.execute("SET TEXTSIZE 2147483647").do
-          client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
-        end
-      end
-
-      def config_appname(config)
-        config[:appname] || configure_application_name || Rails.application.class.name.split("::").first rescue nil
-      end
-
-      def config_login_timeout(config)
-        config[:login_timeout].present? ? config[:login_timeout].to_i : nil
-      end
-
-      def config_timeout(config)
-        config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
-      end
-
-      def config_encoding(config)
-        config[:encoding].present? ? config[:encoding] : nil
-      end
-
-      def configure_connection; end
-
       def configure_application_name; end
 
       def initialize_dateformatter
         @database_dateformat = user_options_dateformat
         a, b, c = @database_dateformat.each_char.to_a
+
         [a, b, c].each { |f| f.upcase! if f == "y" }
         dateformat = "%#{a}-%#{b}-%#{c}"
         ::Date::DATE_FORMATS[:_sqlserver_dateformat]     = dateformat
@@ -487,6 +511,13 @@ module ActiveRecord
       def sqlserver_version
         @sqlserver_version ||= _raw_select("SELECT @@version", fetch: :rows).first.first.to_s
       end
+
+      private
+
+      def connect
+        @connection = self.class.new_client(@connection_options)
+        configure_connection
+      end
     end
   end
 end