activerecord-jdbc-alt-adapter 70.2.0-java → 71.0.0.alpha2-java

data/lib/arjdbc/mssql/connection_methods.rb

@@ -1,62 +1,12 @@
 # frozen_string_literal: true
 
 ArJdbc::ConnectionMethods.module_eval do
-
-  # Default connection method for MS-SQL adapter (`adapter: mssql`),
-  # uses the (open-source) jTDS driver.
-  # If you'd like to use the "official" MS's SQL-JDBC driver, it's preferable
-  # to use the {#sqlserver_connection} method (set `adapter: sqlserver`).
-  def mssql_connection(config)
-    # NOTE: this detection ain't perfect and is only meant as a temporary hack
-    # users will get a deprecation eventually to use `adapter: sqlserver` ...
-    if config[:driver] =~ /SQLServerDriver$/ || config[:url] =~ /^jdbc:sqlserver:/
-      return sqlserver_connection(config)
-    end
-
-    config = config.deep_dup
-
-    config[:adapter_spec] ||= ::ArJdbc::MSSQL
-    config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
-
-    return jndi_connection(config) if jndi_config?(config)
-
-    begin
-      require 'jdbc/jtds'
-      # NOTE: the adapter has only support for working with the
-      # open-source jTDS driver (won't work with MS's driver) !
-      ::Jdbc::JTDS.load_driver(:require) if defined?(::Jdbc::JTDS.load_driver)
-    rescue LoadError => e # assuming driver.jar is on the class-path
-      raise e unless e.message.to_s.index('no such file to load')
-    end
-
-    config[:host] ||= 'localhost'
-    config[:port] ||= 1433
-    config[:driver] ||= defined?(::Jdbc::JTDS.driver_name) ? ::Jdbc::JTDS.driver_name : 'net.sourceforge.jtds.jdbc.Driver'
-    config[:connection_alive_sql] ||= 'SELECT 1'
-
-    config[:url] ||= begin
-      url = ''.dup
-      url << "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      # Instance is often a preferrable alternative to port when dynamic ports are used.
-      # If instance is specified then port is essentially ignored.
-      url << ";instance=#{config[:instance]}" if config[:instance]
-      # This will enable windows domain-based authentication and will require the JTDS native libraries be available.
-      url << ";domain=#{config[:domain]}" if config[:domain]
-      # AppName is shown in sql server as additional information against the connection.
-      url << ";appname=#{config[:appname]}" if config[:appname]
-      url
-    end
-
-    unless config[:domain]
-      config[:username] ||= 'sa'
-      config[:password] ||= ''
-    end
-    jdbc_connection(config)
+  def mssql_adapter_class
+    ConnectionAdapters::MSSQLAdapter
   end
-  alias_method :jdbcmssql_connection, :mssql_connection
 
-  # @note Assumes SQLServer SQL-JDBC driver on the class-path.
-  def sqlserver_connection(config)
+  # NOTE: Assumes SQLServer SQL-JDBC driver on the class-path.
+  def mssql_connection(config)
     config = config.deep_dup
 
     config[:adapter_spec] ||= ::ArJdbc::MSSQL
@@ -89,6 +39,8 @@ ArJdbc::ConnectionMethods.module_eval do
 
     jdbc_connection(config)
   end
-  alias_method :jdbcsqlserver_connection, :sqlserver_connection
 
+  alias_method :jdbcmssql_connection, :mssql_connection
+  alias_method :sqlserver_connection, :mssql_connection
+  alias_method :jdbcsqlserver_connection, :mssql_connection
 end

data/lib/arjdbc/mssql/database_statements.rb

@@ -4,23 +4,22 @@ module ActiveRecord
   module ConnectionAdapters
     module MSSQL
       module DatabaseStatements
-
         def exec_proc(proc_name, *variables)
-          vars =
-            if variables.any? && variables.first.is_a?(Hash)
-              variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
-            else
-              variables.map { |v| quote(v) }
-            end.join(', ')
+          vars = if variables.any? && variables.first.is_a?(Hash)
+                   variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
+                 else
+                   variables.map { |v| quote(v) }
+                 end.join(', ')
+
           sql = "EXEC #{proc_name} #{vars}".strip
           log(sql, 'Execute Procedure') do
-            result = @connection.execute_query_raw(sql)
-            result.map! do |row|
+            result = internal_execute(sql)
+
+            result.map do |row|
               row = row.is_a?(Hash) ? row.with_indifferent_access : row
               yield(row) if block_given?
               row
             end
