activerecord-jdbc-adapter 1.3.16 → 1.3.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cf55d725c96e138c32eea755df27374aa764038
-  data.tar.gz: 9f5e8cf34fc6099b8958ef3de9bacffaf746dc6b
+  metadata.gz: 134cda5c81428ddd6306cfbf8de01390845e9332
+  data.tar.gz: 5b4c2e9e1f691ab3cd0c8df0ab77a06a933bb433
 SHA512:
-  metadata.gz: d75af524f18547b955e6a5b00964536223b382d052b69a7fbce062ba142a5bcb85ccf7ba3918838653756c0e582cbf62852568f3239399b7e00efe749ec7a8b7
-  data.tar.gz: 4f2e9693c5d1eb81f69741e0b1e8d06911d05273564a67910a77da073141609d5c81d1b751c715c2de7adb79956622b36e216493bcb40649bb2157bebcee3d8a
+  metadata.gz: bb750f2f8396290b6212c017350c1b9c2f38792122a2214e1c14a2e83e22f35e6d0dab9c808f384421a64d3c11c691d94e2909e5548ccafbc523c7c066cdd7f1
+  data.tar.gz: 3cc35229994ff2f461fe35ff5e381c461d41d91ab80e51a8e89b054494f21283a9b897488cab748a1efe076abc3f86316939644a1dcfa2a22029a49c409fa800

data/.gitignore

@@ -29,4 +29,5 @@ jndi_test/jdbc/.bindings
 .bundle/config
 gemfiles/.bundle/config
 Gemfile.lock
-/.idea
+.idea
+.settings

data/History.md

