activerecord-jdbc-adapter 1.3.17 → 1.3.18

data/lib/arjdbc/hsqldb/adapter.rb

@@ -245,6 +245,9 @@ module ArJdbc
     # @override
     def supports_views?; true end
 
+    # @override
+    def supports_foreign_keys?; true end
+
     # @override
     def structure_dump
       execute('SCRIPT').map do |result|

data/lib/arjdbc/informix.rb

@@ -2,3 +2,4 @@ require 'arjdbc'
 ArJdbc.load_java_part :Informix
 require 'arjdbc/informix/adapter'
 require 'arjdbc/informix/connection_methods'
+ArJdbc.warn_unsupported_adapter 'informix', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/jdbc.rb

@@ -6,9 +6,26 @@ module ArJdbc
   AR40 = ::ActiveRecord::VERSION::MAJOR > 3
   # @private
   AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
+  # @private
+  AR50 = ::ActiveRecord::VERSION::MAJOR > 4
 
   class << self
 
+    # @private Internal API
+    def warn_unsupported_adapter(adapter, version = nil)
+      warn_prefix = 'NOTE:'
+      if version # e.g. [4, 2]
+        ar_version = [ ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR, ActiveRecord::VERSION::TINY ]
+        if ( ar_version <=> version ) >= 0 # e.g. 4.2.0 > 4.2
+          warn_prefix = "NOTE: ActiveRecord #{version.join('.')} with"
+        else
+          warn_prefix = nil
+        end
+      end
+      warn "#{warn_prefix} adapter: #{adapter} is not (yet) fully supported by AR-JDBC," <<
+      " please consider helping us out." if warn_prefix
+    end
+
     def warn(message, once = nil)
       super(message) || true if warn?(message, once)
     end

data/lib/arjdbc/jdbc/adapter.rb

@@ -593,6 +593,17 @@ module ActiveRecord
       end
       private :_execute
 
+      # Kind of `execute(sql) rescue nil` but logging failures at debug level only.
+      def execute_quietly(sql, name = 'SQL')
+        log(sql, name) do
+          begin
+            _execute(sql)
+          rescue => e
+            logger.debug("#{e.class}: #{e.message}: #{sql}")
+          end
+        end
+      end
+
       # @override
       def tables(name = nil)
         @connection.tables
@@ -624,6 +635,18 @@ module ActiveRecord
         @connection.primary_keys(table)
       end
 
+      # @override
+      def foreign_keys(table_name)
+        @connection.foreign_keys(table_name)
+      end if ArJdbc::AR42
+
+      # Does our database (+ its JDBC driver) support foreign-keys?
+      # @since 1.3.18
+      # @override
+      def supports_foreign_keys?
+        @connection.supports_foreign_keys?
+      end if ArJdbc::AR42
+
       # @deprecated Rather use {#update_lob_value} instead.
       def write_large_object(*args)
         @connection.write_large_object(*args)
@@ -934,10 +957,12 @@ module ActiveRecord
 
       end
 
-
       if ActiveRecord::VERSION::MAJOR < 4 # emulating Rails 3.x compatibility
-        JdbcConnection.raw_date_time = true if JdbcConnection.raw_date_time? == nil
-        JdbcConnection.raw_boolean = true if JdbcConnection.raw_boolean? == nil
+        JdbcConnection.raw_date_time = true if JdbcConnection.raw_date_time?.nil?
+        JdbcConnection.raw_boolean = true if JdbcConnection.raw_boolean?.nil?
+      elsif ArJdbc::AR42 # AR::Type should do the conversion - for better accuracy
+        JdbcConnection.raw_date_time = true if JdbcConnection.raw_date_time?.nil?
+        JdbcConnection.raw_boolean = true if JdbcConnection.raw_boolean?.nil?
       end
 
     end

data/lib/arjdbc/jdbc/column.rb

@@ -10,7 +10,8 @@ module ActiveRecord
     # specific type.
     # @see JdbcAdapter#jdbc_column_class
     class JdbcColumn < Column
-      attr_writer :limit, :precision
+      # @deprecated attribute writers will be removed in 1.4
+      attr_writer :limit, :precision # unless ArJdbc::AR42
 
       def initialize(config, name, *args)
         if self.class == JdbcColumn
@@ -24,9 +25,12 @@ module ActiveRecord
             default = args.shift
           end
         end
+        default = default_value(default)
+        default = args[0].type_cast_from_database(default) if ArJdbc::AR42
+
         # super <= 4.1: (name, default, sql_type = nil, null = true)
         # super >= 4.2: (name, default, cast_type, sql_type = nil, null = true)
-        super(name, default_value(default), *args)
+        super(name, default, *args)
         init_column(name, default, *args)
       end
 
