activerecord-jdbc-alt-adapter 61.1.0-java → 70.0.0-java

data/lib/arjdbc/mssql/adapter.rb

@@ -35,14 +35,15 @@ module ActiveRecord
       ADAPTER_NAME = 'MSSQL'.freeze
 
       MSSQL_VERSION_YEAR = {
-        8 => '2000',
-        9 => '2005',
+        8  => '2000',
+        9  => '2005',
         10 => '2008',
         11 => '2012',
         12 => '2014',
         13 => '2016',
         14 => '2017',
-        15 => '2019'
+        15 => '2019',
+        16 => '2022'
       }.freeze
 
       include Jdbc::ConnectionPoolCallbacks
@@ -143,13 +144,32 @@ module ActiveRecord
       def supports_insert_on_conflict?
         false
       end
+
       alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
       alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
       alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+      def supports_insert_returning?
+        true
+      end
+
       def build_insert_sql(insert) # :nodoc:
         # TODO: hope we can implement an upsert like feature
-        "INSERT #{insert.into} #{insert.values_list}"
+        # "INSERT #{insert.into} #{insert.values_list}"
+        sql = +"INSERT #{insert.into}"
+
+        if returning = insert.send(:insert_all).returning
+          returning_sql = if returning.is_a?(String)
+                            returning
+                          else
+                            returning.map { |column| "INSERTED.#{quote_column_name(column)}" }.join(', ')
+                          end
+
+          sql << " OUTPUT #{returning_sql}"
+        end
+
+        sql << " #{insert.values_list}"
+        sql
       end
 
       # Overrides abstract method which always returns false
@@ -158,7 +178,7 @@ module ActiveRecord
       end
 
       def clear_cache!
-        reload_type_map
+        # reload_type_map
         super
       end
 
@@ -309,8 +329,121 @@ module ActiveRecord
         end
       end
 
