activerecord-jdbc-alt-adapter 50.3.0-java

data/lib/arjdbc/mssql/column.rb

@@ -0,0 +1,29 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # MSSQL specific extensions to column definitions in a table.
+    class MSSQLColumn < Column
+      def initialize(name, raw_default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
+        default = extract_default(raw_default)
+
+        super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
+      end
+
+      def extract_default(value)
+        # return nil if default does not match the patterns to avoid
+        # any unexpected errors.
+        return unless value =~ /^\(N?'(.*)'\)$/m || value =~ /^\(\(?(.*?)\)?\)$/
+
+        unquote_string(Regexp.last_match[1])
+      end
+
+      def unquote_string(string)
+        string.to_s.gsub("''", "'")
+      end
+
+      def identity?
+        sql_type.downcase.include? 'identity'
+      end
+
+    end
+  end
+end

data/lib/arjdbc/mssql/connection_methods.rb

@@ -0,0 +1,79 @@
+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[: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 = "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)
+  end
+  alias_method :jdbcmssql_connection, :mssql_connection
+
+  # @note Assumes SQLServer SQL-JDBC driver on the class-path.
+  def sqlserver_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::MSSQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    config[:host] ||= 'localhost'
+    config[:driver] ||= 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
+    config[:connection_alive_sql] ||= 'SELECT 1'
+
+    config[:url] ||= begin
+      url = "jdbc:sqlserver://#{config[:host]}"
+      url << ( config[:port] ? ":#{config[:port]};" : ';' )
+      url << "databaseName=#{config[:database]};" if config[:database]
+      url << "instanceName=#{config[:instance]};" if config[:instance]
+      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
+
+end

data/lib/arjdbc/mssql/database_statements.rb

@@ -0,0 +1,134 @@
+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(', ')
+          sql = "EXEC #{proc_name} #{vars}".strip
+          log(sql, 'Execute Procedure') do
+            result = @connection.execute_query_raw(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
+
+        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
+
+        # Implements the truncate method.
+        def truncate(table_name, name = nil)
+          execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+        end
+
+        # Not a rails method, own method to test different isolation
+        # levels supported by the mssql adapter.
+        def supports_transaction_isolation_level?(level)
+          @connection.supports_transaction_isolation?(level)
+        end
+
+        def transaction_isolation=(value)
+          @connection.set_transaction_isolation(value)
+        end
+
+        def transaction_isolation
+          @connection.get_transaction_isolation
+        end
+
+        private
+
+        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)
+          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)}
+            return table_name if insert_columns.include?(id_column)
+          end
+        end
+
+        def identity_column_name(table_name)
+          for column in columns(table_name)
+            return column.name if column.identity?
+          end
+          nil
+        end
+
+        # Turns IDENTITY_INSERT ON for table during execution of the block
+        # N.B. This sets the state of IDENTITY_INSERT to OFF after the
+        # block has been executed without regard to its previous state
+        def with_identity_insert_enabled(table_name)
+          set_identity_insert(table_name, true)
+          yield
+        ensure
+          set_identity_insert(table_name, false)
+        end
+
+        def set_identity_insert(table_name, enable = true)
+          if enable
+            execute("SET IDENTITY_INSERT #{quote_table_name(table_name)} ON")
+          else
+            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
+end

data/lib/arjdbc/mssql/errors.rb

@@ -0,0 +1,6 @@
+module ActiveRecord
+  # Error raised when adapter determines the database could not acquire
+  # a necessary lock before timing out
+  class LockTimeout < StatementInvalid
+  end
+end

data/lib/arjdbc/mssql/explain_support.rb

