activerecord-jdbc-adapter 51.4-java → 51.5-java

data/lib/arjdbc/mssql/column.rb

@@ -1,200 +0,0 @@
-module ArJdbc
-  module MSSQL
-
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
-    def self.column_selector
-      [ /sqlserver|tds|Microsoft SQL/i, lambda { |config, column| column.extend(Column) } ]
-    end
-
-    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
-    module Column
-
-      def self.included(base)
-        # NOTE: assumes a standalone MSSQLColumn class
-        class << base; include Cast; end
-      end
-
-      include LockMethods unless AR42
-
-      # @override
-      def simplified_type(field_type)
-        case field_type
-        when /int|bigint|smallint|tinyint/i           then :integer
-        when /numeric/i                               then (@scale.nil? || @scale == 0) ? :integer : :decimal
-        when /float|double|money|real|smallmoney/i    then :decimal
-        when /datetime|smalldatetime/i                then :datetime
-        when /timestamp/i                             then :timestamp
-        when /time/i                                  then :time
-        when /date/i                                  then :date
-        when /text|ntext|xml/i                        then :text
-        when /binary|image|varbinary/i                then :binary
-        when /char|nchar|nvarchar|string|varchar/i    then (@limit == 1073741823 ? (@limit = nil; :text) : :string)
-        when /bit/i                                   then :boolean
-        when /uniqueidentifier/i                      then :string
-        else
-          super
-        end
-      end
-
-      # @override
-      def default_value(value)
-        return $1 if value =~ /^\(N?'(.*)'\)$/ || value =~ /^\(\(?(.*?)\)?\)$/
-        value
-      end
-
-      # @override
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-        when :integer then ( value.is_a?(String) ? unquote(value) : (value || 0) ).to_i
-        when :primary_key then value.respond_to?(:to_i) ? value.to_i : ((value && 1) || 0)
-        when :decimal   then self.class.value_to_decimal(unquote(value))
-        when :date      then self.class.string_to_date(value)
-        when :datetime  then self.class.string_to_time(value)
-        when :timestamp then self.class.string_to_time(value)
-        when :time      then self.class.string_to_dummy_time(value)
-        when :boolean   then value == true || (value =~ /^t(rue)?$/i) == 0 || unquote(value) == '1'
-        when :binary    then unquote(value)
-        else value
-        end
-      end
-
-      # @override
-      def extract_limit(sql_type)
-        case sql_type
-        when /^smallint/i
-          2
-        when /^int/i
-          4
-        when /^bigint/i
-          8
-        when /\(max\)/, /decimal/, /numeric/
-          nil
-        when /text|ntext|xml|binary|image|varbinary|bit/
-          nil
-        else
-          super
-        end
-      end
-
-      # #primary replacement that works on 4.2 as well
-      # #columns will set @primary even when on AR 4.2
-      def primary?; @primary end
-      alias_method :is_primary, :primary?
-
-      def identity?
-        !! sql_type.downcase.index('identity')
-      end
-      # @deprecated
-      alias_method :identity, :identity?
-      alias_method :is_identity, :identity?
-
-      # NOTE: these do not handle = equality as expected
-      # see {#repair_special_columns}
-      # (TEXT, NTEXT, and IMAGE data types are deprecated)
-      # @private
-      def special?
-        unless defined? @special # /text|ntext|image|xml/i
-          sql_type = @sql_type.downcase
-          @special = !! ( sql_type.index('text') || sql_type.index('image') || sql_type.index('xml') )
-        end
-        @special
-      end
-      # @deprecated
-      alias_method :special, :special?
-      alias_method :is_special, :special?
-
-      def is_utf8?
-        !!( sql_type =~ /nvarchar|ntext|nchar/i )
-      end
-
-      private
-
-      def unquote(value)
-        value.to_s.sub(/\A\([\(\']?/, "").sub(/[\'\)]?\)\Z/, "")
-      end
-
-      # @deprecated no longer used
-      def cast_to_time(value)
-        return value if value.is_a?(Time)
-        DateTime.parse(value).to_time rescue nil
-      end
-
-      # @deprecated no longer used
-      def cast_to_date(value)
-        return value if value.is_a?(Date)
-        return Date.parse(value) rescue nil
-      end
-
-      # @deprecated no longer used
-      def cast_to_datetime(value)
-        if value.is_a?(Time)
-          if value.year != 0 and value.month != 0 and value.day != 0
-            return value
-          else
-            return Time.mktime(2000, 1, 1, value.hour, value.min, value.sec) rescue nil
-          end
-        end
-        if value.is_a?(DateTime)
-          begin
-            # Attempt to convert back to a Time, but it could fail for dates significantly in the past/future.
-            return Time.mktime(value.year, value.mon, value.day, value.hour, value.min, value.sec)
-          rescue ArgumentError
-            return value
-          end
-        end
-
-        return cast_to_time(value) if value.is_a?(Date) or value.is_a?(String) rescue nil
-
-        return value.is_a?(Date) ? value : nil
-      end
-
-      module Cast
-
-        def string_to_date(value)
-          return value unless value.is_a?(String)
-          return nil if value.empty?
-
-          date = fast_string_to_date(value)
-          date ? date : Date.parse(value) rescue nil
-        end
-
-        def string_to_time(value)
-          return value unless value.is_a?(String)
-          return nil if value.empty?
-
-          fast_string_to_time(value) || DateTime.parse(value).to_time rescue nil
-        end
-
-        ISO_TIME = /\A(\d\d)\:(\d\d)\:(\d\d)(\.\d+)?\z/
-
-        def string_to_dummy_time(value)
-          return value unless value.is_a?(String)
-          return nil if value.empty?
-
-          if value =~ ISO_TIME # "12:34:56.1234560"
-            microsec = ($4.to_f * 1_000_000).round.to_i
-            new_time 2000, 1, 1, $1.to_i, $2.to_i, $3.to_i, microsec
-          else
-            super(value)
-          end
-        end
-
-        def string_to_binary(value)
-          # this will only allow the adapter to insert binary data with a length
-          # of 7K or less because of a SQL Server statement length policy ...
-          "0x#{value.unpack("H*")}" # "0x#{value.unpack("H*")[0]}"
-        end
-
-        def binary_to_string(value)
-          if value.respond_to?(:force_encoding) && value.encoding != Encoding::ASCII_8BIT
-            value = value.force_encoding(Encoding::ASCII_8BIT)
-          end
-          value =~ /[^[:xdigit:]]/ ? value : [value].pack('H*')
-        end
-
-      end
-
-    end
-  end
-end

data/lib/arjdbc/mssql/connection_methods.rb

@@ -1,79 +0,0 @@
-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/explain_support.rb

@@ -1,99 +0,0 @@
-require 'active_support/core_ext/string'
-
-module ArJdbc
-  module MSSQL
-    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) }
-        PrinterTable.new(result).pp
-      end
-
-      protected
-
-      def with_showplan_on
-        set_showplan_option(true)
-        yield
-      ensure
-        set_showplan_option(false)
-      end
-
-      def set_showplan_option(enable = true)
-        option = 'SHOWPLAN_TEXT'
-        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

data/lib/arjdbc/mssql/limit_helpers.rb

@@ -1,231 +0,0 @@
-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