+      class << self
+        private
+
+        # This method is called indirectly by the abstract method
+        # 'fetch_type_metadata' which then it is called by the java part when
+        # calculating a table's columns.
+        def initialize_type_map(map)
+          # Build the type mapping from SQL Server to ActiveRecord
+
+          # Integer types.
+          map.register_type 'int',      MSSQL::Type::Integer.new(limit: 4)
+          map.register_type 'tinyint',  MSSQL::Type::TinyInteger.new(limit: 1)
+          map.register_type 'smallint', MSSQL::Type::SmallInteger.new(limit: 2)
+          map.register_type 'bigint',   MSSQL::Type::BigInteger.new(limit: 8)
+
+          # Exact Numeric types.
+          map.register_type %r{\Adecimal}i do |sql_type|
+            scale = extract_scale(sql_type)
+            precision = extract_precision(sql_type)
+            if scale == 0
+              MSSQL::Type::DecimalWithoutScale.new(precision: precision)
+            else
+              MSSQL::Type::Decimal.new(precision: precision, scale: scale)
+            end
+          end
+          map.register_type %r{\Amoney\z}i,      MSSQL::Type::Money.new
+          map.register_type %r{\Asmallmoney\z}i, MSSQL::Type::SmallMoney.new
+
+          # Approximate Numeric types.
+          map.register_type %r{\Afloat\z}i,    MSSQL::Type::Float.new
+          map.register_type %r{\Areal\z}i,     MSSQL::Type::Real.new
+
+          # Character strings CHAR and VARCHAR (it can become Unicode UTF-8)
+          map.register_type 'varchar(max)', MSSQL::Type::VarcharMax.new
+          map.register_type %r{\Avarchar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Varchar.new(limit: limit)
+          end
+          map.register_type %r{\Achar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Char.new(limit: limit)
+          end
+
+          # Character strings NCHAR and NVARCHAR (by default Unicode UTF-16)
+          map.register_type %r{\Anvarchar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Nvarchar.new(limit: limit)
+          end
+          map.register_type %r{\Anchar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Nchar.new(limit: limit)
+          end
+          map.register_type 'nvarchar(max)', MSSQL::Type::NvarcharMax.new
+          map.register_type 'nvarchar(4000)', MSSQL::Type::Nvarchar.new
+
+          # Binary data types.
+          map.register_type              'varbinary(max)',       MSSQL::Type::VarbinaryMax.new
+          register_class_with_limit map, %r{\Abinary\(\d+\)},    MSSQL::Type::BinaryBasic
+          register_class_with_limit map, %r{\Avarbinary\(\d+\)}, MSSQL::Type::Varbinary
+
+          # Miscellaneous types, Boolean, XML, UUID
+          # FIXME The xml data needs to be reviewed and fixed
+          map.register_type 'bit',                     MSSQL::Type::Boolean.new
+          map.register_type %r{\Auniqueidentifier\z}i, MSSQL::Type::UUID.new
+          map.register_type %r{\Axml\z}i,              MSSQL::Type::XML.new
+
+          # Date and time types
+          map.register_type 'date',          MSSQL::Type::Date.new
+          map.register_type 'datetime',      MSSQL::Type::DateTime.new
+          map.register_type 'smalldatetime', MSSQL::Type::SmallDateTime.new
+          register_class_with_precision map, %r{\Atime\(\d+\)}i, MSSQL::Type::Time
+          map.register_type 'time(7)',       MSSQL::Type::Time.new
+          register_class_with_precision map, %r{\Adatetime2\(\d+\)}i, MSSQL::Type::DateTime2
+          # map.register_type 'datetime2(7)',  MSSQL::Type::DateTime2.new
+
+          # TODO: we should have identity separated from the sql_type
+          # let's say in another attribute (this will help to pass more AR tests),
+          # also we add collation attribute per column.
+          # aliases
+          map.alias_type 'int identity',    'int'
+          map.alias_type 'bigint identity', 'bigint'
+          map.alias_type 'integer',         'int'
+          map.alias_type 'integer',         'int'
+          map.alias_type 'INTEGER',         'int'
+          map.alias_type 'TINYINT',         'tinyint'
+          map.alias_type 'SMALLINT',        'smallint'
+          map.alias_type 'BIGINT',          'bigint'
+          map.alias_type %r{\Anumeric}i,    'decimal'
+          map.alias_type %r{\Anumber}i,     'decimal'
+          map.alias_type %r{\Adouble\z}i,   'float'
+          map.alias_type 'string',          'nvarchar(4000)'
+          map.alias_type %r{\Aboolean\z}i,  'bit'
+          map.alias_type 'DATE',            'date'
+          map.alias_type 'DATETIME',        'datetime'
+          map.alias_type 'SMALLDATETIME',   'smalldatetime'
+          map.alias_type %r{\Atime\z}i,     'time(7)'
+          map.alias_type %r{\Abinary\z}i,   'varbinary(max)'
+          map.alias_type %r{\Ablob\z}i,     'varbinary(max)'
+          map.alias_type %r{\Adatetime2\z}i, 'datetime2(7)'
+
+          # Deprecated SQL Server types.
+          map.register_type 'text',  MSSQL::Type::Text.new
+          map.register_type 'ntext', MSSQL::Type::Ntext.new
+          map.register_type 'image', MSSQL::Type::Image.new
+        end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
       private
 
+      def type_map
+        TYPE_MAP
+      end
+
       def translate_exception(exception, message:, sql:, binds:)
         case message
         when /no connection available/i
@@ -334,109 +467,6 @@ module ActiveRecord
         end
       end
 
-      # This method is called indirectly by the abstract method
-      # 'fetch_type_metadata' which then it is called by the java part when
-      # calculating a table's columns.
-      def initialize_type_map(map = type_map)
-        # Build the type mapping from SQL Server to ActiveRecord
-
-        # Integer types.
-        map.register_type 'int',      MSSQL::Type::Integer.new(limit: 4)
-        map.register_type 'tinyint',  MSSQL::Type::TinyInteger.new(limit: 1)
-        map.register_type 'smallint', MSSQL::Type::SmallInteger.new(limit: 2)
-        map.register_type 'bigint',   MSSQL::Type::BigInteger.new(limit: 8)
-
-        # Exact Numeric types.
-        map.register_type %r{\Adecimal}i do |sql_type|
-          scale = extract_scale(sql_type)
-          precision = extract_precision(sql_type)
-          if scale == 0
-            MSSQL::Type::DecimalWithoutScale.new(precision: precision)
-          else
-            MSSQL::Type::Decimal.new(precision: precision, scale: scale)
-          end
-        end
-        map.register_type %r{\Amoney\z}i,      MSSQL::Type::Money.new
-        map.register_type %r{\Asmallmoney\z}i, MSSQL::Type::SmallMoney.new
-
-        # Approximate Numeric types.
-        map.register_type %r{\Afloat\z}i,    MSSQL::Type::Float.new
-        map.register_type %r{\Areal\z}i,     MSSQL::Type::Real.new
-
-        # Character strings CHAR and VARCHAR (it can become Unicode UTF-8)
-        map.register_type 'varchar(max)', MSSQL::Type::VarcharMax.new
-        map.register_type %r{\Avarchar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Varchar.new(limit: limit)
-        end
-        map.register_type %r{\Achar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Char.new(limit: limit)
-        end
-
-        # Character strings NCHAR and NVARCHAR (by default Unicode UTF-16)
-        map.register_type %r{\Anvarchar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Nvarchar.new(limit: limit)
-        end
-        map.register_type %r{\Anchar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Nchar.new(limit: limit)
-        end
-        map.register_type 'nvarchar(max)', MSSQL::Type::NvarcharMax.new
-        map.register_type 'nvarchar(4000)', MSSQL::Type::Nvarchar.new
-
-        # Binary data types.
-        map.register_type              'varbinary(max)',       MSSQL::Type::VarbinaryMax.new
-        register_class_with_limit map, %r{\Abinary\(\d+\)},    MSSQL::Type::BinaryBasic
-        register_class_with_limit map, %r{\Avarbinary\(\d+\)}, MSSQL::Type::Varbinary
-
-        # Miscellaneous types, Boolean, XML, UUID
-        # FIXME The xml data needs to be reviewed and fixed
-        map.register_type 'bit',                     MSSQL::Type::Boolean.new
-        map.register_type %r{\Auniqueidentifier\z}i, MSSQL::Type::UUID.new
-        map.register_type %r{\Axml\z}i,              MSSQL::Type::XML.new
-
-        # Date and time types
-        map.register_type 'date',          MSSQL::Type::Date.new
-        map.register_type 'datetime',      MSSQL::Type::DateTime.new
-        map.register_type 'smalldatetime', MSSQL::Type::SmallDateTime.new
-        register_class_with_precision map, %r{\Atime\(\d+\)}i, MSSQL::Type::Time
-        map.register_type 'time(7)',       MSSQL::Type::Time.new
-        register_class_with_precision map, %r{\Adatetime2\(\d+\)}i, MSSQL::Type::DateTime2
-        map.register_type 'datetime2(7)',  MSSQL::Type::DateTime2.new
-
-        # TODO: we should have identity separated from the sql_type
-        # let's say in another attribute (this will help to pass more AR tests),
-        # also we add collation attribute per column.
-        # aliases
-        map.alias_type 'int identity',    'int'
-        map.alias_type 'bigint identity', 'bigint'
-        map.alias_type 'integer',         'int'
-        map.alias_type 'integer',         'int'
-        map.alias_type 'INTEGER',         'int'
-        map.alias_type 'TINYINT',         'tinyint'
-        map.alias_type 'SMALLINT',        'smallint'
-        map.alias_type 'BIGINT',          'bigint'
-        map.alias_type %r{\Anumeric}i,    'decimal'
-        map.alias_type %r{\Anumber}i,     'decimal'
-        map.alias_type %r{\Adouble\z}i,   'float'
-        map.alias_type 'string',          'nvarchar(4000)'
-        map.alias_type %r{\Aboolean\z}i,  'bit'
-        map.alias_type 'DATE',            'date'
-        map.alias_type 'DATETIME',        'datetime'
-        map.alias_type 'SMALLDATETIME',   'smalldatetime'
-        map.alias_type %r{\Atime\z}i,     'time(7)'
-        map.alias_type %r{\Abinary\z}i,   'varbinary(max)'
-        map.alias_type %r{\Ablob\z}i,     'varbinary(max)'
-        map.alias_type %r{\Adatetime2\z}i, 'datetime2(7)'
-
-        # Deprecated SQL Server types.
-        map.register_type 'text',  MSSQL::Type::Text.new
-        map.register_type 'ntext', MSSQL::Type::Ntext.new
-        map.register_type 'image', MSSQL::Type::Image.new
-      end
-
       # Returns an array of Column objects for the table specified by +table_name+.
       # See the concrete implementation for details on the expected parameter values.
       # NOTE: This is ready, all implemented in the java part of adapter,

data/lib/arjdbc/mssql/connection_methods.rb

@@ -78,12 +78,15 @@ ArJdbc::ConnectionMethods.module_eval do
       url << "sendTimeAsDatetime=#{config[:send_time_as_datetime] || false};"
       url << "loginTimeout=#{config[:login_timeout].to_i};" if config[:login_timeout]
       url << "lockTimeout=#{config[:lock_timeout].to_i};"
+      url << "encrypt=#{config[:encrypt]};" if config.key?(:encrypt)
+      url << "trustServerCertificate=#{config[:trust_server_certificate]};" if config.key?(:trust_server_certificate)
       app = config[:appname] || config[:application]
       url << "applicationName=#{app};" if app
       isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll
       url << "integratedSecurity=#{isc};" unless isc.nil?
       url
     end
+
     jdbc_connection(config)
   end
   alias_method :jdbcsqlserver_connection, :sqlserver_connection

data/lib/arjdbc/mssql/quoting.rb

@@ -4,8 +4,30 @@ module ActiveRecord
   module ConnectionAdapters
     module MSSQL
       module Quoting
-        QUOTED_TRUE  = '1'.freeze
-        QUOTED_FALSE = '0'.freeze
+        QUOTED_TRUE  = '1'
+        QUOTED_FALSE = '0'
+
+        def quote(value)
+          # FIXME: this needs improvements to handle other custom types.
+          # Also check if it's possible insert integer into a NVARCHAR
+          case value
+          when ActiveRecord::Type::Binary::Data
+            "0x#{value.hex}"
+          # when SomeOtherBinaryData then BLOB_VALUE_MARKER
+          # when SomeOtherData then "yyy"
+          when String, ActiveSupport::Multibyte::Chars
+            "N'#{quote_string(value)}'"
+          # when OnlyTimeType then "'#{quoted_time(value)}'"
+          when Date, Time
+            "'#{quoted_date(value)}'"
+          when TrueClass
+            quoted_true
+          when FalseClass
+            quoted_false
+          else
+            super
+          end
+        end
 
         # Quote date/time values for use in SQL input, includes microseconds
         # with three digits only if the value is a Time responding to usec.
@@ -15,7 +37,7 @@ module ActiveRecord
             value = time_with_db_timezone(value)
           end
 
-          result = value.to_s(:db)
+          result = value.to_fs(:db)
 
           if value.respond_to?(:usec) && value.usec > 0
             "#{result}.#{sprintf("%06d", value.usec)}"
@@ -105,7 +127,7 @@ module ActiveRecord
         private
 
         def time_with_db_timezone(value)
-          zone_conv_method = if ActiveRecord::Base.default_timezone == :utc
+          zone_conv_method = if ActiveRecord.default_timezone == :utc
                                :getutc
                              else
                                :getlocal
@@ -117,29 +139,6 @@ module ActiveRecord
             value
           end
         end
-
-        # @override
-        # FIXME: it need to be improved to handle other custom types.
-        # Also check if it's possible insert integer into a NVARCHAR
-        def _quote(value)
-          case value
-          when ActiveRecord::Type::Binary::Data
-            "0x#{value.hex}"
-          # when SomeOtherBinaryData then BLOB_VALUE_MARKER
-          # when SomeOtherData then "yyy"
-          when String, ActiveSupport::Multibyte::Chars
-            "N'#{quote_string(value)}'"
-          # when OnlyTimeType then "'#{quoted_time(value)}'"
-          when Date, Time
-            "'#{quoted_date(value)}'"
-          when TrueClass
-            quoted_true
-          when FalseClass
-            quoted_false
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/arjdbc/mssql/schema_creation.rb

@@ -29,7 +29,7 @@ module ActiveRecord
             end
 
             if supports_foreign_keys?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+              statements.concat(o.foreign_keys.map { |fk| accept fk })
             end
 
             create_sql << "(#{statements.join(', ')})" if statements.present?

data/lib/arjdbc/mssql/schema_definitions.rb

@@ -14,80 +14,95 @@ module ActiveRecord
 
         # datetime with seconds always zero (:00) and without fractional seconds
         def smalldatetime(*args, **options)
-          args.each { |name| column(name, :smalldatetime, options) }
+          args.each { |name| column(name, :smalldatetime, **options) }
         end
 
         # this is the old sql server datetime type, the precision is as follow
         # xx1, xx3, and xx7
         def datetime_basic(*args, **options)
-          args.each { |name| column(name, :datetime_basic, options) }
+          args.each { |name| column(name, :datetime_basic, **options) }
         end
 
         def real(*args, **options)
-          args.each { |name| column(name, :real, options) }
+          args.each { |name| column(name, :real, **options) }
         end
 
         def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
+          args.each { |name| column(name, :money, **options) }
         end
 
         def smallmoney(*args, **options)
-          args.each { |name| column(name, :smallmoney, options) }
+          args.each { |name| column(name, :smallmoney, **options) }
         end
 
         def char(*args, **options)
-          args.each { |name| column(name, :char, options) }
+          args.each { |name| column(name, :char, **options) }
         end
 
         def varchar(*args, **options)
-          args.each { |name| column(name, :varchar, options) }
+          args.each { |name| column(name, :varchar, **options) }
         end
 
         def varchar_max(*args, **options)
-          args.each { |name| column(name, :varchar_max, options) }
+          args.each { |name| column(name, :varchar_max, **options) }
         end
 
         def text_basic(*args, **options)
-          args.each { |name| column(name, :text_basic, options) }
+          args.each { |name| column(name, :text_basic, **options) }
         end
 
         def nchar(*args, **options)
-          args.each { |name| column(name, :nchar, options) }
+          args.each { |name| column(name, :nchar, **options) }
         end
 
         def ntext(*args, **options)
-          args.each { |name| column(name, :ntext, options) }
+          args.each { |name| column(name, :ntext, **options) }
         end
 
         def binary_basic(*args, **options)
-          args.each { |name| column(name, :binary_basic, options) }
+          args.each { |name| column(name, :binary_basic, **options) }
         end
 
         def varbinary(*args, **options)
-          args.each { |name| column(name, :varbinary, options) }
+          args.each { |name| column(name, :varbinary, **options) }
         end
 
         def uuid(*args, **options)
-          args.each { |name| column(name, :uniqueidentifier, options) }
+          args.each { |name| column(name, :uniqueidentifier, **options) }
         end
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        def column(name, type, index: nil, **options)
+          # TODO: remove this when the below changed is released
+          #   Fix erroneous nil default precision on virtual datetime columns #46110
+          #   https://github.com/rails/rails/pull/46110
+          #
+          if @conn.supports_datetime_with_precision?
+            if type == :datetime && !options.key?(:precision)
+              options[:precision] = 7
+            end
+          end
+
+          super
+        end
+
+
         def new_column_definition(name, type, **options)
           case type
           when :primary_key
             options[:is_identity] = true
+          when :datetime
+            options[:precision] = 7 if !options.key?(:precision) && @conn.supports_datetime_with_precision?
           end
 
           super
         end
 
         def timestamps(**options)
-          if !options.key?(:precision) && @conn.supports_datetime_with_precision?
-            options[:precision] = 7
-          end
+          options[:precision] = 7 if !options.key?(:precision) && @conn.supports_datetime_with_precision?
 
           super
         end

data/lib/arjdbc/mssql/schema_dumper.rb

@@ -28,11 +28,23 @@ module ActiveRecord
           super && column.identity?
         end
 
+        def schema_precision(column)
+          case column.type
+          when :datetime
+            if column.precision == 7
+              nil
+            else
+              column.precision.inspect
+            end
+          else
+            super
+          end
+        end
+
         # def schema_collation(column)
         #   return unless column.collation
         #   column.collation if column.collation != collation
         # end
-
       end
     end
   end