@@ -0,0 +1,129 @@
+require 'active_support/core_ext/string'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MSSQL
+      # NOTE: the execution plan (explain) is a estimated only for prepared
+      # statements similar the jTDS used to provide. The mssql-jdbc driver
+      # does not supports explain from prepared statements.
+      # more in: https://github.com/Microsoft/mssql-jdbc/issues/778
+      #
+      module ExplainSupport
+        DISABLED = Java::JavaLang::Boolean.getBoolean('arjdbc.mssql.explain_support.disabled')
+
+        def supports_explain?
+          !DISABLED
+        end
+
+        def explain(arel, binds = [])
+          return if DISABLED
+
+          # sql = to_sql(arel, binds)
+          # result = with_showplan_on { exec_query(sql, 'EXPLAIN', binds) }
+           sql = interpolate_sql_statement(arel, binds)
+           result = with_showplan_on do
+             exec_query(sql, 'EXPLAIN', [])
+           end
+          PrinterTable.new(result).pp
+        end
+
+        protected
+
+        # converting the prepared statements to sql
+        def interpolate_sql_statement(arel, binds)
+          return arel if binds.empty?
+
+          sql = if arel.respond_to?(:to_sql)
+                  arel.to_sql
+                else
+                  arel
+                end
+
+          binds.each do |bind|
+            value = quote(bind.value_for_database)
+            sql.sub!('?', value)
+          end
+
+          sql
+        end
+
+        def with_showplan_on
+          set_showplan_option(true)
+          yield
+        ensure
+          set_showplan_option(false)
+        end
+
+        def set_showplan_option(enable = true)
+          option = 'SHOWPLAN_ALL'
+          execute "SET #{option} #{enable ? 'ON' : 'OFF'}"
+        rescue Exception => e
+          raise ActiveRecord::ActiveRecordError, "#{option} could not be turned" +
+            " #{enable ? 'ON' : 'OFF'} (check SHOWPLAN permissions) due : #{e.inspect}"
+        end
+
+        # @private
+        class PrinterTable
+
+          cattr_accessor :max_column_width, :cell_padding
+          self.max_column_width = 50
+          self.cell_padding = 1
+
+          attr_reader :result
+
+          def initialize(result)
+            @result = result
+          end
+
+          def pp
+            @widths = compute_column_widths
+            @separator = build_separator
+            pp = []
+            pp << @separator
+            pp << build_cells(result.columns)
+            pp << @separator
+            result.rows.each do |row|
+              pp << build_cells(row)
+            end
+            pp << @separator
+            pp.join("\n") << "\n"
+          end
+
+          private
+
+          def compute_column_widths
+            [].tap do |computed_widths|
+              result.columns.each_with_index do |column, i|
+                cells_in_column = [column] + result.rows.map { |r| cast_item(r[i]) }
+                computed_width = cells_in_column.map(&:length).max
+                final_width = computed_width > max_column_width ? max_column_width : computed_width
+                computed_widths << final_width
+              end
+            end
+          end
+
+          def build_separator
+            '+' << @widths.map {|w| '-' * (w + (cell_padding * 2))}.join('+') << '+'
+          end
+
+          def build_cells(items)
+            cells = []
+            items.each_with_index do |item, i|
+              cells << cast_item(item).ljust(@widths[i])
+            end
+            "| #{cells.join(' | ')} |"
+          end
+
+          def cast_item(item)
+            case item
+            when NilClass then 'NULL'
+            when Float then item.to_s.to(9)
+            else item.to_s.truncate(max_column_width)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/arjdbc/mssql/extensions.rb

@@ -0,0 +1,36 @@
+# This file contains extensions, overrides, and monkey patches to core parts
+# of active record to allow SQL Server work properly.
+#
+module ActiveRecord
+  module ConnectionAdapters
+    module MSSQL
+      module AttributeMethods
+
+        private
+
+        # Overrides the original attributes_for_update merthod to reject
+        # primary keys because SQL Server does not allow updates
+        # of identity columns.
+        # NOTE: rails 4.1 used to reject primary keys but later changes broke
+        # this behaviour, even the current comments for that method says that
+        # it rejects primary key but it doesn't (maybe a rails bug?)
+        def attributes_for_update(attribute_names)
+          attribute_names.reject do |name|
+            # It seems is only required to check if column in identity or not.
+            # This allows to update rails custom primary keys
+            next true if readonly_attribute?(name)
+
+            column = self.class.columns_hash[name]
+            column && column.identity?
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    include ActiveRecord::ConnectionAdapters::MSSQL::AttributeMethods
+  end
+end

data/lib/arjdbc/mssql/limit_helpers.rb