@@ -34,7 +38,7 @@ module ActiveRecord
       def init_column(*args); end
 
       # Similar to `ActiveRecord`'s `extract_value_from_default(default)`.
-      # @return default value for a given column
+      # @return default value for a column (possibly extracted from driver value)
       def default_value(value); value; end
 
       protected

data/lib/arjdbc/jdbc/type_cast.rb

@@ -33,6 +33,7 @@ module ActiveRecord::ConnectionAdapters
       def string_to_time(string)
         return string unless string.is_a?(String)
         return nil if string.empty?
+        return string if string =~ /^-?infinity$/.freeze
 
         fast_string_to_time(string) || fallback_string_to_time(string)
       end
@@ -134,6 +135,7 @@ module ActiveRecord::ConnectionAdapters
         def fallback_string_to_time(string)
           time_hash = Date._parse(string)
           time_hash[:sec_fraction] = microseconds(time_hash)
+          time_hash[:year] *= -1 if time_hash[:zone] == 'BC'
 
           new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
         end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -5,10 +5,23 @@ module ActiveRecord
     # but apparently a database driver can return multiple types for a given
     # java.sql.Types constant.  So this type converter uses some heuristics to try to pick
     # the best (most common) type to use.  It's not great, it would be better to just
-    # delegate to each database's existin AR adapter's native_database_types method, but I
+    # delegate to each database's existing AR adapter's native_database_types method, but I
     # wanted to try to do this in a way that didn't pull in all the other adapters as
-    # dependencies.  Suggestions appreciated.
+    # dependencies. Improvements appreciated.
     class JdbcTypeConverter
+
+      # @private
+      TEXT_TYPES = [ Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB ]
+      private_constant :TEXT_TYPES if respond_to? :private_constant
+
+      # @private
+      FLOAT_TYPES = [ Jdbc::Types::FLOAT, Jdbc::Types::DOUBLE, Jdbc::Types::REAL ]
+      private_constant :FLOAT_TYPES if respond_to? :private_constant
+
+      # @private
+      BINARY_TYPES = [ Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB ]
+      private_constant :BINARY_TYPES if respond_to? :private_constant
+
       # The basic ActiveRecord types, mapped to an array of procs that are used to #select
       # the best type.  The procs are used as selectors in order until there is only one
       # type left.  If all the selectors are applied and there is still more than one
@@ -18,7 +31,7 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^varchar/i},
                           lambda {|r| r['type_name'] =~ /^varchar$/i},
                           lambda {|r| r['type_name'] =~ /varying/i}],
-        :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'].to_i)},
+        :text        => [ lambda {|r| TEXT_TYPES.include?(r['data_type'].to_i)},
                           lambda {|r| r['type_name'] =~ /^text$/i},     # For Informix
                           lambda {|r| r['type_name'] =~ /sub_type 1$/i}, # For FireBird
                           lambda {|r| r['type_name'] =~ /^(text|clob)$/i},
@@ -35,7 +48,7 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^real$/i},
                           lambda {|r| r['precision'] == '38'},
                           lambda {|r| r['data_type'].to_i == Jdbc::Types::DECIMAL}],
-        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE, Jdbc::Types::REAL].include?(r['data_type'].to_i)},
+        :float       => [ lambda {|r| FLOAT_TYPES.include?(r['data_type'].to_i)},
                           lambda {|r| r['data_type'].to_i == Jdbc::Types::REAL}, #Prefer REAL to DOUBLE for Postgresql
                           lambda {|r| r['type_name'] =~ /^float/i},
                           lambda {|r| r['type_name'] =~ /^double$/i},
@@ -63,12 +76,13 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^date$/i},
                           lambda {|r| r['type_name'] =~ /^date/i},
                           lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver3
-        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'].to_i)},
+        :binary      => [ lambda {|r| BINARY_TYPES.include?(r['data_type'].to_i)},
                           lambda {|r| r['type_name'] =~ /^blob/i},
                           lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
                           lambda {|r| r['type_name'] =~ /^varbinary$/i}, # We want this sucker for Mimer
                           lambda {|r| r['type_name'] =~ /^binary$/i}, ],
