activerecord-jdbc-adapter 1.3.17 → 1.3.18

data/lib/arjdbc.rb

@@ -16,10 +16,4 @@ else
   warn "activerecord-jdbc-adapter is for use with JRuby only"
 end
 
-require 'arjdbc/version'
-
-# TODO: remove this "HINT" once AR 4.2 is working ~ fairly reliable :
-if ActiveRecord::VERSION::STRING[0, 3] == '4.2' && ENV['AR_JDBC_42'] != 'true'
-  ArJdbc.warn "NOTE: ActiveRecord 4.2 is not (yet) fully supported by AR-JDBC," <<
-  " please help us finish 4.2 support - check http://bit.ly/jruby-42 for starters"
-end
+require 'arjdbc/version'

data/lib/arjdbc/db2.rb

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

data/lib/arjdbc/db2/adapter.rb

@@ -1,3 +1,27 @@
+# NOTE: file contains code adapted from **ruby-ibmdb** adapter, license follows
+=begin
+Copyright (c) 2006 - 2015 IBM Corporation
+
+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 :DB2
 
 require 'arjdbc/db2/column'
@@ -111,6 +135,78 @@ module ArJdbc
       #:graphic    => { :name => "graphic", :limit => 1 }, # :limit => 127
     }
 
+    # @override
+    def initialize_type_map(m)
+      register_class_with_limit m, %r(boolean)i,   ActiveRecord::Type::Boolean
+      register_class_with_limit m, %r(char)i,      ActiveRecord::Type::String
+      register_class_with_limit m, %r(binary)i,    ActiveRecord::Type::Binary
+      register_class_with_limit m, %r(text)i,      ActiveRecord::Type::Text
+      register_class_with_limit m, %r(date)i,      ActiveRecord::Type::Date
+      register_class_with_limit m, %r(time)i,      ActiveRecord::Type::Time
+      register_class_with_limit m, %r(datetime)i,  ActiveRecord::Type::DateTime
+      register_class_with_limit m, %r(float)i,     ActiveRecord::Type::Float
+      register_class_with_limit m, %r(int)i,       ActiveRecord::Type::Integer
+
+      m.alias_type %r(blob)i,      'binary'
+      m.alias_type %r(clob)i,      'text'
+      m.alias_type %r(timestamp)i, 'datetime'
+      m.alias_type %r(numeric)i,   'decimal'
+      m.alias_type %r(number)i,    'decimal'
+      m.alias_type %r(double)i,    'float'
+      m.alias_type %r(real)i,      'float'
+
+      m.register_type(%r(decimal)i) do |sql_type|
+        scale = extract_scale(sql_type)
+        precision = extract_precision(sql_type)
+        limit = extract_limit(sql_type)
+        if scale == 0
+          ActiveRecord::Type::BigInteger.new(:precision => precision, :limit => limit)
+        else
+          ActiveRecord::Type::Decimal.new(:precision => precision, :scale => scale)
+        end
+      end
+
+      m.alias_type %r(for bit data)i,  'binary'
+      m.alias_type %r(smallint)i,      'boolean'
+      m.alias_type %r(serial)i,        'int'
+      m.alias_type %r(decfloat)i,      'decimal'
+      #m.alias_type %r(real)i,          'decimal'
+      m.alias_type %r(graphic)i,       'binary'
+      m.alias_type %r(rowid)i,         'int'
+
+      m.register_type(%r(smallint)i) do
+        if DB2.emulate_booleans?
+          ActiveRecord::Type::Boolean.new
+        else
+          ActiveRecord::Type::Integer.new(:limit => 1)
+        end
+      end
+
+      m.register_type %r(xml)i, XmlType.new
+    end if AR42
+
+    # @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 if AR42
+
+    # @override
+    def reset_column_information
+      initialize_type_map(type_map)
+    end if AR42
+
     # @override
     def native_database_types
       # NOTE: currently merging with what JDBC gives us since there's a lot
@@ -389,31 +485,35 @@ module ArJdbc
     # @note Only used with (non-AREL) ActiveRecord **2.3**.
     # @see Arel::Visitors::DB2
     def add_limit_offset!(sql, options)
-      replace_limit_offset!(sql, options[:limit], options[:offset])
+      limit = options[:limit]
+      replace_limit_offset!(sql, limit, options[:offset]) if limit
     end if ::ActiveRecord::VERSION::MAJOR < 3
 
     # @private shared with {Arel::Visitors::DB2}
-    def replace_limit_offset!(sql, limit, offset)
-      return sql unless limit
-
+    def replace_limit_offset!(sql, limit, offset, orders = nil)
       limit = limit.to_i
-      if offset
-        replace_limit_offset_with_ordering!(sql, limit, offset)
+
+      if offset # && limit
+        over_order_by = nil # NOTE: orders matching got reverted as it was not complete and there were no case covering it ...
+
+        start_sql = "SELECT B.* FROM (SELECT A.*, row_number() OVER (#{over_order_by}) AS internal$rownum FROM (SELECT"
+        end_sql = ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset.to_i}"
+
+        if sql.is_a?(String)
+          sql.sub!(/SELECT/i, start_sql)
+          sql << end_sql
+        else # AR 4.2 sql.class ... Arel::Collectors::Bind
+          sql.parts[0] = start_sql # sql.sub! /SELECT/i
+          sql.parts[ sql.parts.length ] = end_sql
+        end
       else
-        if limit == 1
-          sql << " FETCH FIRST ROW ONLY"
-        else
-          sql << " FETCH FIRST #{limit} ROWS ONLY"
+        limit_sql = limit == 1 ? " FETCH FIRST ROW ONLY" : " FETCH FIRST #{limit} ROWS ONLY"
+        if sql.is_a?(String)
+          sql << limit_sql
+        else # AR 4.2 sql.class ... Arel::Collectors::Bind
+          sql.parts[ sql.parts.length ] = limit_sql
         end
-        sql
       end
-    end
-
-    # @private used from {Arel::Visitors::DB2}
-    def replace_limit_offset_with_ordering!(sql, limit, offset, orders = nil)
-      over_order_by = nil # NOTE: orders matching got reverted as it was not complete and there were no case covering it ...
-      sql.sub!(/SELECT/i, "SELECT B.* FROM (SELECT A.*, row_number() OVER (#{over_order_by}) AS internal$rownum FROM (SELECT")
-      sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset}"
       sql
     end
 

data/lib/arjdbc/derby/adapter.rb

@@ -138,16 +138,16 @@ module ArJdbc
       :primary_key => "int GENERATED BY DEFAULT AS identity NOT NULL PRIMARY KEY",
       :string => { :name => "varchar", :limit => 255 }, # 32672
       :text => { :name => "clob" }, # 2,147,483,647
-      :char => { :name => "char", :limit => 254 }, # JDBC limit: 254
+      :char => { :name => "char", :limit => 254 }, # JDBC :limit => 254
       :binary => { :name => "blob" }, # 2,147,483,647
       :float => { :name => "float", :limit => 8 }, # DOUBLE PRECISION
-      :real => { :name => "real", :limit => 4 }, # JDBC limit: 23
-      :double => { :name => "double", :limit => 8 }, # JDBC limit: 52
-      :decimal => { :name => "decimal", :precision => 5, :scale => 0 }, # JDBC limit: 31
-      :numeric => { :name => "decimal", :precision => 5, :scale => 0 }, # JDBC limit: 31
-      :integer => { :name => "integer", :limit => 4 }, # JDBC limit: 10
-      :smallint => { :name => "smallint", :limit => 2 }, # JDBC limit: 5
-      :bigint => { :name => "bigint", :limit => 8 }, # JDBC limit: 19
+      :real => { :name => "real", :limit => 4 }, # JDBC :limit => 23
+      :double => { :name => "double", :limit => 8 }, # JDBC :limit => 52
+      :decimal => { :name => "decimal", :precision => 5, :scale => 0 }, # JDBC :limit => 31
+      :numeric => { :name => "decimal", :precision => 5, :scale => 0 }, # JDBC :limit => 31
+      :integer => { :name => "integer", :limit => 4 }, # JDBC :limit => 10
+      :smallint => { :name => "smallint", :limit => 2 }, # JDBC :limit => 5
+      :bigint => { :name => "bigint", :limit => 8 }, # JDBC :limit => 19
       :date => { :name => "date" },
       :time => { :name => "time" },
       :datetime => { :name => "timestamp" },
@@ -157,6 +157,23 @@ module ArJdbc
       :object => { :name => "object" },
     }
 