-            result
           end
         end
         alias_method :execute_procedure, :exec_proc # AR-SQLServer-Adapter naming
@@ -34,47 +33,22 @@ module ActiveRecord
           !READ_QUERY.match?(sql)
         end
 
-        def execute(sql, name = nil)
-          # with identity insert on block
-          if insert_sql?(sql)
-            table_name_for_identity_insert = identity_insert_table_name(sql)
-
-            if table_name_for_identity_insert
-              with_identity_insert_enabled(table_name_for_identity_insert) do
-                super
-              end
-            else
-              super
-            end
-          else
-            super
-          end
-        end
-
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
-          table_name_for_identity_insert = identity_insert_table_name(sql)
-
-          if table_name_for_identity_insert
-            with_identity_insert_enabled(table_name_for_identity_insert) do
-              super
-            end
-          else
-            super
-          end
-        end
-
-        # Not a rails method, own method to test different isolation
-        # levels supported by the mssql adapter.
+        # Internal method to test different isolation levels supported by this
+        # mssql adapter. NOTE: not a active record method
         def supports_transaction_isolation_level?(level)
-          @connection.supports_transaction_isolation?(level)
+          raw_jdbc_connection.supports_transaction_isolation?(level)
         end
 
+        # Internal method to test different isolation levels supported by this
+        # mssql adapter. Not a active record method
         def transaction_isolation=(value)
-          @connection.set_transaction_isolation(value)
+          raw_jdbc_connection.set_transaction_isolation(value)
         end
 
+        # Internal method to test different isolation levels supported by this
+        # mssql adapter. Not a active record method
         def transaction_isolation
-          @connection.get_transaction_isolation
+          raw_jdbc_connection.get_transaction_isolation
         end
 
         def insert_fixtures_set(fixture_set, tables_to_delete = [])
@@ -116,8 +90,163 @@ module ActiveRecord
           end
         end
 