@@ -0,0 +1,231 @@
+module ArJdbc
+  module MSSQL
+    module LimitHelpers
+
+      # @private
+      FIND_SELECT = /\b(SELECT(\s+DISTINCT)?)\b(.*)/mi
+      # @private
+      FIND_AGGREGATE_FUNCTION = /(AVG|COUNT|COUNT_BIG|MAX|MIN|SUM|STDDEV|STDEVP|VAR|VARP)\(/i
+
+      # @private
+      module SqlServerReplaceLimitOffset
+
+        GROUP_BY = 'GROUP BY'
+        ORDER_BY = 'ORDER BY'
+
+        module_function
+
+        def replace_limit_offset!(sql, limit, offset, order)
+          offset ||= 0
+
+          if match = FIND_SELECT.match(sql)
+            select, distinct, rest_of_query = match[1], match[2], match[3]
+            rest_of_query.strip!
+          end
+          rest_of_query[0] = '*' if rest_of_query[0...1] == '1' && rest_of_query !~ /1 AS/i
+          if rest_of_query[0...1] == '*'
+            from_table = Utils.get_table_name(rest_of_query, true)
+            rest_of_query = "#{from_table}.#{rest_of_query}"
+          end
+
+          # Ensure correct queries if the rest_of_query contains a 'GROUP BY'. Otherwise the following error occurs:
+          #   ActiveRecord::StatementInvalid: ActiveRecord::JDBCError: Column 'users.id' is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.
+          #   SELECT t.* FROM ( SELECT ROW_NUMBER() OVER(ORDER BY users.id) AS _row_num, [users].[lft], COUNT([users].[lft]) FROM [users] GROUP BY [users].[lft] HAVING COUNT([users].[lft]) > 1 ) AS t WHERE t._row_num BETWEEN 1 AND 1
+          if i = ( rest_of_query.rindex(GROUP_BY) || rest_of_query.rindex('group by') )
+            # Do not catch 'GROUP BY' statements from sub-selects, indicated
+            # by more closing than opening brackets after the last group by.
+            rest_after_last_group_by = rest_of_query[i..-1]
+            opening_brackets_count = rest_after_last_group_by.count('(')
+            closing_brackets_count = rest_after_last_group_by.count(')')
+
+            if opening_brackets_count == closing_brackets_count
+              order_start = order.strip[0, 8]; order_start.upcase!
+              if order_start == ORDER_BY && order.match(FIND_AGGREGATE_FUNCTION)
+                # do nothing
+              elsif order.count(',') == 0
+                order.gsub!(/ORDER +BY +([^\s]+)(\s+ASC|\s+DESC)?/i, 'ORDER BY MIN(\1)\2')
+              else
+                raise("can not handle multiple order conditions (#{order.inspect}) in #{sql.inspect}")
+              end
+            end
+          end
+
+          if distinct # select =~ /DISTINCT/i
+            order = order.gsub(/(\[[a-z0-9_]+\]|[a-z0-9_]+)\./, 't.')
+            new_sql = "SELECT t.* FROM "
+            new_sql << "( SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, t.* FROM (#{select} #{rest_of_query}) AS t ) AS t"
+            append_limit_row_num_clause(new_sql, limit, offset)
+          else
+            select_columns_before_from = rest_of_query.gsub(/FROM.*/, '').strip
+            only_one_column            = !select_columns_before_from.include?(',')
+            only_one_id_column         = only_one_column && (select_columns_before_from.ends_with?('.id') || select_columns_before_from.ends_with?('.[id]'))
+
+            if only_one_id_column
+              # If there's only one id column a subquery will be created which only contains this column
+              new_sql = "#{select} t.id FROM "
+            else
+              # All selected columns are used
+              new_sql = "#{select} t.* FROM "
+            end
+            new_sql << "( SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, #{rest_of_query} ) AS t"
+            append_limit_row_num_clause(new_sql, limit, offset)
+          end
+
+          sql.replace new_sql
+        end
+
+        def append_limit_row_num_clause(sql, limit, offset)
+          if limit
+            start_row = offset + 1; end_row = offset + limit.to_i
+            sql << " WHERE t._row_num BETWEEN #{start_row} AND #{end_row}"
+          else
+            sql << " WHERE t._row_num > #{offset}"
+          end
+        end
+
+      end
+
+      # @private
+      module SqlServer2000ReplaceLimitOffset
+
+        module_function
+
+        def replace_limit_offset!(sql, limit, offset, order)
+          if limit
+            offset ||= 0
+            start_row = offset + 1
+            end_row = offset + limit.to_i
+
+            if match = FIND_SELECT.match(sql)
+              select, distinct, rest_of_query = match[1], match[2], match[3]
+            end
+            #need the table name for avoiding amiguity
+            table_name  = Utils.get_table_name(sql, true)
+            primary_key = get_primary_key(order, table_name)
+
+            #I am not sure this will cover all bases.  but all the tests pass
+            if order[/ORDER/].nil?
+              new_order = "ORDER BY #{order}, [#{table_name}].[#{primary_key}]" if order.index("#{table_name}.#{primary_key}").nil?
+            else
+              new_order ||= order
+            end
+
+            if (start_row == 1) && (end_row ==1)
+              new_sql = "#{select} TOP 1 #{rest_of_query} #{new_order}"
+              sql.replace(new_sql)
+            else
+              # We are in deep trouble here. SQL Server does not have any kind of OFFSET build in.
+              # Only remaining solution is adding a where condition to be sure that the ID is not in SELECT TOP OFFSET FROM SAME_QUERY.
+              # To do so we need to extract each part of the query to insert our additional condition in the right place.
+              query_without_select = rest_of_query[/FROM/i=~ rest_of_query.. -1]
+              additional_condition = "#{table_name}.#{primary_key} NOT IN (#{select} TOP #{offset} #{table_name}.#{primary_key} #{query_without_select} #{new_order})"
+
+              # Extract the different parts of the query
+              having, group_by, where, from, selection = split_sql(rest_of_query, /having/i, /group by/i, /where/i, /from/i)
+
+              # Update the where part to add our additional condition
+              if where.blank?
+                where = "WHERE #{additional_condition}"
+              else
+                where = "#{where} AND #{additional_condition}"
+              end
+
+              # Replace the query to be our new customized query
+              sql.replace("#{select} TOP #{limit} #{selection} #{from} #{where} #{group_by} #{having} #{new_order}")
+            end
+          end
+          sql
+        end
+
+        # Split the rest_of_query into chunks based on regexs (applied from end of string to the beginning)
+        # The result is an array of regexs.size+1 elements (the last one being the remaining once everything was chopped away)
+        def split_sql(rest_of_query, *regexs)
+          results = Array.new
+
+          regexs.each do |regex|
+            if position = (regex =~ rest_of_query)
+              # Extract the matched string and chop the rest_of_query
+              matched       = rest_of_query[position..-1]
+              rest_of_query = rest_of_query[0...position]
+            else
+              matched = nil
+            end
+
+            results << matched
+          end
+          results << rest_of_query
+
+          results
+        end
+
+        def get_primary_key(order, table_name) # table_name might be quoted
+          if order =~ /(\w*id\w*)/i
+            $1
+          else
+            unquoted_name = Utils.unquote_table_name(table_name)
+            model = descendants.find { |m| m.table_name == table_name || m.table_name == unquoted_name }
+            model ? model.primary_key : 'id'
+          end
+        end
+
+        private
+
+        if ActiveRecord::VERSION::MAJOR >= 3
+          def descendants; ::ActiveRecord::Base.descendants; end
+        else
+          def descendants; ::ActiveRecord::Base.send(:subclasses) end
+        end
+
+      end
+
+      private
+
+      if ::ActiveRecord::VERSION::MAJOR < 3
+
+        def setup_limit_offset!(version = nil)
+          if version.to_s == '2000' || sqlserver_2000?
+            extend SqlServer2000AddLimitOffset
+          else
+            extend SqlServerAddLimitOffset
+          end
+        end
+
+      else
+
+        def setup_limit_offset!(version = nil); end
+
+      end
+
+      # @private
+      module SqlServerAddLimitOffset
+
+        # @note Only needed with (non-AREL) ActiveRecord **2.3**.
+        # @see Arel::Visitors::SQLServer
+        def add_limit_offset!(sql, options)
+          if options[:limit]
+            order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
+            sql.sub!(/ ORDER BY.*$/i, '')
+            SqlServerReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
+          end
+        end
+
+      end if ::ActiveRecord::VERSION::MAJOR < 3
+
+      # @private
+      module SqlServer2000AddLimitOffset
+
+        # @note Only needed with (non-AREL) ActiveRecord **2.3**.
+        # @see Arel::Visitors::SQLServer
+        def add_limit_offset!(sql, options)
+          if options[:limit]
+            order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
+            sql.sub!(/ ORDER BY.*$/i, '')
+            SqlServer2000ReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
+          end
+        end
+
+      end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    end
+  end
+end