activerecord-sqlserver-adapter 6.0.0.rc1 → 6.1.0.0.rc1

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

@@ -5,7 +5,6 @@ module ActiveRecord
     module SQLServer
       module Type
         class Varchar < Char
-
           def initialize(**args)
             super
             @limit = 8000 if @limit.to_i == 0
@@ -16,12 +15,11 @@ module ActiveRecord
           end
 
           def sqlserver_type
-            'varchar'.yield_self do |type|
+            "varchar".yield_self do |type|
               type += "(#{limit})" if limit
               type
             end
           end
-
         end
       end
     end

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

@@ -5,7 +5,6 @@ module ActiveRecord
     module SQLServer
       module Type
         class VarcharMax < Varchar
-
           def initialize(**args)
             super
             @limit = 2_147_483_647
@@ -18,7 +17,6 @@ module ActiveRecord
           def sqlserver_type
             "varchar(max)"
           end
-
         end
       end
     end

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

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
-require 'strscan'
+require "strscan"
 
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Utils
-
-        QUOTED_STRING_PREFIX = 'N'
+        QUOTED_STRING_PREFIX = "N"
 
         # Value object to return identifiers from SQL Server names http://bit.ly/1CZ3EiL
         # Inspiried from Rails PostgreSQL::Name adapter object in their own Utils.
         #
         class Name
-
           SEPARATOR = "."
           UNQUOTED_SCANNER = /\]?\./
           QUOTED_SCANNER   = /\A\[.*?\]\./
@@ -56,15 +54,15 @@ module ActiveRecord
           end
 
           def quoted
-            parts.map{ |p| quote(p) if p }.join SEPARATOR
+            parts.map { |p| quote(p) if p }.join SEPARATOR
           end
 
           def quoted_raw
             quote @raw_name
           end
 
-          def ==(o)
-            o.class == self.class && o.parts == parts
+          def ==(other)
+            other.class == self.class && other.parts == parts
           end
           alias_method :eql?, :==
 
@@ -77,6 +75,7 @@ module ActiveRecord
           def parse_raw_name
             @parts = []
             return if raw_name.blank?
+
             scanner = StringScanner.new(raw_name)
             matched = scanner.exist?(QUOTED_CHECKER) ? scanner.scan_until(QUOTED_SCANNER) : scanner.scan_until(UNQUOTED_SCANNER)
             while matched
@@ -93,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
@@ -103,7 +102,7 @@ module ActiveRecord
           end
 
           def unquote(part)
-            if part && part.start_with?('[')
+            if part && part.start_with?("[")
               part[1..-2]
             else
               part
@@ -113,7 +112,6 @@ module ActiveRecord
           def parts
             @parts
           end
-
         end
 
         extend self
@@ -141,7 +139,6 @@ module ActiveRecord
         def extract_identifiers(name)
           SQLServer::Utils::Name.new(name)
         end
-
       end
     end
   end

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

@@ -4,9 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Version
-
         VERSION = File.read(File.expand_path("../../../../../VERSION", __FILE__)).chomp
-
       end
     end
   end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,40 +1,39 @@
 # frozen_string_literal: true
 