-        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'].to_i)},
+        :boolean     => [ lambda {|r| Jdbc::Types::BIT == r['data_type'].to_i && r['precision'].to_i == 1},
+                          lambda {|r| Jdbc::Types::TINYINT == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^bool/i},
                           lambda {|r| r['data_type'].to_i == Jdbc::Types::BIT},
                           lambda {|r| r['type_name'] =~ /^tinyint$/i},
@@ -90,25 +104,24 @@ module ActiveRecord
           set_limit_to_nonzero_precision(type_map[k], row)
         end
 
-        AR_TO_JDBC_TYPES.keys.each do |k|
-          typerow = choose_type(k)
-          type_map[k] = { :name => typerow['type_name'].downcase }
-          case k
+        AR_TO_JDBC_TYPES.keys.each do |ar_type|
+          typerow = choose_type(ar_type)
+          type_map[ar_type] = { :name => typerow['type_name'].downcase }
+          case ar_type
           when :integer, :string, :decimal
-            set_limit_to_nonzero_precision(type_map[k], typerow)
+            set_limit_to_nonzero_precision(type_map[ar_type], typerow)
           when :boolean
-            type_map[k][:limit] = 1
+            type_map[ar_type][:limit] = 1
           end
         end
         type_map
       end
 
       def choose_type(ar_type)
-        procs = AR_TO_JDBC_TYPES[ar_type]
         types = @types
-        procs.each do |p|
+        AR_TO_JDBC_TYPES[ar_type].each do |proc|
           new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
-          new_types = new_types.select(&p)
+          new_types = new_types.select(&proc)
           new_types = new_types.inject([]) do |typs,t|
             typs << t unless typs.detect {|el| el['type_name'] == t['type_name']}
             typs

data/lib/arjdbc/mimer.rb

@@ -1,2 +1,3 @@
 require 'arjdbc'
 require 'arjdbc/mimer/adapter'
+ArJdbc.warn_unsupported_adapter 'mimer', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/mssql.rb

@@ -3,4 +3,5 @@ require 'arjdbc/mssql/adapter'
 require 'arjdbc/mssql/connection_methods'
 module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
-end
+end
+ArJdbc.warn_unsupported_adapter 'mssql', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/mssql/adapter.rb

@@ -1,14 +1,41 @@
+# 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
+
 ArJdbc.load_java_part :MSSQL
 
 require 'strscan'
-require 'arjdbc/mssql/utils'
-require 'arjdbc/mssql/limit_helpers'
-require 'arjdbc/mssql/lock_methods'
-require 'arjdbc/mssql/column'
-require 'arjdbc/mssql/explain_support'
 
 module ArJdbc
   module MSSQL
+
+    require 'arjdbc/mssql/utils'
+    require 'arjdbc/mssql/limit_helpers'
+    require 'arjdbc/mssql/lock_methods'
+    require 'arjdbc/mssql/column'
+    require 'arjdbc/mssql/explain_support'
+    require 'arjdbc/mssql/types' if AR42
+
     include LimitHelpers
     include Utils
     include ExplainSupport
@@ -45,6 +72,17 @@ module ArJdbc
     # @see #update_lob_values?
     def self.update_lob_values=(update); @@update_lob_values = update; end
 
+    # @private
+    @@cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
+
+    # Operator for sorting strings in SQLServer, setup as :
+    #
+    #  ArJdbc::MSSQL.cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
+    #
+    def self.cs_equality_operator; @@cs_equality_operator; end
+    # @see #cs_equality_operator
+    def self.cs_equality_operator=(operator); @@cs_equality_operator = operator; end
+
     # @see #quote
     # @private
     BLOB_VALUE_MARKER = "''"
@@ -70,6 +108,10 @@ module ArJdbc
         ::Arel::Visitors::SQLServer2000 : ::Arel::Visitors::SQLServer
     end
 
+    def self.arel_visitor_type(config)
+      require 'arel/visitors/sql_server'; ::Arel::Visitors::SQLServerNG
+    end if AR42
+
     # @deprecated no longer used
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#arel2_visitors
     def self.arel2_visitors(config)
@@ -89,17 +131,54 @@ module ArJdbc
       end
     end
 
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => 'int NOT NULL IDENTITY(1,1) PRIMARY KEY',
+      :integer   =>  { :name => 'int', }, # :limit => 4
+      :boolean   =>  { :name => 'bit' },
+      :decimal   =>  { :name => 'decimal' },
+      :float     =>  { :name => 'float' },
+      :bigint    =>  { :name => 'bigint' },
+      :real      =>  { :name => 'real' },
+      :date      =>  { :name => 'date' },
+      :time      =>  { :name => 'time' },
+      :datetime  =>  { :name => 'datetime' },
+      :timestamp =>  { :name => 'datetime' },
+
+      :string    =>  { :name => 'nvarchar', :limit => 4000 },
+      #:varchar    =>  { :name => 'varchar' }, # limit: 8000
+      :text      =>  { :name => 'nvarchar(max)' },
+      :text_basic =>  { :name => 'text' },
+      #:ntext      =>  { :name => 'ntext' },
+      :char      =>  { :name => 'char' },
+      #:nchar     =>  { :name => 'nchar' },
+      :binary    =>  { :name => 'image' }, # NOTE: :name => 'varbinary(max)'
+      :binary_basic => { :name => 'binary' },
+      :uuid      =>  { :name => 'uniqueidentifier' },
+      :money     =>  { :name => 'money' },
+      #:smallmoney => { :name => 'smallmoney' },
+    }
+
+    def native_database_types
+      # NOTE: due compatibility we're using the generic type resolution
+      # ... NATIVE_DATABASE_TYPES won't be used at all on SQLServer 2K
+      sqlserver_2000? ? super : super.merge(NATIVE_DATABASE_TYPES)
+    end
+
     def modify_types(types)