@@ -1,3 +1,23 @@
+## 1.3.17 (06/30/15)
+
+- [mysql] bulk compatibility with AR 4.2 - all _sql helper accept an options (hash)
+- [mysql] back-port case sensitive/insensitive comparison
+- [mysql] handle precision for datetimes when doing type_to_sql (AR 4.2 compat)
+- [mysql] foreign key support based on AR 4.2 (#656)
+- [postgres] foreign_key support back-ported from AR 4.2 (#656)
+- moved jndi callbacks to happen outside adapter's `initialize` (#649, #620)
+- [postgres] AR 4.2 compatibility with SchemaCreation
+- [postgres] re-define `lookup_cast_type` (AR 4.2) + `conn.type_map` is public
+- [postgres] override `valid_type?(type)` (AR 4.2 compatibility)
+- [postgres] back-port change_column updates from AR 4.2 for compatibility
+- [postgres] pass down array_member to hstore_to_string (fixes #647 on AR 4.1)
+- [postgres] on AR 4.2 use core's schema_definitions.rb for improved compat (#644)
+- back-port PGconn hack on AR 4.x (from #655 and following commits)
+  to fix #651 as an unfortunate work-around for (non-shareable) AR internals (#652)
+- seems that extension methods won't work in 9K the same as in 1.7.x thus work-around
+  (originally reported as https://github.com/jruby/jruby/issues/2533)
+- restore 1.8 compatibility in postgres' adapter (regression in 1.3.16 see #641)
+
 ## 1.3.16 (04/13/15)
 
 - [h2] allow jdbch2 adapter to use jdbc-h2 1.4 (#639)

data/Rakefile

@@ -12,7 +12,6 @@ require 'appraisal'
 
 task :default => [:jar, :test]
 
-#ugh, bundler doesn't use tasks, so gotta hook up to both tasks.
 task :build => :jar
 task :install => :jar
 
@@ -21,13 +20,27 @@ DRIVERS  = %w[derby h2 hsqldb jtds mysql postgres sqlite3].map { |a| "jdbc-#{a}"
 TARGETS = ( ADAPTERS + DRIVERS )
 
 rake = lambda { |task| ruby "-S", "rake", task }
+current_version = lambda { Bundler.load_gemspec('activerecord-jdbc-adapter.gemspec').version }
 
-TARGETS.each do |target|
+ADAPTERS.each do |target|
+  namespace target do
+    task :build do
+      version = current_version.call
+      Dir.chdir(target) { rake.call "build" }
+      cp FileList["#{target}/pkg/#{target}-#{version}.gem"], "pkg"
+    end
+  end
+end
+DRIVERS.each do |target|
   namespace target do
     task :build do
       Dir.chdir(target) { rake.call "build" }
       cp FileList["#{target}/pkg/#{target}-*.gem"], "pkg"
     end
+  end
+end
+TARGETS.each do |target|
+  namespace target do
     task :install do
       Dir.chdir(target) { rake.call "install" }
     end
@@ -66,15 +79,16 @@ task "release:adapters" => [ 'release' ] + ADAPTERS.map { |name| "#{name}:releas
 task "adapters:release" => 'release:adapters'
 
 task 'release:do' => 'build:adapters' do
-  gemspec = Bundler.load_gemspec('activerecord-jdbc-adapter.gemspec')
-  version = gemspec.version; version_tag = "v#{version}"
+  version = current_version.call; version_tag = "v#{version}"
 
   sh("git diff --no-patch --exit-code") { |ok| fail "git working dir is not clean" unless ok }
   sh("git diff-index --quiet --cached HEAD") { |ok| fail "git index is not clean" unless ok }
 
   sh "git tag -a -m \"AR-JDBC #{version}\" #{version_tag}"
+  branch = `git rev-parse --abbrev-ref HEAD`.strip
+  puts "releasing from (current) branch #{branch.inspect}"
   sh "for gem in `ls pkg/*-#{version}.gem`; do gem push $gem; done" do |ok|
-    sh "git push origin master --tags" if ok
+    sh "git push origin #{branch} --tags" if ok
   end
 end
 

data/lib/arjdbc/jdbc.rb

@@ -2,6 +2,11 @@ require 'active_support/deprecation'
 
 module ArJdbc
 
+  # @private
+  AR40 = ::ActiveRecord::VERSION::MAJOR > 3
+  # @private
+  AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
+
   class << self
 
     def warn(message, once = nil)

data/lib/arjdbc/jdbc/adapter.rb

@@ -40,6 +40,12 @@ module ActiveRecord
 
       attr_reader :config
 
+      def self.new(connection, logger = nil, pool = nil)
+        adapter = super
+        Jdbc::JndiConnectionPoolCallbacks.prepare(adapter, adapter.instance_variable_get(:@connection))
+        adapter
+      end
+
       # Initializes the (JDBC connection) adapter instance.
       # The passed configuration Hash's keys are symbolized, thus changes to
       # the original `config` keys won't be reflected in the adapter.
@@ -50,6 +56,8 @@ module ActiveRecord
       # @param config the database configuration
       # @note `initialize(logger, config)` with 2 arguments is supported as well
       def initialize(connection, logger, config = nil)
+        # AR : initialize(connection, logger = nil, pool = nil)
+        # AR < 3.2 : initialize(connection, logger = nil)
         if config.nil? && logger.respond_to?(:key?) # (logger, config)
           config, logger, connection = logger, connection, nil
         end
@@ -76,8 +84,6 @@ module ActiveRecord
         # NOTE: should not be necessary for JNDI due reconnect! on checkout :
         configure_connection if respond_to?(:configure_connection)
 
-        Jdbc::JndiConnectionPoolCallbacks.prepare(self, connection)
-
         @visitor = new_visitor # nil if no AREL (AR-2.3)
       end
 
@@ -216,6 +222,11 @@ module ActiveRecord
         end
       end
 
+      # @override introduced in AR 4.2
+      def valid_type?(type)
+        ! native_database_types[type].nil?
+      end
+
       # Allows for modification of the detected native types.
       # @param types the resolved native database types
       # @see #native_database_types

data/lib/arjdbc/mysql/adapter.rb

@@ -6,11 +6,6 @@ require 'active_record/connection_adapters/abstract/schema_definitions'
 module ArJdbc
   module MySQL
 
-    # @private
-    AR40 = ::ActiveRecord::VERSION::MAJOR > 3
-    # @private
-    AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
-
     require 'arjdbc/mysql/column'
     require 'arjdbc/mysql/bulk_change_table'
     require 'arjdbc/mysql/explain_support'
@@ -154,13 +149,29 @@ module ArJdbc
 
     def case_sensitive_modifier(node)
       Arel::Nodes::Bin.new(node)
-    end
+    end unless AR42
 
     def case_sensitive_modifier(node, table_attribute)
       node = Arel::Nodes.build_quoted node, table_attribute
       Arel::Nodes::Bin.new(node)
     end if AR42
 
+    def case_sensitive_comparison(table, attribute, column, value)
+      if column.case_sensitive?
+        table[attribute].eq(value)
+      else
+        super
+      end
+    end if AR42
+
+    def case_insensitive_comparison(table, attribute, column, value)
+      if column.case_sensitive?
+        super
+      else
+        table[attribute].eq(value)
+      end
+    end if AR42
+
     def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
       where_sql
     end
@@ -532,12 +543,52 @@ module ArJdbc
     # @override
     def rename_index(table_name, old_name, new_name)
       if supports_rename_index?
+        validate_index_length!(table_name, new_name) if respond_to?(:validate_index_length!)
         execute "ALTER TABLE #{quote_table_name(table_name)} RENAME INDEX #{quote_table_name(old_name)} TO #{quote_table_name(new_name)}"
       else
         super
       end
     end
 
+    # @private
+    ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition if ::ActiveRecord::ConnectionAdapters.const_defined? :ForeignKeyDefinition
+
+    def supports_foreign_keys?; true end
+
+    def foreign_keys(table_name)
+      fk_info = select_all "" <<
+        "SELECT fk.referenced_table_name as 'to_table' " <<
+              ",fk.referenced_column_name as 'primary_key' " <<
+              ",fk.column_name as 'column' " <<
+              ",fk.constraint_name as 'name' " <<
+        "FROM information_schema.key_column_usage fk " <<
+        "WHERE fk.referenced_column_name is not null " <<
+          "AND fk.table_schema = '#{current_database}' " <<
+          "AND fk.table_name = '#{table_name}'"
+
+      create_table_info = select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
+
+      fk_info.map! do |row|
+        options = {
+          :column => row['column'], :name => row['name'], :primary_key => row['primary_key']
+        }
+        options[:on_update] = extract_foreign_key_action(create_table_info, row['name'], "UPDATE")
+        options[:on_delete] = extract_foreign_key_action(create_table_info, row['name'], "DELETE")
+
+        ForeignKeyDefinition.new(table_name, row['to_table'], options)
+      end
+    end if defined? ForeignKeyDefinition
+
+    def extract_foreign_key_action(structure, name, action)
+      if structure =~ /CONSTRAINT #{quote_column_name(name)} FOREIGN KEY .* REFERENCES .* ON #{action} (CASCADE|SET NULL|RESTRICT)/
+        case $1
+        when 'CASCADE'; :cascade
+        when 'SET NULL'; :nullify
+        end
+      end
+    end
+    private :extract_foreign_key_action
+
     # @override
     def add_column(table_name, column_name, type, options = {})
       add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
@@ -663,31 +714,39 @@ module ArJdbc
       show_variable("collation_database")
     end
 
+    # Maps logical Rails types to MySQL-specific data types.
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       case type.to_s
       when 'binary'
         case limit
-        when 0..0xfff; "varbinary(#{limit})"
-        when nil; "blob"
+        when 0..0xfff;           "varbinary(#{limit})"
+        when nil;                "blob"
         when 0x1000..0xffffffff; "blob(#{limit})"
-        else raise ActiveRecordError, "No binary type has character length #{limit}"
+        else raise(ActiveRecordError, "No binary type has character length #{limit}")
         end
       when 'integer'
         case limit
         when 1; 'tinyint'
         when 2; 'smallint'
         when 3; 'mediumint'
-        when nil, 4, 11; 'int(11)' # compatibility with MySQL default
+        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
         when 5..8; 'bigint'
-        else raise ActiveRecordError, "No integer type has byte size #{limit}"
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
         end
       when 'text'
         case limit
-        when 0..0xff; 'tinytext'
-        when nil, 0x100..0xffff; 'text'
-        when 0x10000..0xffffff; 'mediumtext'
+        when 0..0xff;               'tinytext'
+        when nil, 0x100..0xffff;    'text'
+        when 0x10000..0xffffff;     'mediumtext'
         when 0x1000000..0xffffffff; 'longtext'
-        else raise ActiveRecordError, "No text type has character length #{limit}"
+        else raise(ActiveRecordError, "No text type has character length #{limit}")
+        end
+      when 'datetime'
+        return super unless precision
+
+        case precision
+          when 0..6; "datetime(#{precision})"
+          else raise(ActiveRecordError, "No datetime type has precision of #{precision}. The allowed range of precision is from 0 to 6.")
         end
       else
         super

data/lib/arjdbc/mysql/bulk_change_table.rb

@@ -131,7 +131,7 @@ module ArJdbc
         [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
       end
 
-      def remove_timestamps_sql(table_name)
+      def remove_timestamps_sql(table_name, options = nil)
         [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
       end
 

data/lib/arjdbc/mysql/schema_creation.rb

@@ -8,12 +8,30 @@ module ArJdbc
       end
 
       private
+
+      def visit_DropForeignKey(name)
+        "DROP FOREIGN KEY #{name}"
+      end
+
+      def visit_TableDefinition(o)
+        name = o.name
+        create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(name)} "
+
+        statements = o.columns.map { |c| accept c }
+        statements.concat(o.indexes.map { |column_name, options| index_in_create(name, column_name, options) })
+
+        create_sql << "(#{statements.join(', ')}) " if statements.present?
+        create_sql << "#{o.options}"
+        create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+        create_sql
+      end if AR42
+
       def visit_ChangeColumnDefinition(o)
         column = o.column
         options = o.options
         sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
         change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
-        add_column_options!(change_column_sql, options)
+        add_column_options!(change_column_sql, options.merge(:column => column))
         add_column_position!(change_column_sql, options)
       end
 
@@ -25,6 +43,11 @@ module ArJdbc
         end
         sql
       end
+
+      def index_in_create(table_name, column_name, options)
+        index_name, index_type, index_columns, index_options, index_algorithm, index_using = @conn.add_index_options(table_name, column_name, options)
+        "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_options} #{index_algorithm}"
+      end
     end
   end
 

data/lib/arjdbc/postgresql/adapter.rb

@@ -6,21 +6,24 @@ module ArJdbc
   # Strives to provide Rails built-in PostgreSQL adapter (API) compatibility.
   module PostgreSQL
 
+    # @deprecated no longer used
     # @private
-    AR4_COMPAT = ::ActiveRecord::VERSION::MAJOR > 3 unless const_defined?(:AR4_COMPAT)
+    AR4_COMPAT = AR40
+    # @deprecated no longer used
     # @private
-    AR42_COMPAT = ::ActiveRecord::VERSION::MAJOR > 4 ||
-      ( ::ActiveRecord::VERSION::MAJOR == 4 && ::ActiveRecord::VERSION::MINOR >= 2 )
+    AR42_COMPAT = AR42
 
     require 'arjdbc/postgresql/column'
     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
+    ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition if ::ActiveRecord::ConnectionAdapters.const_defined? :ForeignKeyDefinition
+
+    # @private
+    Type = ::ActiveRecord::Type if AR42
 
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
@@ -137,22 +140,22 @@ module ArJdbc
 
     # Maps logical Rails types to PostgreSQL-specific data types.
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-      case type.to_sym
-      when :'binary'
+      case type.to_s
+      when 'binary'
         # PostgreSQL doesn't support limits on binary (bytea) columns.
         # The hard limit is 1Gb, because of a 32-bit size field, and TOAST.
         case limit
-        when nil, 0..0x3fffffff; super(type, nil, nil, nil)
+        when nil, 0..0x3fffffff; super(type)
         else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
         end
-      when :'text'
+      when 'text'
         # PostgreSQL doesn't support limits on text columns.
         # The hard limit is 1Gb, according to section 8.3 in the manual.
         case limit
-        when nil, 0..0x3fffffff; super(type, nil, nil, nil)
+        when nil, 0..0x3fffffff; super(type)
         else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
         end
-      when :'integer'
+      when 'integer'
         return 'integer' unless limit
 
         case limit
@@ -161,7 +164,7 @@ module ArJdbc
           when 5..8; 'bigint'
           else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
         end
-      when :'datetime'
+      when 'datetime'
         return super unless precision
 
         case precision
@@ -201,7 +204,7 @@ module ArJdbc
       when Hash
         case column.sql_type
         when 'hstore'
-          jdbc_column_class.hstore_to_string(value)
+          jdbc_column_class.hstore_to_string(value, array_member)
         when 'json', 'jsonb'
           jdbc_column_class.json_to_string(value)
         else super(value, column)
@@ -215,7 +218,7 @@ module ArJdbc
       else
         super(value, column)
       end
-    end if AR4_COMPAT && ! AR42_COMPAT
+    end if AR40 && ! AR42
 
     # @private
     def _type_cast(value)
@@ -224,14 +227,14 @@ module ArJdbc
         # 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 }
+        { :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
+    end if AR42
+    private :_type_cast if AR42
 
     NATIVE_DATABASE_TYPES = {
       :primary_key => "serial primary key",
@@ -273,14 +276,14 @@ module ArJdbc
       :tstzrange => { :name => "tstzrange" },
       :int4range => { :name => "int4range" },
       :int8range => { :name => "int8range" },
-    }) if AR4_COMPAT
+    }) if AR40
 
     NATIVE_DATABASE_TYPES.update(
       :bigserial => "bigserial",
       :bigint => { :name => "bigint" },
       :bit => { :name => "bit" },
       :bit_varying => { :name => "bit varying" }
-    ) if AR42_COMPAT
+    ) if AR42
 
     def native_database_types
       NATIVE_DATABASE_TYPES
@@ -293,13 +296,13 @@ module ArJdbc
       spec[:array] = 'true' if column.respond_to?(:array) && column.array
       spec[:default] = "\"#{column.default_function}\"" if column.default_function
       spec
-    end if AR4_COMPAT
+    end if AR40
 
     # Adds `:array` as a valid migration key.
     # @override
     def migration_keys
       super + [:array]
-    end if AR4_COMPAT
+    end if AR40
 
     # Enable standard-conforming strings if available.
     def set_standard_conforming_strings
@@ -367,12 +370,12 @@ module ArJdbc
 
     def supports_index_sort_order?; true end
 
-    def supports_partial_index?; true end if AR4_COMPAT
+    def supports_partial_index?; true end if AR40
 
     # Range data-types weren't introduced until PostgreSQL 9.2.
     def supports_ranges?
       postgresql_version >= 90200
-    end if AR4_COMPAT
+    end if AR40
 
     def supports_transaction_isolation?(level = nil)
       true
@@ -518,9 +521,8 @@ module ArJdbc
       result = select(<<-end_sql, 'SCHEMA').first
         SELECT attr.attname
         FROM pg_attribute attr
-        INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.conkey[1]
-        WHERE cons.contype = 'p'
-          AND cons.conrelid = '#{quote_table_name(table)}'::regclass
+        INNER JOIN pg_constraint cons ON attr.attrelid = cons.conrelid AND attr.attnum = any(cons.conkey)
+        WHERE cons.contype = 'p' AND cons.conrelid = '#{quote_table_name(table)}'::regclass
       end_sql
 
       result && result['attname']
@@ -874,7 +876,7 @@ module ArJdbc
         sql_type = column.respond_to?(:sql_type) && column.sql_type
         sql_type && sql_type[0, 3] == 'bit' ? quote_bit(value) : super
       when Array
-        if AR4_COMPAT && column.array? # will be always falsy in AR < 4.0
+        if AR40 && column.array? # will be always falsy in AR < 4.0
           "'#{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)
@@ -895,7 +897,7 @@ module ArJdbc
         end
       when Range
         sql_type = column.respond_to?(:sql_type) && column.sql_type
-        if sql_type && sql_type[-5, 5] == 'range' && AR4_COMPAT
+        if sql_type && sql_type[-5, 5] == 'range' && AR40
           escaped = quote_string(jdbc_column_class.range_to_string(value))
           "'#{escaped}'::#{sql_type}"
         else super
@@ -908,7 +910,7 @@ module ArJdbc
       else
         super
       end
-    end unless AR42_COMPAT
+    end unless AR42
 
     # @private
     def _quote(value)
@@ -932,8 +934,8 @@ module ArJdbc
       else
         super
       end
-    end if AR42_COMPAT
-    private :_quote if AR42_COMPAT
+    end if AR42
+    private :_quote if AR42
 
     # Quotes a string, escaping any ' (single quote) and \ (backslash) chars.
     # @return [String]
@@ -962,7 +964,7 @@ module ArJdbc
 
     def quote_bit(value)
       "B'#{value}'"
-    end if AR4_COMPAT
+    end if AR40
 
     def escape_bytea(string)
       return unless string
@@ -990,7 +992,7 @@ module ArJdbc
     # @override
     def quote_table_name_for_assignment(table, attr)
       quote_column_name(attr)
-    end if AR4_COMPAT
+    end if AR40
 
     # @override
     def quote_column_name(name)
@@ -1072,35 +1074,50 @@ module ArJdbc
       change_column_null(table_name, column_name, false, default) if notnull
     end if ::ActiveRecord::VERSION::MAJOR < 4
 
+    # @private documented above
+    def add_column(table_name, column_name, type, options = {}); super end if AR42
+
     # Changes the column of a table.
     def change_column(table_name, column_name, type, options = {})
       quoted_table_name = quote_table_name(table_name)
+      quoted_column_name = quote_table_name(column_name)
 
       sql_type = type_to_sql(type, options[:limit], options[:precision], options[:scale])
       sql_type << "[]" if options[:array]
 
+      sql = "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quoted_column_name} TYPE #{sql_type}"
+      sql << " USING #{options[:using]}" if options[:using]
+      if options[:cast_as]
+        sql << " USING CAST(#{quoted_column_name} AS #{type_to_sql(options[:cast_as], options[:limit], options[:precision], options[:scale])})"
+      end
       begin
-        execute "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quote_column_name(column_name)} TYPE #{sql_type}"
+        execute sql
       rescue ActiveRecord::StatementInvalid => e
         raise e if postgresql_version > 80000
-        # This is PostgreSQL 7.x, so we have to use a more arcane way of doing it.
-        begin
-          begin_db_transaction
-          tmp_column_name = "#{column_name}_ar_tmp"
-          add_column(table_name, tmp_column_name, type, options)
-          execute "UPDATE #{quoted_table_name} SET #{quote_column_name(tmp_column_name)} = CAST(#{quote_column_name(column_name)} AS #{sql_type})"
-          remove_column(table_name, column_name)
-          rename_column(table_name, tmp_column_name, column_name)
-          commit_db_transaction
-        rescue
-          rollback_db_transaction
-        end
+        change_column_pg7(table_name, column_name, type, options)
       end
 
       change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
       change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
     end # unless const_defined? :SchemaCreation
 
+    def change_column_pg7(table_name, column_name, type, options)
+      quoted_table_name = quote_table_name(table_name)
+      # This is PostgreSQL 7.x, so we have to use a more arcane way of doing it.
+      begin
+        begin_db_transaction
+        tmp_column_name = "#{column_name}_ar_tmp"
+        add_column(table_name, tmp_column_name, type, options)
+        execute "UPDATE #{quoted_table_name} SET #{quote_column_name(tmp_column_name)} = CAST(#{quote_column_name(column_name)} AS #{sql_type})"
+        remove_column(table_name, column_name)
+        rename_column(table_name, tmp_column_name, column_name)
+        commit_db_transaction
+      rescue
+        rollback_db_transaction
+      end
+    end
+    private :change_column_pg7
+
     # Changes the default value of a table column.
     def change_column_default(table_name, column_name, default)
       if column = column_for(table_name, column_name) # (backwards) compatible with AR 3.x - 4.x
@@ -1108,8 +1125,23 @@ module ArJdbc
       else
         execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}"
       end
-    end # unless const_defined? :SchemaCreation
+    end unless AR42 # unless const_defined? :SchemaCreation
+
+    # @private documented above
+    def change_column_default(table_name, column_name, default)
+      return unless column = column_for(table_name, column_name)
+
+      alter_column_query = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} %s"
+      if default.nil?
+        # <tt>DEFAULT NULL</tt> results in the same behavior as <tt>DROP DEFAULT</tt>. However, PostgreSQL will
+        # cast the default to the columns type, which leaves us with a default like "default NULL::character varying".
+        execute alter_column_query % "DROP DEFAULT"
+      else
+        execute alter_column_query % "SET DEFAULT #{quote_default_value(default, column)}"
+      end
+    end if AR42
 
+    # @private
     def change_column_null(table_name, column_name, null, default = nil)
       unless null || default.nil?
         if column = column_for(table_name, column_name) # (backwards) compatible with AR 3.x - 4.x
@@ -1119,7 +1151,16 @@ module ArJdbc
         end
       end
       execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
-    end # unless const_defined? :SchemaCreation
+    end unless AR42 # unless const_defined? :SchemaCreation
+
+    # @private
+    def change_column_null(table_name, column_name, null, default = nil)
+      unless null || default.nil?
+        column = column_for(table_name, column_name)
+        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_value(default, column)} WHERE #{quote_column_name(column_name)} IS NULL") if column
+      end
+      execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL")
+    end if AR42
 
     def rename_column(table_name, column_name, new_column_name)
       execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
@@ -1129,16 +1170,55 @@ module ArJdbc
     def add_index(table_name, column_name, options = {})
       index_name, index_type, index_columns, index_options, index_algorithm, index_using = add_index_options(table_name, column_name, options)
       execute "CREATE #{index_type} INDEX #{index_algorithm} #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{index_using} (#{index_columns})#{index_options}"
-    end if AR4_COMPAT
+    end if AR40
 
     def remove_index!(table_name, index_name)
       execute "DROP INDEX #{quote_table_name(index_name)}"
     end
 
     def rename_index(table_name, old_name, new_name)
+      validate_index_length!(table_name, new_name) if respond_to?(:validate_index_length!)
+
       execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
     end
 
+    def supports_foreign_keys?; true end
+
+    def foreign_keys(table_name)
+      fk_info = select_all "" <<
+        "SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete " <<
+        "FROM pg_constraint c " <<
+        "JOIN pg_class t1 ON c.conrelid = t1.oid " <<
+        "JOIN pg_class t2 ON c.confrelid = t2.oid " <<
+        "JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid " <<
+        "JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid " <<
+        "JOIN pg_namespace t3 ON c.connamespace = t3.oid " <<
+        "WHERE c.contype = 'f' " <<
+        "  AND t1.relname = #{quote(table_name)} " <<
+        "  AND t3.nspname = ANY (current_schemas(false)) " <<
+        "ORDER BY c.conname "
+
+      fk_info.map! do |row|
+        options = {
+          :column => row['column'], :name => row['name'], :primary_key => row['primary_key']
+        }
+        options[:on_delete] = extract_foreign_key_action(row['on_delete'])
+        options[:on_update] = extract_foreign_key_action(row['on_update'])
+
+        ForeignKeyDefinition.new(table_name, row['to_table'], options)
+      end
+    end if defined? ForeignKeyDefinition
+
+    # @private
+    def extract_foreign_key_action(specifier)
+      case specifier
+      when 'c'; :cascade
+      when 'n'; :nullify
+      when 'r'; :restrict
+      end
+    end
+    private :extract_foreign_key_action
+
     def index_name_length
       63
     end
@@ -1180,12 +1260,12 @@ module ArJdbc
 
         column.new(name, default_value, oid_type, type, ! notnull, default_function, oid, self)
       end
-    end if AR42_COMPAT
+    end if AR42
 
     # @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
+    end if AR42
 
     # @private
     def column_for(table_name, column_name)
@@ -1227,7 +1307,7 @@ module ArJdbc
     # @private
     TABLE_EXISTS_SQL_PREFIX =  'SELECT COUNT(*) as table_count FROM pg_class c'
     TABLE_EXISTS_SQL_PREFIX << ' LEFT JOIN pg_namespace n ON n.oid = c.relnamespace'
-    if AR42_COMPAT # -- (r)elation/table, (v)iew, (m)aterialized view
+    if AR42 # -- (r)elation/table, (v)iew, (m)aterialized view
     TABLE_EXISTS_SQL_PREFIX << " WHERE c.relkind IN ('r','v','m')"
     else
     TABLE_EXISTS_SQL_PREFIX << " WHERE c.relkind IN ('r','v')"
@@ -1251,6 +1331,10 @@ module ArJdbc
       end
     end
 
+    def drop_table(table_name, options = {})
+      execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+    end
+
     def truncate(table_name, name = nil)
       execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
     end
@@ -1266,7 +1350,7 @@ module ArJdbc
           AND t.relname = '#{table_name}'
           AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
       SQL
-    end if AR42_COMPAT
+    end if AR42
 
     # Returns an array of indexes for the given table.
     def indexes(table_name, name = nil)
@@ -1328,7 +1412,7 @@ module ArJdbc
       when 'average' then 'avg'
       else operation.downcase
       end
-    end if AR42_COMPAT
+    end if AR42
 
     private
 
@@ -1391,9 +1475,9 @@ module ActiveRecord::ConnectionAdapters
     include ::ArJdbc::PostgreSQL
     include ::ArJdbc::PostgreSQL::ExplainSupport
 
-    require 'arjdbc/postgresql/oid_types' if AR4_COMPAT
+    require 'arjdbc/postgresql/oid_types' if ::ArJdbc::AR40
     include ::ArJdbc::PostgreSQL::OIDTypes if ::ArJdbc::PostgreSQL.const_defined?(:OIDTypes)
-    include ::ArJdbc::PostgreSQL::ColumnHelpers if AR42_COMPAT
+    include ::ArJdbc::PostgreSQL::ColumnHelpers if ::ArJdbc::AR42
 
     include ::ArJdbc::Util::QuotedCache
 
@@ -1405,141 +1489,28 @@ module ActiveRecord::ConnectionAdapters
 
       @table_alias_length = nil
 
-      initialize_type_map(@type_map = Type::HashLookupTypeMap.new) if AR42_COMPAT
+      initialize_type_map(@type_map = Type::HashLookupTypeMap.new) if ::ArJdbc::AR42
 
       @use_insert_returning = @config.key?(:insert_returning) ?
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : nil
     end
 
-    class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-      attr_accessor :array
-      def array?; !!@array; end
-    end
-
-    module ColumnMethods
-      def xml(*args)
-        options = args.extract_options!
-        column(args[0], 'xml', options)
-      end
-
-      def tsvector(*args)
-        options = args.extract_options!
-        column(args[0], 'tsvector', options)
-      end
-
-      def int4range(name, options = {})
-        column(name, 'int4range', options)
-      end
-
-      def int8range(name, options = {})
-        column(name, 'int8range', options)
-      end
-
-      def tsrange(name, options = {})
-        column(name, 'tsrange', options)
-      end
-
-      def tstzrange(name, options = {})
-        column(name, 'tstzrange', options)
-      end
-
-      def numrange(name, options = {})
-        column(name, 'numrange', options)
-      end
-
-      def daterange(name, options = {})
-        column(name, 'daterange', options)
-      end
-
-      def hstore(name, options = {})
-        column(name, 'hstore', options)
-      end
-
-      def ltree(name, options = {})
-        column(name, 'ltree', options)
-      end
-
-      def inet(name, options = {})
-        column(name, 'inet', options)
-      end
-
-      def cidr(name, options = {})
-        column(name, 'cidr', options)
-      end
-
-      def macaddr(name, options = {})
-        column(name, 'macaddr', options)
-      end
-
-      def uuid(name, options = {})
-        column(name, 'uuid', options)
-      end
-
-      def json(name, options = {})
-        column(name, 'json', options)
-      end
-
-      def jsonb(name, options = {})
-        column(name, :jsonb, options)
-      end
-
-      def bit(name, options)
-        column(name, 'bit', options)
-      end
-
-      def bit_varying(name, options)
-        column(name, 'bit varying', options)
-      end
+    if ::ArJdbc::AR42
+      require 'active_record/connection_adapters/postgresql/schema_definitions'
+    else
+      require 'arjdbc/postgresql/base/schema_definitions'
     end
 
-    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-      include ColumnMethods
-
-      def primary_key(name, type = :primary_key, options = {})
-        return super unless type == :uuid
-        options[:default] = options.fetch(:default, 'uuid_generate_v4()')
-        options[:primary_key] = true
-        column name, type, options
-      end if ::ActiveRecord::VERSION::MAJOR > 3 # 3.2 super expects (name)
-
-      def column(name, type = nil, options = {})
-        super
-        column = self[name]
-        # NOTE: <= 3.1 no #new_column_definition hard-coded ColumnDef.new :
-        # column = self[name] || ColumnDefinition.new(@base, name, type)
-        # thus we simply do not support array column definitions on <= 3.1
-        column.array = options[:array] if column.is_a?(ColumnDefinition)
-        self
-      end
+    ColumnDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDefinition
 
-      private
-
-      if ::ActiveRecord::VERSION::MAJOR > 3
-
-        def create_column_definition(name, type)
-          ColumnDefinition.new name, type
-        end
-
-      else # no #create_column_definition on 3.2
-
-        def new_column_definition(base, name, type)
-          definition = ColumnDefinition.new base, name, type
-          @columns << definition
-          @columns_hash[name] = definition
-          definition
-        end
-
-      end
-
-    end
+    ColumnMethods = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods
+    TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
 
     def table_definition(*args)
       new_table_definition(TableDefinition, *args)
     end
 
-    class Table < ActiveRecord::ConnectionAdapters::Table
-      include ColumnMethods
-    end
+    Table = ActiveRecord::ConnectionAdapters::PostgreSQL::Table
 
     def update_table_definition(table_name, base)
       Table.new(table_name, base)