-require 'base64'
-require 'active_record'
-require 'arel_sqlserver'
-require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
-require 'active_record/connection_adapters/sqlserver/core_ext/calculations'
-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'
-require 'active_record/connection_adapters/sqlserver/database_limits'
-require 'active_record/connection_adapters/sqlserver/database_statements'
-require 'active_record/connection_adapters/sqlserver/database_tasks'
-require 'active_record/connection_adapters/sqlserver/transaction'
-require 'active_record/connection_adapters/sqlserver/errors'
-require 'active_record/connection_adapters/sqlserver/schema_creation'
-require 'active_record/connection_adapters/sqlserver/schema_dumper'
-require 'active_record/connection_adapters/sqlserver/schema_statements'
-require 'active_record/connection_adapters/sqlserver/sql_type_metadata'
-require 'active_record/connection_adapters/sqlserver/showplan'
-require 'active_record/connection_adapters/sqlserver/table_definition'
-require 'active_record/connection_adapters/sqlserver/quoting'
-require 'active_record/connection_adapters/sqlserver/utils'
-require 'active_record/sqlserver_base'
-require 'active_record/connection_adapters/sqlserver_column'
-require 'active_record/tasks/sqlserver_database_tasks'
+require "base64"
+require "active_record"
+require "arel_sqlserver"
+require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/sqlserver/core_ext/active_record"
+require "active_record/connection_adapters/sqlserver/core_ext/calculations"
+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"
+require "active_record/connection_adapters/sqlserver/database_limits"
+require "active_record/connection_adapters/sqlserver/database_statements"
+require "active_record/connection_adapters/sqlserver/database_tasks"
+require "active_record/connection_adapters/sqlserver/transaction"
+require "active_record/connection_adapters/sqlserver/errors"
+require "active_record/connection_adapters/sqlserver/schema_creation"
+require "active_record/connection_adapters/sqlserver/schema_dumper"
+require "active_record/connection_adapters/sqlserver/schema_statements"
+require "active_record/connection_adapters/sqlserver/sql_type_metadata"
+require "active_record/connection_adapters/sqlserver/showplan"
+require "active_record/connection_adapters/sqlserver/table_definition"
+require "active_record/connection_adapters/sqlserver/quoting"
+require "active_record/connection_adapters/sqlserver/utils"
+require "active_record/sqlserver_base"
+require "active_record/connection_adapters/sqlserver_column"
+require "active_record/tasks/sqlserver_database_tasks"
 
 module ActiveRecord
   module ConnectionAdapters
     class SQLServerAdapter < AbstractAdapter
-
       include SQLServer::Version,
               SQLServer::Quoting,
               SQLServer::DatabaseStatements,
@@ -43,7 +42,7 @@ module ActiveRecord
               SQLServer::DatabaseLimits,
               SQLServer::DatabaseTasks
 
-      ADAPTER_NAME = 'SQLServer'.freeze
+      ADAPTER_NAME = "SQLServer".freeze
 
       # Default precision for 'time' (See https://docs.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql)
       DEFAULT_TIME_PRECISION = 7
@@ -56,17 +55,77 @@ module ActiveRecord
       cattr_accessor :showplan_option, instance_accessor: false
       cattr_accessor :lowercase_schema_reflection
 
-      self.cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
+      self.cs_equality_operator = "COLLATE Latin1_General_CS_AS_WS"
       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 ========================================== #
@@ -153,6 +212,10 @@ module ActiveRecord
         true
       end
 
+      def supports_optimizer_hints?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
@@ -189,7 +252,8 @@ module ActiveRecord
 
       def active?
         return false unless @connection
-        raw_connection_do 'SELECT 1'
+
+        raw_connection_do "SELECT 1"
         true
       rescue *connection_errors
         false
@@ -219,7 +283,15 @@ module ActiveRecord
 
       def reset!
         reset_transaction
-        do_execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+        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) =========================== #
@@ -254,6 +326,7 @@ module ActiveRecord
 
       def database_prefix_remote_server?
         return false if database_prefix.blank?
+
         name = SQLServer::Utils.extract_identifiers(database_prefix)
         name.fully_qualified? && name.object.blank?
       end
@@ -294,31 +367,38 @@ module ActiveRecord
       # === Abstract Adapter (Misc Support) =========================== #
 
       def initialize_type_map(m = type_map)
-        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
+        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)
+          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
+        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              "date",              SQLServer::Type::Date.new
         m.register_type              %r{\Adatetime} do |sql_type|
           precision = extract_precision(sql_type)
           if precision
@@ -327,38 +407,44 @@ module ActiveRecord
             SQLServer::Type::DateTime.new
           end
         end
-        m.register_type              %r{\Adatetimeoffset}i do |sql_type|
+        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              "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
+        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
+        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
+        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
 
       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
@@ -392,83 +478,23 @@ 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 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' }
+
+        [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_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}"
@@ -477,13 +503,21 @@ module ActiveRecord
 
       def version_year
         return 2016 if sqlserver_version =~ /vNext/
+
         /SQL Server (\d+)/.match(sqlserver_version).to_a.last.to_s.to_i
-      rescue StandardError => e
+      rescue StandardError
         2016
       end
 
       def sqlserver_version
-        @sqlserver_version ||= _raw_select('SELECT @@version', fetch: :rows).first.first.to_s
+        @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