-      types[:string] = { :name => "NVARCHAR", :limit => 255 }
       if sqlserver_2000?
-        types[:text] = { :name => "NTEXT" }
+        types[:primary_key] = NATIVE_DATABASE_TYPES[:primary_key]
+        types[:string] = NATIVE_DATABASE_TYPES[:string]
+        types[:boolean] = NATIVE_DATABASE_TYPES[:boolean]
+        types[:text] = { :name => "ntext" }
+        types[:integer][:limit] = nil
+        types[:binary] = { :name => "image" }
       else
-        types[:text] = { :name => "NVARCHAR(MAX)" }
+        # ~ private types for better "native" adapter compatibility
+        types[:varchar_max]   =  { :name => 'varchar(max)' }
+        types[:nvarchar_max]  =  { :name => 'nvarchar(max)' }
+        types[:varbinary_max] =  { :name => 'varbinary(max)' }
       end
-      types[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
-      types[:integer][:limit] = nil
-      types[:boolean] = { :name => "bit" }
-      types[:binary] = { :name => "image" }
+      types[:string][:limit] = 255 unless AR40 # backwards compatibility
       types
     end
 
@@ -515,13 +594,6 @@ module ArJdbc
 
     # @private
     SKIP_COLUMNS_TABLE_NAMES_RE = /^information_schema\./i
-    # @private
-    IDENTITY_COLUMN_TYPE_RE = /identity/i
-    # NOTE: these do not handle = equality as expected
-    # see {#repair_special_columns}
-    # (TEXT, NTEXT, and IMAGE data types are deprecated)
-    # @private
-    SPECIAL_COLUMN_TYPE_RE = /text|ntext|image|xml/i
 
     # @private
     EMPTY_ARRAY = [].freeze
@@ -537,12 +609,7 @@ module ArJdbc
       return default if table_name =~ SKIP_COLUMNS_TABLE_NAMES_RE
 
       unless columns = ( @table_columns ||= {} )[table_name]
-        columns = super(table_name, name)
-        for column in columns
-          column.identity = true if column.sql_type =~ IDENTITY_COLUMN_TYPE_RE
-          column.special = true if column.sql_type =~ SPECIAL_COLUMN_TYPE_RE
-        end
-        @table_columns[table_name] = columns
+        @table_columns[table_name] = columns = super(table_name, name)
       end
       columns
     end
@@ -572,14 +639,19 @@ module ArJdbc
             " #{enable ? 'ON' : 'OFF'} for table #{table_name} due : #{e.inspect}"
     end
 
+    def disable_referential_integrity
+      execute "EXEC sp_MSforeachtable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'"
+      yield
+    ensure
+      execute "EXEC sp_MSforeachtable 'ALTER TABLE ? CHECK CONSTRAINT ALL'"
+    end
+
     # @private
     # @see ArJdbc::MSSQL::LimitHelpers
     def determine_order_clause(sql)
       return $1 if sql =~ /ORDER BY (.*)$/i
-      table_name = get_table_name(sql)
-      # determine primary key for table :
-      columns = self.columns(table_name)
-      primary_column = columns.find { |column| column.primary || column.identity }
+      columns = self.columns(table_name = get_table_name(sql))
+      primary_column = columns.find { |column| column.primary? || column.identity? }
       unless primary_column # look for an id column and return it,
         # without changing case, to cover DBs with a case-sensitive collation :
         primary_column = columns.find { |column| column.name =~ /^id$/i }
@@ -708,7 +780,7 @@ module ArJdbc
       columns = self.columns(qualified_table_name, nil, nil)
       return columns if ! columns || columns.empty?
       special = []
-      columns.each { |column| special << column.name if column.special }
+      columns.each { |column| special << column.name if column.special? }
       special
     end
 
@@ -735,6 +807,9 @@ module ActiveRecord::ConnectionAdapters
       setup_limit_offset!
     end
 
+    def self.cs_equality_operator; ::ArJdbc::MSSQL.cs_equality_operator end
+    def self.cs_equality_operator=(operator); ::ArJdbc::MSSQL.cs_equality_operator = operator end
+
   end
 
   class MSSQLColumn < JdbcColumn