activerecord-jdbc-adapter 50.3-java → 50.8-java

data/lib/arjdbc/mssql/lock_methods.rb

@@ -1,77 +0,0 @@
-require 'strscan'
-
-module ArJdbc
-  module MSSQL
-    module LockMethods
-
-      # @private
-      SELECT_FROM_WHERE_RE = /\A(\s*SELECT\s.*?)(\sFROM\s)(.*?)(\sWHERE\s.*|)\Z/mi
-
-      # Microsoft SQL Server uses its own syntax for SELECT .. FOR UPDATE:
-      # SELECT .. FROM table1 WITH(ROWLOCK,UPDLOCK), table2 WITH(ROWLOCK,UPDLOCK) WHERE ..
-      #
-      # This does in-place modification of the passed-in string.
-      def add_lock!(sql, options)
-        if (lock = options[:lock]) && sql =~ /\A\s*SELECT/mi
-          # Check for and extract the :limit/:offset sub-query
-          if sql =~ /\A(\s*SELECT t\.\* FROM \()(.*)(\) AS t WHERE t._row_num BETWEEN \d+ AND \d+\s*)\Z/m
-            prefix, subselect, suffix = [$1, $2, $3]
-            add_lock!(subselect, options)
-            return sql.replace(prefix + subselect + suffix)
-          end
-          unless sql =~ SELECT_FROM_WHERE_RE
-            # If you get this error, this driver probably needs to be fixed.
-            raise NotImplementedError, "Don't know how to add_lock! to SQL statement: #{sql.inspect}"
-          end
-          select_clause, from_word, from_tables, where_clause = $1, $2, $3, $4
-          with_clause = lock.is_a?(String) ? " #{lock} " : " WITH(ROWLOCK,UPDLOCK) "
-
-          # Split the FROM clause into its constituent tables, and add the with clause after each one.
-          new_from_tables = []
-          scanner = StringScanner.new(from_tables)
-          until scanner.eos?
-            prev_pos = scanner.pos
-            if scanner.scan_until(/,|(INNER\s+JOIN|CROSS\s+JOIN|(LEFT|RIGHT|FULL)(\s+OUTER)?\s+JOIN)\s+/mi)
-              join_operand = scanner.pre_match[prev_pos..-1]
-              join_operator = scanner.matched
-            else
-              join_operand = scanner.rest
-              join_operator = ""
-              scanner.terminate
-            end
-
-            # At this point, we have something like:
-            #   join_operand == "appointments "
-            #   join_operator == "INNER JOIN "
-            # or:
-            #   join_operand == "appointment_details AS d1 ON appointments.[id] = d1.[appointment_id]"
-            #   join_operator == ""
-            if join_operand =~ /\A(.*)(\s+ON\s+.*)\Z/mi
-              table_spec, on_clause = $1, $2
-            else
-              table_spec = join_operand
-              on_clause = ""
-            end
-
-            # Add the "WITH(ROWLOCK,UPDLOCK)" option to the table specification
-            table_spec << with_clause unless table_spec =~ /\A\(\s*SELECT\s+/mi # HACK - this parser isn't so great
-            join_operand = table_spec + on_clause
-
-            # So now we have something like:
-            #   join_operand == "appointments  WITH(ROWLOCK,UPDLOCK) "
-            #   join_operator == "INNER JOIN "
-            # or:
-            #   join_operand == "appointment_details AS d1 WITH(ROWLOCK,UPDLOCK)  ON appointments.[id] = d1.[appointment_id]"
-            #   join_operator == ""
-
-            new_from_tables << join_operand
-            new_from_tables << join_operator
-          end
-          sql.replace( select_clause.to_s << from_word.to_s << new_from_tables.join << where_clause.to_s )
-        end
-        sql
-      end
-
-    end
-  end
-end

data/lib/arjdbc/mssql/types.rb

@@ -1,343 +0,0 @@
-module ArJdbc
-  module MSSQL
-
-    def initialize_type_map(m)
-      #m.register_type              %r{.*},             UnicodeStringType.new
-      # Exact Numerics
-      register_class_with_limit m, /^bigint./,          BigIntegerType
-      m.alias_type                 'bigint',            'bigint(8)'
-      register_class_with_limit m, /^int\(|\s/,         ActiveRecord::Type::Integer
-      m.alias_type                 /^integer/,          'int(4)'
-      m.alias_type                 'int',               'int(4)'
-      register_class_with_limit m, /^smallint./,        SmallIntegerType
-      m.alias_type                 'smallint',          'smallint(2)'
-      register_class_with_limit m, /^tinyint./,         TinyIntegerType
-      m.alias_type                 'tinyint',           'tinyint(1)'
-      m.register_type              /^bit/,              ActiveRecord::Type::Boolean.new
-      m.register_type              %r{\Adecimal} do |sql_type|
-        scale = extract_scale(sql_type)
-        precision = extract_precision(sql_type)
-        DecimalType.new :precision => precision, :scale => scale
-        #if scale == 0
-        #  ActiveRecord::Type::Integer.new(:precision => precision)
-        #else
-        #  DecimalType.new(:precision => precision, :scale => scale)
-        #end
-      end
-      m.alias_type                 %r{\Anumeric},       'decimal'
-      m.register_type              /^money/,            MoneyType.new
-      m.register_type              /^smallmoney/,       SmallMoneyType.new
-      # Approximate Numerics
-      m.register_type              /^float/,            ActiveRecord::Type::Float.new
-      m.register_type              /^real/,             RealType.new
-      # Date and Time
-      m.register_type              /^date\(?/,          ActiveRecord::Type::Date.new
-      m.register_type              /^datetime\(?/,      DateTimeType.new
-      m.register_type              /smalldatetime/,     SmallDateTimeType.new
-      m.register_type              %r{\Atime} do |sql_type|
-        TimeType.new :precision => extract_precision(sql_type)
-      end
-      # Character Strings
-      register_class_with_limit m, %r{\Achar}i,         CharType
-      #register_class_with_limit m, %r{\Avarchar}i,      VarcharType
-      m.register_type              %r{\Anvarchar}i do |sql_type|
-        limit = extract_limit(sql_type)
-        if limit == 2_147_483_647 # varchar(max)
-          VarcharMaxType.new
-        else
-          VarcharType.new :limit => limit
-        end
-      end
-      #m.register_type              'varchar(max)',      VarcharMaxType.new
-      m.register_type              /^text/,             TextType.new
-      # Unicode Character Strings
-      register_class_with_limit m, %r{\Anchar}i,        UnicodeCharType
-      #register_class_with_limit m, %r{\Anvarchar}i,     UnicodeVarcharType
-      m.register_type              %r{\Anvarchar}i do |sql_type|
-        limit = extract_limit(sql_type)
-        if limit == 1_073_741_823 # nvarchar(max)
-          UnicodeVarcharMaxType.new
-        else
-          UnicodeVarcharType.new :limit => limit
-        end
-      end
-      #m.register_type              'nvarchar(max)',     UnicodeVarcharMaxType.new
-      m.alias_type                 'string',            'nvarchar(4000)'
-      m.register_type              /^ntext/,            UnicodeTextType.new
-      # Binary Strings
-      register_class_with_limit m, %r{\Aimage}i,        ImageType
-      register_class_with_limit m, %r{\Abinary}i,       BinaryType
-      register_class_with_limit m, %r{\Avarbinary}i,    VarbinaryType
-      #m.register_type              'varbinary(max)',    VarbinaryMaxType.new
-      # Other Data Types
-      m.register_type              'uniqueidentifier',  UUIDType.new
-      # TODO
-      #m.register_type              'timestamp',         SQLServer::Type::Timestamp.new
-      m.register_type              'xml',               XmlType.new
-    end
-
-    def clear_cache!
-      super
-      reload_type_map
-    end
-
-    # @private
-    class BigIntegerType < ActiveRecord::Type::BigInteger
-      def type; :bigint end
-    end
-
-    # @private
-    SmallIntegerType = ActiveRecord::Type::Integer
-
-    # @private
-    class TinyIntegerType < ActiveRecord::Type::Integer
-      def max_value; 256 end
-      def min_value;   0 end
-    end
-
-    # @private
-    class RealType < ActiveRecord::Type::Float
-      def type; :real end
-    end
-
-    # @private
-    class DecimalType < ActiveRecord::Type::Decimal
-
-      private
-
-      def cast_value(value)
-        return 0 if value.equal? false
-        return 1 if value.equal? true
-
-        if @scale == 0 # act-like an integer
-          return value.to_i rescue nil
-        end
-
-        case value
-        when ::Float
-          if precision
-            BigDecimal(value, float_precision)
-          else
-            value.to_d
-          end
-        when ::Numeric, ::String
-          BigDecimal(value, precision.to_i)
-        else
-          if value.respond_to?(:to_d)
-            value.to_d
-          else
-            BigDecimal(value.to_s, precision.to_i)
-          end
-        end
-      end
-
-      def float_precision
-        if precision.to_i > ::Float::DIG + 1
-          ::Float::DIG + 1
-        else
-          precision.to_i
-        end
-      end
-
-      #def max_value; ::Float::INFINITY end
-
-    end
-
-    # @private
-    class MoneyType < DecimalType
-      def type; :money end
-      def initialize(options = {})
-        super; @precision = 19; @scale = 4
-      end
-    end
-
-    # @private
-    class SmallMoneyType < MoneyType
-      def type; :smallmoney end
-      def initialize(options = {})
-        super; @precision = 10; @scale = 4
-      end
-    end
-
-    # @private
-    class DateTimeType < ActiveRecord::Type::DateTime
-
-      def type_cast_for_schema(value)
-        value.acts_like?(:string) ? "'#{value}'" : "'#{value.to_s(:db)}'"
-      end
-
-      private
-
-      def cast_value(value)
-        value = value.respond_to?(:usec) ? value : super
-        return unless value
-        value.change usec: cast_usec(value)
-      end
-
-      def cast_usec(value)
-        return 0 if !value.respond_to?(:usec) || value.usec.zero?
-        seconds = value.usec.to_f / 1_000_000.0
-        second_precision = 0.00333
-        ss_seconds = ((seconds * (1 / second_precision)).round / (1 / second_precision)).round(3)
-        (ss_seconds * 1_000_000).to_i
-      end
-
-    end
-
-    # @private
-    class SmallDateTimeType < DateTimeType
-      def cast_usec(value); 0 end
-      def cast_usec_for_database(value); '.000' end
-    end
-
-    # @private
-    class TimeType < ActiveRecord::Type::Time
-
-      def initialize(options = {})
-        super; @precision = nil if @precision == 7
-      end
-
-      def type_cast_for_schema(value)
-        value.acts_like?(:string) ? "'#{value}'" : super
-      end
-
-      private
-
-      def cast_value(value)
-        value = value.respond_to?(:usec) ?
-          value.change(year: 2000, month: 01, day: 01) :
-            cast_value_like_super(value)
-
-        return if value.blank?
-        value.change usec: cast_usec(value)
-      end
-
-      def cast_value_like_super(value)
-        return value unless value.is_a?(::String)
-        return if value.empty?
-
-        dummy_value = "2000-01-01 #{value}"
-
-        fast_string_to_time(dummy_value) || DateTime.parse(dummy_value).to_time # rescue nil
-      end
-
-      def cast_usec(value)
-        (usec_to_seconds_frction(value) * 1_000_000).to_i
-      end
-
-      def usec_to_seconds_frction(value)
-        (value.usec.to_f / 1_000_000.0).round(precision || 7)
-      end
-
-      #def quote_usec(value)
-      #  usec_to_seconds_frction(value).to_s.split('.').last
-      #end
-
-    end
-
-    # @private
-    StringType = ActiveRecord::Type::String
-
-    # @private
-    class CharType < StringType
-      def type; :char end
-    end
-
-    # @private
-    class VarcharType < StringType
-      def type; :varchar end
-      def initialize(options = {})
-        super; @limit = 8000 if @limit.to_i == 0
-      end
-    end
-
-    # @private
-    class TextType < StringType
-      def type; :text_basic end
-    end
-
-    # @private
-    class VarcharMaxType < TextType
-      def type; :varchar_max end
-      def limit; @limit ||= 2_147_483_647 end
-    end
-
-    # @private
-    class UnicodeCharType < StringType
-      def type; :nchar end
-    end
-
-    # @private
-    class UnicodeVarcharType < StringType
-      def type; :string end
-      def initialize(options = {})
-        super; @limit = 4000 if @limit.to_i == 0
-      end
-    end
-
-    # @private
-    class UnicodeVarcharMaxType < TextType
-      def type; :text end # :nvarchar_max end
-      def limit; @limit ||= 2_147_483_647 end
-    end
-
-    # @private
-    class UnicodeTextType < TextType
-      def type; :ntext end
-      def limit; @limit ||= 2_147_483_647 end
-    end
-
-    # @private
-    class BinaryType < ActiveRecord::Type::Binary
-      def type; :binary_basic end
-    end
-
-    # @private
-    class ImageType < BinaryType # ActiveRecord::Type::Binary
-      def type; :binary end
-      def limit; @limit ||= 2_147_483_647 end
-    end
-
-    # @private
-    class VarbinaryType < BinaryType # ActiveRecord::Type::Binary
-      def type; :varbinary end
-      def initialize(options = {})
-        super; @limit = 8000 if @limit.to_i == 0
-      end
-    end
-
-    # @private
-    class VarbinaryMaxType < BinaryType # ActiveRecord::Type::Binary
-      def type; :varbinary_max end
-      def limit; @limit ||= 2_147_483_647 end
-    end
-
-    # @private
-    class UUIDType < ActiveRecord::Type::String
-      def type; :uuid end
-
-      alias_method :type_cast_for_database, :type_cast_from_database
-
-      ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
-      def type_cast(value); value.to_s[ACCEPTABLE_UUID, 0] end
-    end
-
-    # @private
-    class XmlType < ActiveRecord::Type::String
-      def type; :xml end
-
-      def type_cast_for_database(value)
-        return unless value
-        Data.new(super)
-      end
-
-      class Data
-        def initialize(value)
-          @value = value
-        end
-        def to_s; @value end
-      end
-    end
-
-  end
-end

data/lib/arjdbc/mssql/utils.rb

@@ -1,82 +0,0 @@
-# NOTE: file contains code adapted from **sqlserver** adapter, license follows
-=begin
-Copyright (c) 2008-2015
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-=end
-
-module ArJdbc
-  module MSSQL
-    module Utils
-
-      module_function
-
-      GET_TABLE_NAME_INSERT_UPDATE_RE =
-        /^\s*(INSERT|EXEC sp_executesql N'INSERT)(?:\s+INTO)?\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
-
-      GET_TABLE_NAME_FROM_RE = /\bFROM\s+([^\(\)\s,]+)\s*/i
-
-      def get_table_name(sql, qualified = nil)
-        if sql =~ GET_TABLE_NAME_INSERT_UPDATE_RE
-          tn = $2 || $3
-          qualified ? tn : unqualify_table_name(tn)
-        elsif sql =~ GET_TABLE_NAME_FROM_RE
-          qualified ? $1 : unqualify_table_name($1)
-        else
-          nil
-        end
-      end
-
-      def unquote_table_name(table_name)
-        remove_identifier_delimiters(table_name)
-      end
-
-      def unquote_column_name(column_name)
-        remove_identifier_delimiters(column_name)
-      end
-
-      def unquote_string(string)
-        string.to_s.gsub("''", "'")
-      end
-
-      def unqualify_table_name(table_name)
-        remove_identifier_delimiters(table_name.to_s.split('.').last)
-      end
-
-      def 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)
-        table_names = table_name.to_s.split('.')
-        table_names.length == 3 ? remove_identifier_delimiters(table_names.first) : nil
-      end
-
-      # private
-
-      # See "Delimited Identifiers": http://msdn.microsoft.com/en-us/library/ms176027.aspx
-      def remove_identifier_delimiters(keyword)
-        keyword.to_s.tr("\]\[\"", '')
-      end
-
-    end
-  end
-end