activerecord-jdbc-adapter 1.3.15 → 1.3.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4739f3c7b3060fa31587fc71df2cc0694e01b112
-  data.tar.gz: a2eb0b13a9c4e91ec04114dfa3b6ccf4837c1caf
+  metadata.gz: 7cf55d725c96e138c32eea755df27374aa764038
+  data.tar.gz: 9f5e8cf34fc6099b8958ef3de9bacffaf746dc6b
 SHA512:
-  metadata.gz: 5c7a8e8d16adaa14b6ff45722f50ac83284b9cfb7e1fd01656369ed863b09a0174f5e3d5da082f39ce531417bcdbdc84259bc6683e2ee024d07bc0f03f4d1efa
-  data.tar.gz: 31745bff9b3d93c76adcfe18a6073e48115aa2f0de2b923ec5c396f3ce855357d36c29b174ef003d421cc92cccc903469bd0d53dea5aa4c664b7ea7a60f8e6f3
+  metadata.gz: d75af524f18547b955e6a5b00964536223b382d052b69a7fbce062ba142a5bcb85ccf7ba3918838653756c0e582cbf62852568f3239399b7e00efe749ec7a8b7
+  data.tar.gz: 4f2e9693c5d1eb81f69741e0b1e8d06911d05273564a67910a77da073141609d5c81d1b751c715c2de7adb79956622b36e216493bcb40649bb2157bebcee3d8a

data/History.md