+        def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false)
+          sql = transform_query(sql)
+
+          check_if_write_query(sql)
+
+          mark_transaction_written_if_write(sql)
+
+          # binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+
+          # puts "internal----->sql: #{sql}, binds: #{binds}"
+          if without_prepared_statement?(binds)
+            log(sql, name) do
+              with_raw_connection do |conn|
+                result = conditional_indentity_insert(sql) do
+                  conn.execute_query(sql)
+                end
+                verified!
+                result
+              end
+            end
+          else
+            log(sql, name, binds) do
+              with_raw_connection do |conn|
+                # this is different from normal AR that always caches
+                cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
+
+                result = conditional_indentity_insert(sql) do
+                  conn.execute_prepared_query(sql, binds, cached_statement)
+                end
+                verified!
+                result
+              end
+            end
+          end
+        end
+
+        def exec_update(sql, name = nil, binds = [])
+          sql = transform_query(sql)
+
+          check_if_write_query(sql)
+
+          mark_transaction_written_if_write(sql)
+
+          # puts "exec_update----->sql: #{sql}, binds: #{binds}"
+          if without_prepared_statement?(binds)
+            log(sql, name) do
+              with_raw_connection do |conn|
+                result = conn.execute_update(sql)
+                verified!
+                result
+              end
+            end
+          else
+            log(sql, name, binds) do
+              with_raw_connection do |conn|
+                result = conn.execute_prepared_update(sql, binds)
+                verified!
+                result
+              end
+            end
+          end
+        end
+        alias :exec_delete :exec_update
+
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+          sql = transform_query(sql)
+
+          check_if_write_query(sql)
+
+          mark_transaction_written_if_write(sql)
+
+          # puts "exec_insert----->sql: #{sql}, binds: #{binds}"
+          if without_prepared_statement?(binds)
+            log(sql, name) do
+              with_raw_connection do |conn|
+                result = conditional_indentity_insert(sql) do
+                  conn.execute_insert_pk(sql, pk)
+                end
+                verified!
+                result
+              end
+            end
+          else
+            log(sql, name, binds) do
+              with_raw_connection do |conn|
+                result = conditional_indentity_insert(sql) do
+                  conn.execute_insert_pk(sql, binds, pk)
+                end
+                verified!
+                result
+              end
+            end
+          end
+        end
+
         private
 
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          # puts "raw_execute----->sql: #{sql}"
+          log(sql, name, async: async) do
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = conditional_indentity_insert(sql) { conn.execute(sql) }
+              verified!
+              result
+            end
+          end
+        end
+
+        def sql_for_insert(sql, pk, binds, returning) # :nodoc:
+          return [sql, binds]
+
+          # TODO: Add/Implement and support for insert returning values when
+          # upgrading to rails 7.2
+          return [sql, binds] unless supports_insert_returning?
+
+          if pk.nil?
+            # Extract the table from the insert sql. Yuck.
+            table_name = identity_insert_table_name(sql)
+            pk = primary_key(table_name) if table_name
+          end
+
+          returning_columns = returning || Array(pk)
+
+          returning_columns_stmt = returning_columns.map do |column|
+            "INSERTED.#{quote_column_name(column)}"
+          end.join(', ')
+
+
+          return [sql, binds] unless returning_columns.any?
+
+          index = sql.index(/VALUES\s\(\?/) || sql.index(/DEFAULT VALUES/)
+
+          insert_into = sql[0..(index - 1)].strip
+
+          values_list = sql[index..]
+
+          sql = "#{insert_into} OUTPUT #{returning_columns_stmt} #{values_list}"
+
+          [sql, binds]
+        end
+
+        def conditional_indentity_insert(sql, &block)
+          table_name_for_identity_insert = identity_insert_table_name(sql)
+
+          if table_name_for_identity_insert
+            with_identity_insert_enabled(table_name_for_identity_insert) do
+              block.call
+            end
+          else
+            block.call
+          end
+        end
+
+        def raw_jdbc_connection
+          @raw_connection
+        end
+
         # It seems the truncate_tables is mostly used for testing
         # this a workaround to the fact that SQL Server truncate tables
         # referenced by a foreign key, it may not be required to reset
@@ -151,24 +280,21 @@ module ActiveRecord
           end
         end
 
-        def insert_sql?(sql)
-          !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil? 
-        end
-
         def identity_insert_table_name(sql)
-          table_name = get_table_name(sql)
+          return unless ArJdbc::MSSQL::Utils.insert_sql?(sql)
+
+          table_name = ArJdbc::MSSQL::Utils.get_table_name(sql)
+
           id_column = identity_column_name(table_name)
+
           if id_column && sql.strip =~ /INSERT INTO [^ ]+ ?\((.+?)\)/i
-            insert_columns = $1.split(/, */).map{|w| ArJdbc::MSSQL::Utils.unquote_column_name(w)}
+            insert_columns = $1.split(/, */).map { |w| ArJdbc::MSSQL::Utils.unquote_column_name(w) }
             return table_name if insert_columns.include?(id_column)
           end
         end
 
         def identity_column_name(table_name)
-          for column in schema_cache.columns(table_name)
-            return column.name if column.identity?
-          end
-          nil
+          schema_cache.columns(table_name).find(&:identity?)&.name
         end
 
         # Turns IDENTITY_INSERT ON for table during execution of the block
@@ -183,29 +309,14 @@ module ActiveRecord
 
         def set_identity_insert(table_name, enable = true)
           if enable
-            execute("SET IDENTITY_INSERT #{quote_table_name(table_name)} ON")
+            internal_execute("SET IDENTITY_INSERT #{quote_table_name(table_name)} ON")
           else
-            execute("SET IDENTITY_INSERT #{quote_table_name(table_name)} OFF")
+            internal_execute("SET IDENTITY_INSERT #{quote_table_name(table_name)} OFF")
           end
         rescue Exception => e
           raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned" +
                 " #{enable ? 'ON' : 'OFF'} for table #{table_name} due : #{e.inspect}"
         end
-
-        def get_table_name(sql, qualified = nil)
-          if sql =~ TABLE_NAME_INSERT_UPDATE
-            tn = $2 || $3
-            qualified ? tn : ArJdbc::MSSQL::Utils.unqualify_table_name(tn)
-          elsif sql =~ TABLE_NAME_FROM
-            qualified ? $1 : ArJdbc::MSSQL::Utils.unqualify_table_name($1)
-          else
-            nil
-          end
-        end
-
-        TABLE_NAME_INSERT_UPDATE = /^\s*(INSERT|EXEC sp_executesql N'INSERT)(?:\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
-
-        TABLE_NAME_FROM = /\bFROM\s+([^\(\)\s,]+)\s*/i
       end
     end
   end

data/lib/arjdbc/mssql/explain_support.rb

@@ -17,7 +17,7 @@ module ActiveRecord
           !DISABLED
         end
 
-        def explain(arel, binds = [])
+        def explain(arel, binds = [], options = [])
           return if DISABLED
 
           if arel.respond_to?(:to_sql)
@@ -25,12 +25,15 @@ module ActiveRecord
           else
             raw_sql, raw_binds = arel, binds
           end
+
           # sql = to_sql(arel, binds)
           # result = with_showplan_on { exec_query(sql, 'EXPLAIN', binds) }
-           sql = interpolate_sql_statement(raw_sql, raw_binds)
-           result = with_showplan_on do
-             exec_query(sql, 'EXPLAIN', [])
-           end
+
+          sql = interpolate_sql_statement(raw_sql, raw_binds)
+
+          result = with_showplan_on do
+            exec_query(sql, 'EXPLAIN', [])
+          end
           PrinterTable.new(result).pp
         end
 

data/lib/arjdbc/mssql/schema_creation.rb

@@ -28,7 +28,7 @@ module ActiveRecord
               statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
             end
 
-            if supports_foreign_keys?
+            if use_foreign_keys?
               statements.concat(o.foreign_keys.map { |fk| accept fk })
             end
 

data/lib/arjdbc/mssql/schema_definitions.rb

@@ -70,6 +70,10 @@ module ActiveRecord
         def uuid(*args, **options)
           args.each { |name| column(name, :uniqueidentifier, **options) }
         end
+
+        def json(*names, **options)
+          names.each { |name| column(name, :text, **options) }
+        end
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
@@ -106,6 +110,12 @@ module ActiveRecord
 
           super
         end
+
+        private
+
+        def valid_column_definition_options
+          super + [:is_identity]
+        end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table

data/lib/arjdbc/mssql/schema_statements.rb

@@ -18,6 +18,7 @@ module ActiveRecord
           string:         { name: 'nvarchar', limit: 4000 },
           text:           { name: 'nvarchar(max)' },
           binary:         { name: 'varbinary(max)' },
+          json:           { name: 'nvarchar(max)' },
           # Other types or SQL Server specific
           bigint:         { name: 'bigint' },
           smalldatetime:  { name: 'smalldatetime' },
@@ -76,11 +77,11 @@ module ActiveRecord
         end
 
         def primary_keys(table_name)
-          @connection.primary_keys(table_name)
+          valid_raw_connection.primary_keys(table_name)
         end
 
         def foreign_keys(table_name)
-          @connection.foreign_keys(table_name)
+          valid_raw_connection.foreign_keys(table_name)
         end
 
         def charset
@@ -151,16 +152,20 @@ module ActiveRecord
           # https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-table-transact-sql?view=sql-server-2017
           if options[:force] == :cascade
             execute_procedure(:sp_fkeys, pktable_name: table_name).each do |fkdata|
-              fktable = fkdata['FKTABLE_NAME']
-              fkcolmn = fkdata['FKCOLUMN_NAME']
-              pktable = fkdata['PKTABLE_NAME']
-              pkcolmn = fkdata['PKCOLUMN_NAME']
-              remove_foreign_key(fktable, name: fkdata['FK_NAME'])
-              execute("DELETE FROM #{quote_table_name(fktable)} WHERE #{quote_column_name(fkcolmn)} IN ( SELECT #{quote_column_name(pkcolmn)} FROM #{quote_table_name(pktable)} )")
+              raw_fktable = fkdata['FKTABLE_NAME']
+              remove_foreign_key(raw_fktable, name: fkdata['FK_NAME'])
+
+              fktable = quote_table_name(fkdata['FKTABLE_NAME'])
+              fkcolmn = quote_column_name(fkdata['FKCOLUMN_NAME'])
+
+              pktable = quote_table_name(fkdata['PKTABLE_NAME'])
+              pkcolmn = quote_column_name(fkdata['PKCOLUMN_NAME'])
+
+              execute("DELETE FROM #{fktable} WHERE #{fkcolmn} IN ( SELECT #{pkcolmn} FROM #{pktable} )")
             end
           end
 
-          if options[:if_exists] && mssql_major_version < 13
+          if options[:if_exists] && mssql_version.major < '13'
             # this is for sql server 2012 and 2014
             execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}"
           else
@@ -169,9 +174,12 @@ module ActiveRecord
           end
         end
 
-        def rename_table(table_name, new_table_name)
-          execute "EXEC sp_rename '#{table_name}', '#{new_table_name}'"
-          rename_table_indexes(table_name, new_table_name)
+        def rename_table(table_name, new_name, **options)
+          validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
+          execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
+          rename_table_indexes(table_name, new_name)
         end
 
         # This is the same as the abstract method
@@ -261,7 +269,10 @@ module ActiveRecord
             options[:precision] = 7
           end
 
-          super
+          # In SQL Server only the first column added should have the `ADD` keyword.
+          fragments = add_timestamps_for_alter(table_name, **options)
+          fragments[1..].each { |fragment| fragment.sub!('ADD ', '') }
+          execute("ALTER TABLE #{quote_table_name(table_name)} #{fragments.join(', ')}")
         end
 
         def add_column(table_name, column_name, type, **options)
@@ -371,7 +382,7 @@ module ActiveRecord
           MSSQL::TableDefinition.new(self, name, **options)
         end
 
-        def new_column_from_field(table_name, field)
+        def new_column_from_field(table_name, field, definitions)
           # NOTE: this method is used by the columns method in the abstract Class
           # to map column_definitions. It would be good if column_definitions is
           # implemented in ruby

data/lib/arjdbc/mssql/server_version.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MSSQL
+      class Version
+        attr_reader :major
+        attr_reader :complete
+        attr_reader :level
+        attr_reader :edition
+
+        VERSION_YEAR = {
+          '8'  => '2000',
+          '9'  => '2005',
+          '10' => '2008',
+          '11' => '2012',
+          '12' => '2014',
+          '13' => '2016',
+          '14' => '2017',
+          '15' => '2019',
+          '16' => '2022'
+        }.freeze
+
+        def initialize(version_array = [])
+          @complete, @major, @level, @edition = version_array
+        end
+
+        def product_name
+          return system_name unless year
+
+          "#{system_name} #{year}"
+        end
+
+        def system_name
+          'Microsoft SQL Server'
+        end
+
+        def year
+          VERSION_YEAR[major]
+        end
+
+        def min_year
+          VERSION_YEAR[min_major]
+        end
+
+        def min_major
+          '13'
+        end
+
+        def support_message
+          "This adapter supports #{system_name} >= #{min_year}."
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/mssql/utils.rb

@@ -27,32 +27,47 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 module ArJdbc
   module MSSQL
     module Utils
+      TABLE_NAME_INSERT_UPDATE = /^\s*(INSERT|EXEC sp_executesql N'INSERT)(?:\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
 
-      module_function
+      TABLE_NAME_FROM = /\bFROM\s+([^\(\)\s,]+)\s*/i
 
-      def unquote_table_name(table_name)
+      def self.insert_sql?(sql)
+        !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
+      end
+
+      def self.get_table_name(sql, qualified = nil)
+        if sql =~ TABLE_NAME_INSERT_UPDATE
+          tn = $2 || $3
+          qualified ? tn : unqualify_table_name(tn)
+        elsif sql =~ TABLE_NAME_FROM
+          qualified ? $1 : unqualify_table_name($1)
+        end
+      end
+
+      def self.unquote_table_name(table_name)
         remove_identifier_delimiters(table_name)
       end
 
-      def unquote_column_name(column_name)
+      def self.unquote_column_name(column_name)
         remove_identifier_delimiters(column_name)
       end
 
-      def unquote_string(string)
+      def self.unquote_string(string)
         string.to_s.gsub("''", "'")
       end
 
-      def unqualify_table_name(table_name)
+      def self.unqualify_table_name(table_name)
         return if table_name.blank?
+
         remove_identifier_delimiters(table_name.to_s.split('.').last)
       end
 
-      def unqualify_table_schema(table_name)
+      def self.unqualify_table_schema(table_name)
         schema_name = table_name.to_s.split('.')[-2]
         schema_name.nil? ? nil : remove_identifier_delimiters(schema_name)
       end
 
-      def unqualify_db_name(table_name)
+      def self.unqualify_db_name(table_name)
         table_names = table_name.to_s.split('.')
         table_names.length == 3 ? remove_identifier_delimiters(table_names.first) : nil
       end
@@ -60,10 +75,9 @@ module ArJdbc
       # private
 
       # See "Delimited Identifiers": http://msdn.microsoft.com/en-us/library/ms176027.aspx
-      def remove_identifier_delimiters(keyword)
+      def self.remove_identifier_delimiters(keyword)
         keyword.to_s.tr("\]\[\"", '')
       end
-
     end
   end
 end