+    # @private
+    def initialize_type_map(m)
+      super
+      m.register_type(%r(smallint)i) do |sql_type|
+        if Derby.emulate_booleans?
+          ActiveRecord::Type::Boolean.new
+        else
+          ActiveRecord::Type::Integer.new(:limit => 1)
+        end
+      end
+      m.alias_type %r(real)i, 'float'
+    end if AR42
+
+    def reset_column_information
+      initialize_type_map(type_map)
+    end if AR42
+
     # @override
     def native_database_types
       NATIVE_DATABASE_TYPES
@@ -171,6 +188,7 @@ module ArJdbc
 
     # @override
     def quote(value, column = nil)
+      return super if column && ArJdbc::AR42 && column.cast_type.is_a?(ActiveRecord::Type::Serialized)
       return value.quoted_id if value.respond_to?(:quoted_id)
       return value if sql_literal?(value)
       return 'NULL' if value.nil?
@@ -415,6 +433,9 @@ module ArJdbc
       @connection.tables(nil, current_schema)
     end
 
+    # @override
+    def supports_foreign_keys?; true end
+
     def truncate(table_name, name = nil)
       execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
     end

data/lib/arjdbc/firebird.rb

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

data/lib/arjdbc/firebird/adapter.rb

@@ -1,3 +1,5 @@
+ArJdbc.load_java_part :Firebird
+
 module ArJdbc
   module Firebird
 
@@ -15,6 +17,11 @@ module ArJdbc
       Util::SerializedAttributes.setup /blob/i
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::FirebirdJdbcConnection
+    end
+
     # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
     def self.column_selector
       [ /firebird/i, lambda { |cfg, column| column.extend(Column) } ]
@@ -52,6 +59,9 @@ module ArJdbc
 
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
+    def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::FirebirdColumn end
+
     # @see ArJdbc::ArelHelper::ClassMethods#arel_visitor_type
     def self.arel_visitor_type(config = nil)
       require 'arel/visitors/firebird'; ::Arel::Visitors::Firebird
@@ -120,6 +130,68 @@ module ArJdbc
       NATIVE_DATABASE_TYPES
     end
 
+    def initialize_type_map(m)
+      register_class_with_limit m, %r(binary)i, ActiveRecord::Type::Binary
+      register_class_with_limit m, %r(text)i,   ActiveRecord::Type::Text
+
+      register_class_with_limit m, %r(date(?:\(.*?\))?$)i, DateType
+      register_class_with_limit m, %r(time(?:\(.*?\))?$)i, ActiveRecord::Type::Time
+
+      register_class_with_limit m, %r(float)i, ActiveRecord::Type::Float
+      register_class_with_limit m, %r(int)i,   ActiveRecord::Type::Integer
+
+      m.alias_type %r(blob)i,   'binary'
+      m.alias_type %r(clob)i,   'text'
+      m.alias_type %r(double)i, 'float'
+
+      m.register_type(%r(decimal)i) do |sql_type|
+        scale = extract_scale(sql_type)
+        precision = extract_precision(sql_type)
+        if scale == 0
+          ActiveRecord::Type::Integer.new(precision: precision)
+        else
+          ActiveRecord::Type::Decimal.new(precision: precision, scale: scale)
+        end
+      end
+      m.alias_type %r(numeric)i, 'decimal'
+
+      register_class_with_limit m, %r(varchar)i, ActiveRecord::Type::String
+
+      m.register_type(%r(^char)i) do |sql_type|
+        precision = extract_precision(sql_type)
+        if Firebird.emulate_booleans? && precision == 1
+          ActiveRecord::Type::Boolean.new
+        else
+          ActiveRecord::Type::String.new(:precision => precision)
+        end
+      end
+
+      register_class_with_limit m, %r(datetime)i, ActiveRecord::Type::DateTime
+      register_class_with_limit m, %r(timestamp)i, TimestampType
+    end if AR42
+
+    def clear_cache!
+      super
+      reload_type_map
+    end if AR42
+
+    # @private
+    class DateType < ActiveRecord::Type::Date
+      # NOTE: quote still gets called ...
+      #def type_cast_for_database(value)
+      #  if value.acts_like?(:date)
+      #    "'#{value.strftime("%Y-%m-%d")}'"
+      #  else
+      #    super
+      #  end
+      #end
+    end if AR42
+
+    # @private
+    class TimestampType < ActiveRecord::Type::DateTime
+      def type; :timestamp end
+    end if AR42
+
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       case type
       when :integer
@@ -176,21 +248,31 @@ module ArJdbc
     end
 
     def add_limit_offset!(sql, options)
-      if options[:limit]
-        limit_string = "FIRST #{options[:limit]}"
-        limit_string << " SKIP #{options[:offset]}" if options[:offset]
-        sql.sub!(/\A(\s*SELECT\s)/i, '\&' + limit_string + ' ')
+      if limit = options[:limit]
+        insert_limit_offset!(sql, limit, options[:offset])
       end
     end
 
+    # @private
+    SELECT_RE = /\A(\s*SELECT\s)/i
+
+    def insert_limit_offset!(sql, limit, offset)
+      lim_off = ''
+      lim_off << "FIRST #{limit}"  if limit
+      lim_off << " SKIP #{offset}" if offset
+      lim_off.strip!
+
+      sql.sub!(SELECT_RE, "\\&#{lim_off} ") unless lim_off.empty?
+    end
+
     # Should primary key values be selected from their corresponding
     # sequence before the insert statement?
     # @see #next_sequence_value
     # @override
     def prefetch_primary_key?(table_name = nil)
       return true if table_name.nil?
-      table_name = table_name.to_s
-      columns(table_name).count { |column| column.primary } == 1
+      primary_keys(table_name.to_s).size == 1
+      # columns(table_name).count { |column| column.primary } == 1
     end
 
     IDENTIFIER_LENGTH = 31 # usual DB meta-identifier: 31 chars maximum
@@ -201,8 +283,8 @@ module ArJdbc
     def column_name_length; IDENTIFIER_LENGTH; end
 
     def default_sequence_name(table_name, column = nil)
-      # TODO: remove schema prefix if present (before truncating)
-      "#{table_name.to_s[0, IDENTIFIER_LENGTH - 4]}_seq"
+      len = IDENTIFIER_LENGTH - 4
+      table_name.to_s.gsub (/(^|\.)([\w$-]{1,#{len}})([\w$-]*)$/), '\1\2_seq'
     end
 
     # Set the sequence to the max value of the table's column.
@@ -217,17 +299,18 @@ module ArJdbc
 
     def create_table(name, options = {})
       super(name, options)
-      execute "CREATE GENERATOR #{name}_seq"
+      execute "CREATE GENERATOR #{default_sequence_name(name)}"
     end
 
     def rename_table(name, new_name)
       execute "RENAME #{name} TO #{new_name}"
-      execute "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name}_seq' WHERE RDB$GENERATOR_NAME='#{name}_seq'" rescue nil
+      name_seq, new_name_seq = default_sequence_name(name), default_sequence_name(new_name)
+      execute_quietly "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name_seq}' WHERE RDB$GENERATOR_NAME='#{name_seq}'"
     end
 
     def drop_table(name, options = {})
       super(name)
-      execute "DROP GENERATOR #{name}_seq" rescue nil
+      execute_quietly "DROP GENERATOR #{default_sequence_name(name)}"
     end
 
     def change_column(table_name, column_name, type, options = {})
@@ -326,3 +409,35 @@ module ArJdbc
   end
   FireBird = Firebird
 end
+
+require 'arjdbc/util/quoted_cache'
+
+module ActiveRecord::ConnectionAdapters
+
+  remove_const(:FirebirdAdapter) if const_defined?(:FirebirdAdapter)
+
+  class FirebirdAdapter < JdbcAdapter
+    include ::ArJdbc::Firebird
+    include ::ArJdbc::Util::QuotedCache
+
+    # By default, the FirebirdAdapter will consider all columns of type
+    # <tt>char(1)</tt> as boolean. If you wish to disable this :
+    #
+    #   ActiveRecord::ConnectionAdapters::FirebirdAdapter.emulate_booleans = false
+    #
+    def self.emulate_booleans?; ::ArJdbc::Firebird.emulate_booleans?; end
+    def self.emulate_booleans;  ::ArJdbc::Firebird.emulate_booleans?; end # oracle-enhanced
+    def self.emulate_booleans=(emulate); ::ArJdbc::Firebird.emulate_booleans = emulate; end
+
+    def initialize(*args)
+      ::ArJdbc::Firebird.initialize!
+      super
+    end
+
+  end
+
+  class FirebirdColumn < JdbcColumn
+    include ::ArJdbc::Firebird::Column
+  end
+
+end