@@ -1,3 +1,17 @@
+## 1.3.16 (04/13/15)
+
+- [h2] allow jdbch2 adapter to use jdbc-h2 1.4 (#639)
+- [postgres] quote and type_cast should not be overriden on 4.2
+- [postgres] fix table column resolution (slightly align it to our needs) on 4.2
+- [postgres] re-arrange Column internals as some helpers end-up on Adapter in 4.2
+- [mysql] change_column table is redefined on AR 4.2 so that it uses _sql version
+- [mysql] more tuning/compatibility backports for AR 4.2 (working booleans #626)
+- [mysql] type-map support copy-pasta from AR 4.2 (closer to full compat) (#617)
+- [postgres] improved support for Amazon Redshift (based on user feedback #403)
+- fixed problem with create table statements with references in MySQL (#629)
+- fix RecordNotUnique reference in ArJdbc::SQlite3 (#634)
+- [postgres] add support for jsonb column type (#633 #635 #637)
+
 ## 1.3.15 (03/09/15)
 
 - [informix] adapter undefined method 'column_types' with Rails 4.x (#622)

data/lib/arjdbc/mysql/adapter.rb

@@ -7,7 +7,9 @@ module ArJdbc
   module MySQL
 
     # @private
-    AR42 = ActiveRecord::VERSION::STRING >= '4.2'
+    AR40 = ::ActiveRecord::VERSION::MAJOR > 3
+    # @private
+    AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
 
     require 'arjdbc/mysql/column'
     require 'arjdbc/mysql/bulk_change_table'
@@ -16,6 +18,9 @@ module ArJdbc
 
     include BulkChangeTable if const_defined? :BulkChangeTable
 
+    # @private
+    ActiveRecordError = ::ActiveRecord::ActiveRecordError
+
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
@@ -77,10 +82,10 @@ module ArJdbc
       execute("SET #{encoding} #{variable_assignments}", :skip_logging)
     end
 
-    def strict_mode? # strict_mode is default since AR 4.0
+    def strict_mode?
       config.key?(:strict) ?
         self.class.type_cast_config_to_boolean(config[:strict]) :
-          ::ActiveRecord::VERSION::MAJOR > 3
+          AR40 # strict_mode is default since AR 4.0
     end
 
     # @private
@@ -166,7 +171,7 @@ module ArJdbc
       else
         ActiveRecord::SchemaMigration.create_table
       end
-    end if ::ActiveRecord::VERSION::MAJOR > 3
+    end if AR40
 
     # HELPER METHODS ===========================================
 
@@ -200,7 +205,16 @@ module ArJdbc
       else
         super
       end
-    end
+    end unless AR42
+
+    # @private since AR 4.2
+    def _quote(value)
+      if value.is_a?(Type::Binary::Data)
+        "x'#{value.hex}'"
+      else
+        super
+      end
+    end if AR42
 
     # @override
     def quote_column_name(name)
@@ -229,6 +243,11 @@ module ArJdbc
       true
     end
 
+    # @override
+    def supports_indexes_in_create?
+      true
+    end
+
     # @override
     def supports_transaction_isolation?
       # MySQL 4 technically support transaction isolation, but it is affected by
@@ -247,6 +266,10 @@ module ArJdbc
       (version[0] == 5 && version[1] >= 7) || version[0] >= 6
     end
 
+    def index_algorithms
+      { :default => 'ALGORITHM = DEFAULT', :copy => 'ALGORITHM = COPY', :inplace => 'ALGORITHM = INPLACE' }
+    end if AR42
+
     # @override
     def supports_transaction_isolation?(level = nil)
       version[0] && version[0] >= 5 # MySQL 5+
@@ -335,12 +358,8 @@ module ArJdbc
     # @private
     IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
 
-    if ::ActiveRecord::VERSION::MAJOR > 3
-
-    INDEX_TYPES = [ :fulltext, :spatial ]
-    INDEX_USINGS = [ :btree, :hash ]
-
-    end
+    INDEX_TYPES = [ :fulltext, :spatial ] if AR40
+    INDEX_USINGS = [ :btree, :hash ] if AR40
 
     # Returns an array of indexes for the given table.
     # @override
@@ -373,7 +392,7 @@ module ArJdbc
     # Returns an array of `Column` objects for the table specified.
     # @override
     def columns(table_name, name = nil)
-      sql = "SHOW FULL COLUMNS FROM #{quote_table_name(table_name)}"
+      sql = "SHOW FULL #{AR40 ? 'FIELDS' : 'COLUMNS'} FROM #{quote_table_name(table_name)}"
       columns = execute(sql, name || 'SCHEMA')
       strict = strict_mode?
       pass_cast_type = respond_to?(:lookup_cast_type)
@@ -561,6 +580,11 @@ module ArJdbc
       execute(change_column_sql)
     end
 
+    # @private
+    def change_column(table_name, column_name, type, options = {})
+      execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
+    end if AR42
+
     # @override
     def rename_column(table_name, column_name, new_column_name)
       options = {}
@@ -570,7 +594,7 @@ module ArJdbc
         options[:default] = column.default if type != :text && type != :binary
         options[:null] = column.null
       else
-        raise ActiveRecord::ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+        raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
       end
 
       current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
@@ -646,7 +670,7 @@ module ArJdbc
         when 0..0xfff; "varbinary(#{limit})"
         when nil; "blob"
         when 0x1000..0xffffffff; "blob(#{limit})"
-        else raise ActiveRecord::ActiveRecordError, "No binary type has character length #{limit}"
+        else raise ActiveRecordError, "No binary type has character length #{limit}"
         end
       when 'integer'
         case limit
@@ -655,7 +679,7 @@ module ArJdbc
         when 3; 'mediumint'
         when nil, 4, 11; 'int(11)' # compatibility with MySQL default
         when 5..8; 'bigint'
-        else raise ActiveRecord::ActiveRecordError, "No integer type has byte size #{limit}"
+        else raise ActiveRecordError, "No integer type has byte size #{limit}"
         end
       when 'text'
         case limit
@@ -663,7 +687,7 @@ module ArJdbc
         when nil, 0x100..0xffff; 'text'
         when 0x10000..0xffffff; 'mediumtext'
         when 0x1000000..0xffffffff; 'longtext'
-        else raise ActiveRecord::ActiveRecordError, "No text type has character length #{limit}"
+        else raise ActiveRecordError, "No text type has character length #{limit}"
         end
       else
         super
@@ -675,8 +699,91 @@ module ArJdbc
       "VALUES ()"
     end
 
+    # @note since AR 4.2
+    def valid_type?(type)
+      ! native_database_types[type].nil?
+    end
+
+    def clear_cache!
+      super
+      reload_type_map
+    end if AR42
+
+    # @private since AR 4.2
+    def prepare_column_options(column, types)
+      spec = super
+      spec.delete(:limit) if column.type == :boolean
+      spec
+    end if AR42
+
+    # @private
+    Type = ActiveRecord::Type if AR42
+
     protected
 
+    # @private
+    def initialize_type_map(m)
+      super
+
+      register_class_with_limit m, %r(char)i, MysqlString
+
+      m.register_type %r(tinytext)i,   Type::Text.new(limit: 2**8 - 1)
+      m.register_type %r(tinyblob)i,   Type::Binary.new(limit: 2**8 - 1)
+      m.register_type %r(text)i,       Type::Text.new(limit: 2**16 - 1)
+      m.register_type %r(blob)i,       Type::Binary.new(limit: 2**16 - 1)
+      m.register_type %r(mediumtext)i, Type::Text.new(limit: 2**24 - 1)
+      m.register_type %r(mediumblob)i, Type::Binary.new(limit: 2**24 - 1)
+      m.register_type %r(longtext)i,   Type::Text.new(limit: 2**32 - 1)
+      m.register_type %r(longblob)i,   Type::Binary.new(limit: 2**32 - 1)
+      m.register_type %r(^float)i,     Type::Float.new(limit: 24)
+      m.register_type %r(^double)i,    Type::Float.new(limit: 53)
+
+      register_integer_type m, %r(^bigint)i,    limit: 8
+      register_integer_type m, %r(^int)i,       limit: 4
+      register_integer_type m, %r(^mediumint)i, limit: 3
+      register_integer_type m, %r(^smallint)i,  limit: 2
+      register_integer_type m, %r(^tinyint)i,   limit: 1
+
+      m.alias_type %r(tinyint\(1\))i,  'boolean' if emulate_booleans
+      m.alias_type %r(set)i,           'varchar'
+      m.alias_type %r(year)i,          'integer'
+      m.alias_type %r(bit)i,           'binary'
+
+      m.register_type(%r(datetime)i) do |sql_type|
+        precision = extract_precision(sql_type)
+        MysqlDateTime.new(precision: precision)
+      end
+
+      m.register_type(%r(enum)i) do |sql_type|
+        limit = sql_type[/^enum\((.+)\)/i, 1]
+          .split(',').map{|enum| enum.strip.length - 2}.max
+        MysqlString.new(limit: limit)
+      end
+    end if AR42
+
+    # @private
+    def register_integer_type(mapping, key, options)
+      mapping.register_type(key) do |sql_type|
+        if /unsigned/i =~ sql_type
+          Type::UnsignedInteger.new(options)
+        else
+          Type::Integer.new(options)
+        end
+      end
+    end if AR42
+
+    # MySQL is too stupid to create a temporary table for use subquery, so we have
+    # to give it some prompting in the form of a subsubquery. Ugh!
+    # @note since AR 4.2
+    def subquery_for(key, select)
+      subsubselect = select.clone
+      subsubselect.projections = [key]
+
+      subselect = Arel::SelectManager.new(select.engine)
+      subselect.project Arel.sql(key.name)
+      subselect.from subsubselect.as('__active_record_temp')
+    end if AR42
+
     def quoted_columns_for_index(column_names, options = {})
       length = options[:length] if options.is_a?(Hash)
 
@@ -741,6 +848,40 @@ module ArJdbc
       end
     end
 
+    # @private
+    def emulate_booleans; ::ArJdbc::MySQL.emulate_booleans?; end # due AR 4.2
+    public :emulate_booleans
+
+    # @private
+    class MysqlDateTime < Type::DateTime
+      private
+
+      def has_precision?
+        precision || 0
+      end
+    end if AR42
+
+    # @private
+    class MysqlString < Type::String
+      def type_cast_for_database(value)
+        case value
+        when true then "1"
+        when false then "0"
+        else super
+        end
+      end
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then "1"
+        when false then "0"
+        else super
+        end
+      end
+    end if AR42
+
   end
 end
 
@@ -772,9 +913,9 @@ module ActiveRecord
 
       end
 
-      def initialize(*args)
-        super # configure_connection happens in super
-      end
+      #def initialize(*args)
+      #  super # configure_connection happens in super
+      #end
 
       def jdbc_connection_class(spec)
         ::ArJdbc::MySQL.jdbc_connection_class

data/lib/arjdbc/mysql/bulk_change_table.rb

@@ -3,10 +3,13 @@ module ArJdbc
     module BulkChangeTable
 
       # @private
-      AR41 = ActiveRecord::VERSION::STRING >= '4.1'
+      AR41 = ::ActiveRecord::VERSION::STRING >= '4.1'
 
       # @private
-      ChangeColumnDefinition = ActiveRecord::ConnectionAdapters::ChangeColumnDefinition if AR41
+      #ActiveRecordError = ActiveRecord::ActiveRecordError
+
+      # @private
+      ChangeColumnDefinition = ::ActiveRecord::ConnectionAdapters::ChangeColumnDefinition if AR41
 
       # @override
       def supports_bulk_alter?; true end
@@ -106,12 +109,12 @@ module ArJdbc
         schema_creation.accept ChangeColumnDefinition.new column, current_type, options
       end if AR41
 
-      def remove_column_sql(table_name, column_name, type = nil, options = {})
+      def remove_column_sql(table_name, column_name, type = nil, options = nil)
         "DROP #{quote_column_name(column_name)}"
       end
 
       def remove_columns_sql(table_name, *column_names)
-        column_names.map {|column_name| remove_column_sql(table_name, column_name) }
+        column_names.map { |column_name| remove_column_sql(table_name, column_name) }
       end
 
       def add_index_sql(table_name, column_name, options = {})

data/lib/arjdbc/postgresql/adapter.rb

@@ -16,6 +16,12 @@ module ArJdbc
     require 'arjdbc/postgresql/explain_support'
     require 'arjdbc/postgresql/schema_creation' # AR 4.x
 
+    # @private
+    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
+
+    # @private
+    Type = ::ActiveRecord::Type if AR42_COMPAT
+
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
@@ -54,8 +60,8 @@ module ArJdbc
     def postgresql_version
       @postgresql_version ||=
         begin
-          value = select_value('SELECT version()')
-          if value =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
+          version = select_version
+          if version =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
             ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
           else
             0
@@ -63,6 +69,21 @@ module ArJdbc
         end
     end
 
+    def select_version
+      @_version ||= select_value('SELECT version()')
+    end
+    private :select_version
+
+    def redshift?
+      # SELECT version() :
+      #  PostgreSQL 8.0.2 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3), Redshift 1.0.647
+      if ( redshift = config[:redshift] ).nil?
+        redshift = !! (select_version || '').index('Redshift')
+      end
+      redshift
+    end
+    private :redshift?
+
     def use_insert_returning?
       if @use_insert_returning.nil?
         @use_insert_returning = supports_insert_with_returning?
@@ -97,16 +118,16 @@ module ArJdbc
         execute("SET time zone 'UTC'", 'SCHEMA')
       elsif tz = local_tz
         execute("SET time zone '#{tz}'", 'SCHEMA')
-      end # if defined? ActiveRecord::Base.default_timezone
+      end unless redshift?
 
       # SET statements from :variables config hash
       # http://www.postgresql.org/docs/8.3/static/sql-set.html
       (config[:variables] || {}).map do |k, v|
         if v == ':default' || v == :default
           # Sets the value to the global or compile default
-          execute("SET SESSION #{k.to_s} TO DEFAULT", 'SCHEMA')
+          execute("SET SESSION #{k} TO DEFAULT", 'SCHEMA')
         elsif ! v.nil?
-          execute("SET SESSION #{k.to_s} TO #{quote(v)}", 'SCHEMA')
+          execute("SET SESSION #{k} TO #{quote(v)}", 'SCHEMA')
         end
       end
     end
@@ -163,7 +184,7 @@ module ArJdbc
         case column.sql_type
         when 'point'
           jdbc_column_class.point_to_string(value)
-        when 'json'
+        when 'json', 'jsonb'
           jdbc_column_class.json_to_string(value)
         else
           return super(value, column) unless column.array?
@@ -181,7 +202,7 @@ module ArJdbc
         case column.sql_type
         when 'hstore'
           jdbc_column_class.hstore_to_string(value)
-        when 'json'
+        when 'json', 'jsonb'
           jdbc_column_class.json_to_string(value)
         else super(value, column)
         end
@@ -194,7 +215,23 @@ module ArJdbc
       else
         super(value, column)
       end
-    end if AR4_COMPAT
+    end if AR4_COMPAT && ! AR42_COMPAT
+
+    # @private
+    def _type_cast(value)
+      case value
+      when Type::Binary::Data
+        # Return a bind param hash with format as binary.
+        # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
+        # for more information
+        { value: value.to_s, format: 1 }
+      when OID::Xml::Data, OID::Bit::Data
+        value.to_s
+      else
+        super
+      end
+    end if AR42_COMPAT
+    private :_type_cast if AR42_COMPAT
 
     NATIVE_DATABASE_TYPES = {
       :primary_key => "serial primary key",
@@ -227,6 +264,7 @@ module ArJdbc
       :macaddr => { :name => "macaddr" },
       :uuid => { :name => "uuid" },
       :json => { :name => "json" },
+      :jsonb => { :name => "jsonb" },
       :ltree => { :name => "ltree" },
       # ranges :
       :daterange => { :name => "daterange" },
@@ -249,6 +287,7 @@ module ArJdbc
     end
 
     # Adds `:array` option to the default set provided by the `AbstractAdapter`.
+    # @override
     def prepare_column_options(column, types)
       spec = super
       spec[:array] = 'true' if column.respond_to?(:array) && column.array
@@ -257,6 +296,7 @@ module ArJdbc
     end if AR4_COMPAT
 
     # Adds `:array` as a valid migration key.
+    # @override
     def migration_keys
       super + [:array]
     end if AR4_COMPAT
@@ -744,11 +784,15 @@ module ArJdbc
 
     # Returns the current client message level.
     def client_min_messages
+      return nil if redshift? # not supported on Redshift
       select_value('SHOW client_min_messages', 'SCHEMA')
     end
 
     # Set the client message level.
     def client_min_messages=(level)
+      # NOTE: for now simply ignore the writer (no warn on Redshift) so that
+      # the AR copy-pasted PpstgreSQL parts stay the same as much as possible
+      return nil if redshift? # not supported on Redshift
       execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
     end
 
@@ -834,6 +878,8 @@ module ArJdbc
           "'#{jdbc_column_class.array_to_string(value, column, self).gsub(/'/, "''")}'"
         elsif column.type == :json # only in AR-4.0
           super(jdbc_column_class.json_to_string(value), column)
+        elsif column.type == :jsonb # only in AR-4.0
+          super(jdbc_column_class.json_to_string(value), column)
         elsif column.type == :point # only in AR-4.0
           super(jdbc_column_class.point_to_string(value), column)
         else super
@@ -843,6 +889,8 @@ module ArJdbc
           super(jdbc_column_class.hstore_to_string(value), column)
         elsif column.type == :json # only in AR-4.0
           super(jdbc_column_class.json_to_string(value), column)
+        elsif column.type == :jsonb # only in AR-4.0
+          super(jdbc_column_class.json_to_string(value), column)
         else super
         end
       when Range
@@ -862,13 +910,22 @@ module ArJdbc
       end
     end unless AR42_COMPAT
 
-    def quote(value, column = nil)
-      return super unless column
-
+    # @private
+    def _quote(value)
       case value
+      when Type::Binary::Data
+        "'#{escape_bytea(value.to_s)}'"
+      when OID::Xml::Data
+        "xml '#{quote_string(value.to_s)}'"
+      when OID::Bit::Data
+        if value.binary?
+          "B'#{value}'"
+        elsif value.hex?
+          "X'#{value}'"
+        end
       when Float
         if value.infinite? || value.nan?
-          "'#{value.to_s}'"
+          "'#{value}'"
         else
           super
         end
@@ -876,6 +933,7 @@ module ArJdbc
         super
       end
     end if AR42_COMPAT
+    private :_quote if AR42_COMPAT
 
     # Quotes a string, escaping any ' (single quote) and \ (backslash) chars.
     # @return [String]
@@ -932,7 +990,7 @@ module ArJdbc
     # @override
     def quote_table_name_for_assignment(table, attr)
       quote_column_name(attr)
-    end if ::ActiveRecord::VERSION::MAJOR >= 4
+    end if AR4_COMPAT
 
     # @override
     def quote_column_name(name)
@@ -1088,9 +1146,8 @@ module ArJdbc
     # Returns the list of all column definitions for a table.
     def columns(table_name, name = nil)
       column = jdbc_column_class
-      pass_cast_type = respond_to?(:lookup_cast_type)
-      column_definitions(table_name).map do |row|
-        # name, type, default, notnull, oid, fmod
+      column_definitions(table_name).map! do |row|
+        # |name, type, default, notnull, oid, fmod|
         name = row[0]; type = row[1]; default = row[2]
         notnull = row[3]; oid = row[4]; fmod = row[5]
         # oid = OID::TYPE_MAP.fetch(oid.to_i, fmod.to_i) { OID::Identity.new }
@@ -1102,18 +1159,41 @@ module ArJdbc
         elsif default =~ /^\(([-+]?[\d\.]+)\)$/ # e.g. "(-1)" for a negative default
           default = $1
         end
-        if pass_cast_type
-          cast_type = lookup_cast_type(type)
-          column.new(name, default, cast_type, type, ! notnull, fmod, self)
-        else
-          column.new(name, default, oid, type, ! notnull, fmod, self)
-        end
+
+        column.new(name, default, oid, type, ! notnull, fmod, self)
       end
     end
 
+    # @private documented above
+    def columns(table_name)
+      column = jdbc_column_class
+      # Limit, precision, and scale are all handled by the superclass.
+      column_definitions(table_name).map! do |row|
+        # |name, type, default, notnull, oid, fmod|
+        name = row[0]; type = row[1]; default = row[2]
+        notnull = row[3]; oid = row[4]; fmod = row[5]
+        notnull = notnull == 't' if notnull.is_a?(String) # JDBC gets true/false
+
+        oid_type = get_oid_type(oid.to_i, fmod.to_i, name, type)
+        default_value = extract_value_from_default(oid, default)
+        default_function = extract_default_function(default_value, default)
+
+        column.new(name, default_value, oid_type, type, ! notnull, default_function, oid, self)
+      end
+    end if AR42_COMPAT
+
+    # @private only for API compatibility
+    def new_column(name, default, cast_type, sql_type = nil, null = true, default_function = nil)
+      jdbc_column_class.new(name, default, cast_type, sql_type, null, default_function)
+    end if AR42_COMPAT
+
     # @private
     def column_for(table_name, column_name)
-      columns(table_name).detect { |c| c.name == column_name.to_s }
+      column_name = column_name.to_s
+      for column in columns(table_name)
+        return column if column.name == column_name
+      end
+      nil
     end
 
     # Returns the list of a table's column names, data types, and default values.
@@ -1188,9 +1268,6 @@ module ArJdbc
       SQL
     end if AR42_COMPAT
 
-    # @private
-    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
-
     # Returns an array of indexes for the given table.
     def indexes(table_name, name = nil)
       # NOTE: maybe it's better to leave things of to the JDBC API ?!
@@ -1304,33 +1381,6 @@ module ActiveRecord::ConnectionAdapters
 
   class PostgreSQLColumn < JdbcColumn
     include ::ArJdbc::PostgreSQL::Column
-
-    def initialize(name, default, oid_type = nil, sql_type = nil, null = true,
-        fmod = nil, adapter = nil) # added due resolving #oid_type
-      if oid_type.is_a?(Integer) # the "main" if branch (on AR 4.x)
-        @oid = oid_type; @fmod = fmod; @adapter = adapter # see Column#oid_type
-      elsif oid_type.respond_to?(:type_cast) # MRI compatibility
-        @oid_type = oid_type; # @fmod = fmod; @adapter = adapter
-      else # NOTE: AR <= 3.2 : (name, default, sql_type = nil, null = true)
-        null, sql_type, oid_type = !! sql_type, oid_type, nil
-      end
-      if sql_type.to_s[-2, 2] == '[]' && ArJdbc::PostgreSQL::AR4_COMPAT
-        @array = true if respond_to?(:array)
-        super(name, default, sql_type[0..-3], null)
-      else
-        @array = false if respond_to?(:array)
-        super(name, default, sql_type, null)
-      end
-
-      @default_function = default if has_default_function?(@default, default)
-    end
-
-    private
-
-    def has_default_function?(default_value, default)
-      ! default_value && ( %r{\w+\(.*\)} === default )
-    end
-
   end
 
   # NOTE: seems needed on 4.x due loading of '.../postgresql/oid' which
@@ -1341,8 +1391,9 @@ module ActiveRecord::ConnectionAdapters
     include ::ArJdbc::PostgreSQL
     include ::ArJdbc::PostgreSQL::ExplainSupport
 
-    require 'arjdbc/postgresql/oid_types' if ::ArJdbc::PostgreSQL::AR4_COMPAT
+    require 'arjdbc/postgresql/oid_types' if AR4_COMPAT
     include ::ArJdbc::PostgreSQL::OIDTypes if ::ArJdbc::PostgreSQL.const_defined?(:OIDTypes)
+    include ::ArJdbc::PostgreSQL::ColumnHelpers if AR42_COMPAT
 
     include ::ArJdbc::Util::QuotedCache
 
@@ -1354,6 +1405,8 @@ module ActiveRecord::ConnectionAdapters
 
       @table_alias_length = nil
 
+      initialize_type_map(@type_map = Type::HashLookupTypeMap.new) if AR42_COMPAT
+
       @use_insert_returning = @config.key?(:insert_returning) ?
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : nil
     end

data/lib/arjdbc/postgresql/base/oid.rb

@@ -275,6 +275,25 @@ module ActiveRecord
           end
         end
 
+        class Jsonb < Type
+          def type_cast_for_write(value)
+            # roundtrip to ensure uniform uniform types
+            # TODO: This is not an efficient solution.
+            stringified = ConnectionAdapters::PostgreSQLColumn.json_to_string(value)
+            type_cast(stringified)
+          end
+
+          def type_cast(value)
+            return if value.nil?
+
+            ConnectionAdapters::PostgreSQLColumn.string_to_json value
+          end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          end
+        end
+
         class TypeMap
           def initialize
             @mapping = {}
@@ -382,6 +401,7 @@ module ActiveRecord
         register_type 'circle', OID::Identity.new
         register_type 'hstore', OID::Hstore.new
         register_type 'json', OID::Json.new
+        register_type 'jsonb', OID::Jsonb.new
         register_type 'ltree', OID::Identity.new
 
         register_type 'cidr', OID::Cidr.new
@@ -389,4 +409,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/arjdbc/postgresql/column.rb

@@ -6,46 +6,134 @@ module ArJdbc
       [ /postgre/i, lambda { |cfg, column| column.extend(Column) } ]
     end
 
+    # @private these are defined on the Adapter class since 4.2
+    module ColumnHelpers
+
+      def extract_limit(sql_type) # :nodoc:
+        case sql_type
+        when /^bigint/i, /^int8/i then 8
+        when /^smallint/i then 2
+        when /^timestamp/i then nil
+        else
+          super
+        end
+      end
+
+      # Extracts the value from a PostgreSQL column default definition.
+      def extract_value_from_default(oid, default) # :nodoc:
+        case default
+          # Quoted types
+          when /\A[\(B]?'(.*)'::/m
+            $1.gsub(/''/, "'")
+          # Boolean types
+          when 'true', 'false'
+            default
+          # Numeric types
+          when /\A\(?(-?\d+(\.\d*)?)\)?(::bigint)?\z/
+            $1
+          # Object identifier types
+          when /\A-?\d+\z/
+            $1
+          else
+            # Anything else is blank, some user type, or some function
+            # and we can't know the value of that, so return nil.
+            nil
+        end
+      end
+
+      def extract_default_function(default_value, default) # :nodoc:
+        default if ! default_value && ( %r{\w+\(.*\)} === default )
+      end
+
+    end
+
     # Column behavior based on PostgreSQL adapter in Rails.
     # @see ActiveRecord::ConnectionAdapters::JdbcColumn
     module Column
 
+      attr_accessor :array
+
+      def initialize(name, default, cast_type, sql_type = nil, null = true, default_function = nil,
+        oid = nil, adapter = nil) # added arguments
+        if sql_type.to_s[-2, 2] == '[]'
+          @array = true
+          super(name, default, cast_type, sql_type[0..-3], null)
+        else
+          @array = false
+          super(name, default, cast_type, sql_type, null)
+        end
+
+        @oid = oid # used on Java side - expects @oid on Column instances
+        #@adapter = adapter
+
+        @default_function = default_function
+      end
+
+    end if AR42_COMPAT
+
+    # @private (AR < 4.2 version) documented above
+    module Column
+
+      def initialize(name, default, oid_type = nil, sql_type = nil, null = true,
+          fmod = nil, adapter = nil) # added due resolving #oid_type
+        if oid_type.is_a?(Integer) # the "main" if branch (on AR 4.x)
+          @oid = oid_type; @fmod = fmod; @adapter = adapter # see Column#oid_type
+        elsif oid_type.respond_to?(:type_cast) # MRI compatibility
+          @oid_type = oid_type; # @fmod = fmod; @adapter = adapter
+        else # NOTE: AR <= 3.2 : (name, default, sql_type = nil, null = true)
+          null, sql_type, oid_type = !! sql_type, oid_type, nil
+        end
+        if sql_type.to_s[-2, 2] == '[]' && ArJdbc::PostgreSQL::AR4_COMPAT
+          @array = true if respond_to?(:array)
+          super(name, default, sql_type[0..-3], null)
+        else
+          @array = false if respond_to?(:array)
+          super(name, default, sql_type, null)
+        end
+
+        @default_function = extract_default_function(@default, default)
+      end
+
       def self.included(base)
         # NOTE: assumes a standalone PostgreSQLColumn class
-        class << base
-
-          attr_accessor :money_precision
-
-          # Loads pg_array_parser if available. String parsing can be
-          # performed quicker by a native extension, which will not create
-          # a large amount of Ruby objects that will need to be garbage
-          # collected. pg_array_parser has a C and Java extension
-          begin
-            require 'pg_array_parser'
-            include PgArrayParser
-          rescue LoadError
-            if AR42_COMPAT
-              require 'active_record/connection_adapters/postgresql/array_parser'
-            else
-              require 'arjdbc/postgresql/base/array_parser'
-            end
-            include ActiveRecord::ConnectionAdapters::PostgreSQL::ArrayParser
-          end if AR4_COMPAT
+        base_meta = class << base; self end
+        base_meta.send :attr_accessor, :money_precision
+
+        # Loads pg_array_parser if available. String parsing can be
+        # performed quicker by a native extension, which will not create
+        # a large amount of Ruby objects that will need to be garbage
+        # collected. pg_array_parser has a C and Java extension
+        begin
+          require 'pg_array_parser'
+          base_meta.send :include, PgArrayParser
+        rescue LoadError
+          if AR42_COMPAT
+            require 'active_record/connection_adapters/postgresql/array_parser'
+          else
+            require 'arjdbc/postgresql/base/array_parser'
+          end
+          base_meta.send :include, ActiveRecord::ConnectionAdapters::PostgreSQL::ArrayParser
+        end if AR4_COMPAT
 
-          include Cast
+        base_meta.send :include, Cast
 
-        end
+        base.send :include, ColumnHelpers
       end
 
+      if AR4_COMPAT && ! AR42_COMPAT
+
       # @private
       def oid_type
         @oid_type ||= begin
           raise "oid not defined" unless oid = (@oid ||= nil)
           @adapter.get_oid_type(oid.to_i, @fmod.to_i, name)
         end
-      end if AR4_COMPAT
+      end
+
+      # @private
+      def accessor; oid_type.accessor end
 
-      def accessor; oid_type.accessor end if AR4_COMPAT
+      end
 
       ( attr_accessor :array; def array?; array; end ) if AR4_COMPAT
 
@@ -110,6 +198,9 @@ module ArJdbc
           # JSON
           when /\A'(.*)'::json\z/
             $1
+          # JSONB
+          when /\A'(.*)'::jsonb\z/
+            $1
           # Object identifier types
           when /\A-?\d+\z/
             $1
@@ -146,6 +237,7 @@ module ArJdbc
         case type ||= self.type
         when :hstore then self.class.string_to_hstore value
         when :json then self.class.string_to_json value
+        when :jsonb then self.class.string_to_json value
         when :cidr, :inet then self.class.string_to_cidr value
         when :macaddr then value
         when :tsvector then value
@@ -198,15 +290,6 @@ module ArJdbc
 
       private
 
-      def extract_limit(sql_type)
-        case sql_type
-        when /^bigint/i; 8
-        when /^smallint/i; 2
-        when /^timestamp/i; nil
-        else super
-        end
-      end
-
       # Extracts the scale from PostgreSQL-specific data types.
       def extract_scale(sql_type)
         # Money type has a fixed scale of 2.
@@ -302,6 +385,7 @@ module ArJdbc
         when 'uuid' then :uuid
         # JSON type
         when 'json' then :json
+        when 'jsonb' then :jsonb
         # Small and big integer types
         when /^(?:small|big)int$/ then :integer
         when /(num|date|tstz|ts|int4|int8)range$/
@@ -550,6 +634,6 @@ module ArJdbc
 
       end
 
-    end
+    end unless AR42_COMPAT
   end
 end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -10,11 +10,10 @@ module ArJdbc
     end
 
     # @private
-    module OIDTypes
-
-      OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
+    OID = ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-      Type = ActiveRecord::Type if AR42_COMPAT
+    # @private
+    module OIDTypes
 
       # @override
       def enable_extension(name)
@@ -44,7 +43,7 @@ module ArJdbc
         }
       end unless AR42_COMPAT
 
-      def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
+      def get_oid_type(oid, fmod, column_name, sql_type = '')
         if !type_map.key?(oid)
           load_additional_types(type_map, [oid])
         end
@@ -79,7 +78,8 @@ module ArJdbc
       end
 
       def type_map
-        # NOTE: our type_map is lazy since it's only used for `adapter.accessor`
+        # NOTE: our type_map is lazy (on AR < 4.2)
+        # ... since it's only used for `adapter.accessor`
         @type_map ||= begin
           if type_map = @@type_map_cache[ type_cache_key ]
             type_map.dup
@@ -150,10 +150,10 @@ module ArJdbc
         end
       end unless AR42_COMPAT
 
-      def initialize_type_map(m) # :nodoc:
+      def initialize_type_map(m)
         register_class_with_limit m, 'int2', OID::Integer
-        m.alias_type 'int4', 'int2'
-        m.alias_type 'int8', 'int2'
+        register_class_with_limit m, 'int4', OID::Integer
+        register_class_with_limit m, 'int8', OID::Integer
         m.alias_type 'oid', 'int2'
         m.register_type 'float4', OID::Float.new
         m.alias_type 'float8', 'float4'
@@ -221,7 +221,7 @@ module ArJdbc
         load_additional_types(m)
       end if AR42_COMPAT
 
-      def load_additional_types(type_map, oids = nil) # :nodoc:
+      def load_additional_types(type_map, oids = nil)
         if supports_ranges?
           query = <<-SQL
             SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
@@ -235,11 +235,16 @@ module ArJdbc
           SQL
         end
 
+        initializer = OID::TypeMapInitializer.new(type_map)
+
         if oids
-          query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
+          query << "WHERE t.oid::integer IN (%s)" % oids.join(", ")
+        else
+          if initializer.respond_to?(:query_conditions_for_initial_load)
+            query << initializer.query_conditions_for_initial_load(type_map)
+          end
         end
 
-        initializer = OID::TypeMapInitializer.new(type_map)
         records = execute(query, 'SCHEMA')
         initializer.run(records)
       end if AR42_COMPAT

data/lib/arjdbc/sqlite3/adapter.rb

@@ -534,7 +534,7 @@ module ArJdbc
         #   column *column_name* is not unique
         if msg.index('UNIQUE constraint failed: ') ||
            msg =~ /column(s)? .* (is|are) not unique/
-          return RecordNotUnique.new(message, exception)
+          return ::ActiveRecord::RecordNotUnique.new(message, exception)
         end
       end
       super

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 module ArJdbc
-  VERSION = "1.3.15"
+  VERSION = "1.3.16"
   # @deprecated
   module Version
     # @private 1.2.x compatibility

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: 1.3.15
+  version: 1.3.16
 platform: ruby
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2015-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord