activerecord-jdbc-adapter 1.2.1 → 1.2.2

data/lib/arjdbc/mysql/adapter.rb

@@ -135,7 +135,7 @@ module ::ArJdbc
     def quote_column_name(name)
       "`#{name.to_s.gsub('`', '``')}`"
     end
-    
+
     def quoted_true
       "1"
     end
@@ -192,13 +192,54 @@ module ::ArJdbc
       end
     end
 
+    # based on:
+    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L756
+    # Required for passing rails column caching tests
+    # Returns a table's primary key and belonging sequence.
+    def pk_and_sequence_for(table) #:nodoc:
+      keys = []
+      result = execute("SHOW INDEX FROM #{quote_table_name(table)} WHERE Key_name = 'PRIMARY'", 'SCHEMA')
+      result.each do |h|
+        keys << h["Column_name"]
+      end
+      keys.length == 1 ? [keys.first, nil] : nil
+    end
+
+    # based on:
+    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L647
+    # Returns an array of indexes for the given table.
+    def indexes(table_name, name = nil)#:nodoc:
+      indexes = []
+      current_index = nil
+      result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", name)
+      result.each do |row|
+        key_name = row["Key_name"]
+        if current_index != key_name
+          next if key_name == "PRIMARY" # skip the primary key
+          current_index = key_name
+          indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(
+            row["Table"], key_name, row["Non_unique"] == 0, [], [])
+        end
+
+        indexes.last.columns << row["Column_name"]
+        indexes.last.lengths << row["Sub_part"]
+      end
+      indexes
+    end
+
     def jdbc_columns(table_name, name = nil)#:nodoc:
       sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
-      execute(sql, :skip_logging).map do |field|
-        ::ActiveRecord::ConnectionAdapters::MysqlAdapter::Column.new(field["Field"], field["Default"], field["Type"], field["Null"] == "YES")
+      execute(sql, 'SCHEMA').map do |field|
+        ::ActiveRecord::ConnectionAdapters::MysqlColumn.new(field["Field"], field["Default"], field["Type"], field["Null"] == "YES")
       end
     end
 
+    # Returns just a table's primary key
+    def primary_key(table)
+      pk_and_sequence = pk_and_sequence_for(table)
+      pk_and_sequence && pk_and_sequence.first
+    end
+
     def recreate_database(name, options = {}) #:nodoc:
       drop_database(name)
       create_database(name, options)
@@ -221,7 +262,7 @@ module ::ArJdbc
     end
 
     def create_table(name, options = {}) #:nodoc:
-      super(name, {:options => "ENGINE=InnoDB"}.merge(options))
+      super(name, {:options => "ENGINE=InnoDB DEFAULT CHARSET=utf8"}.merge(options))
     end
 
     def rename_table(name, new_name)
@@ -293,6 +334,29 @@ module ::ArJdbc
       sql
     end
 
+    # Taken from: https://github.com/gfmurphy/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L540
+    #
+    # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
+    # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+    # these, we must use a subquery. However, MySQL is too stupid to create a
+    # temporary table for this automatically, so we have to give it some prompting
+    # in the form of a subsubquery. Ugh!
+    def join_to_update(update, select) #:nodoc:
+      if select.limit || select.offset || select.orders.any?
+        subsubselect = select.clone
+        subsubselect.projections = [update.key]
+
+        subselect = Arel::SelectManager.new(select.engine)
+        subselect.project Arel.sql(update.key.name)
+        subselect.from subsubselect.as('__active_record_temp')
+
+        update.where update.key.in(subselect)
+      else
+        update.table select.source
+        update.wheres = select.constraints
+      end
+    end
+
     def show_variable(var)
       res = execute("show variables like '#{var}'")
       result_row = res.detect {|row| row["Variable_name"] == var }
@@ -333,12 +397,12 @@ module ::ArJdbc
       length = options[:length] if options.is_a?(Hash)
 
       case length
-        when Hash
-          column_names.map { |name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
-        when Fixnum
-          column_names.map { |name| "#{quote_column_name(name)}(#{length})" }
-        else
-          column_names.map { |name| quote_column_name(name) }
+      when Hash
+        column_names.map { |name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
+      when Fixnum
+        column_names.map { |name| "#{quote_column_name(name)}(#{length})" }
+      else
+        column_names.map { |name| quote_column_name(name) }
       end
     end
 
@@ -373,31 +437,13 @@ module ::ArJdbc
   end
 end
 
-module ActiveRecord::ConnectionAdapters
-  # Remove any vestiges of core/Ruby MySQL adapter
-  remove_const(:MysqlColumn) if const_defined?(:MysqlColumn)
-  remove_const(:MysqlAdapter) if const_defined?(:MysqlAdapter)
-
-  class MysqlAdapter < JdbcAdapter
-    include ArJdbc::MySQL
-
-    def initialize(*args)
-      super
-      configure_connection
-    end
+module ActiveRecord
+  module ConnectionAdapters
+    # Remove any vestiges of core/Ruby MySQL adapter
+    remove_const(:MysqlColumn) if const_defined?(:MysqlColumn)
+    remove_const(:MysqlAdapter) if const_defined?(:MysqlAdapter)
 
-    def jdbc_connection_class(spec)
-      ::ArJdbc::MySQL.jdbc_connection_class
-    end
-
-    def jdbc_column_class
-      ActiveRecord::ConnectionAdapters::MysqlAdapter::Column
-    end
-
-    alias_chained_method :columns, :query_cache, :jdbc_columns
-
-    remove_const(:Column) if const_defined?(:Column)
-    class Column < JdbcColumn
+    class MysqlColumn < JdbcColumn
       include ArJdbc::MySQL::ColumnExtensions
 
       def initialize(name, *args)
@@ -411,20 +457,39 @@ module ActiveRecord::ConnectionAdapters
       def call_discovered_column_callbacks(*)
       end
     end
-    
-    protected
-    def exec_insert(sql, name, binds)
-      binds = binds.dup
 
-      # Pretend to support bind parameters
-      unless binds.empty?
-        sql = sql.gsub('?') { quote(*binds.shift.reverse) }
+    class MysqlAdapter < JdbcAdapter
+      include ArJdbc::MySQL
+
+      def initialize(*args)
+        super
+        configure_connection
       end
-      execute sql, name
-    end
-    alias :exec_update :exec_insert
-    alias :exec_delete :exec_insert
 
+      def jdbc_connection_class(spec)
+        ::ArJdbc::MySQL.jdbc_connection_class
+      end
+
+      def jdbc_column_class
+        ActiveRecord::ConnectionAdapters::MysqlColumn
+      end
+
+      alias_chained_method :columns, :query_cache, :jdbc_columns
+
+      protected
+      def exec_insert(sql, name, binds)
+        binds = binds.dup
+
+        # Pretend to support bind parameters
+        unless binds.empty?
+          sql = sql.gsub('?') { quote(*binds.shift.reverse) }
+        end
+        execute sql, name
+      end
+      alias :exec_update :exec_insert
+      alias :exec_delete :exec_insert
+
+    end
   end
 end
 

data/lib/arjdbc/oracle/adapter.rb

@@ -58,6 +58,13 @@ module ::ArJdbc
         end
       end
 
+      def extract_limit(sql_type)
+        case sql_type
+        when /^(clob|date)/i; nil
+        else super
+        end
+      end
+
       def type_cast_code(var_name)
         case type
         when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name}, self.class)"

data/lib/arjdbc/postgresql/adapter.rb

@@ -6,7 +6,6 @@ module ::ArJdbc
   module PostgreSQL
     def self.extended(mod)
       (class << mod; self; end).class_eval do
-        alias_chained_method :insert, :query_dirty, :pg_insert
         alias_chained_method :columns, :query_cache, :pg_columns
       end
     end
@@ -19,90 +18,170 @@ module ::ArJdbc
       ::ActiveRecord::ConnectionAdapters::PostgresJdbcConnection
     end
 
+    # column behavior based on postgresql_adapter in rails project
+    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L41
     module Column
-      def type_cast(value)
-        case type
-        when :boolean then cast_to_boolean(value)
-        else super
+      def self.included(base)
+        class << base
+          attr_accessor :money_precision
+          def string_to_time(string)
+            return string unless String === string
+
+            case string
+            when 'infinity' then 1.0 / 0.0
+            when '-infinity' then -1.0 / 0.0
+            else
+              super
+            end
+          end
+        end
+      end
+
+      private
+      # Extracts the value from a Postgresql column default definition
+      def default_value(default)
+        case default
+          # This is a performance optimization for Ruby 1.9.2 in development.
+          # If the value is nil, we return nil straight away without checking
+          # the regular expressions. If we check each regular expression,
+          # Regexp#=== will call NilClass#to_str, which will trigger
+          # method_missing (defined by whiny nil in ActiveSupport) which
+          # makes this method very very slow.
+        when NilClass
+          nil
+          # Numeric types
+        when /\A\(?(-?\d+(\.\d*)?\)?)\z/
+          $1
+          # Character types
+        when /\A'(.*)'::(?:character varying|bpchar|text)\z/m
+          $1
+          # Character types (8.1 formatting)
+        when /\AE'(.*)'::(?:character varying|bpchar|text)\z/m
+          $1.gsub(/\\(\d\d\d)/) { $1.oct.chr }
+          # Binary data types
+        when /\A'(.*)'::bytea\z/m
+          $1
+          # Date/time types
+        when /\A'(.+)'::(?:time(?:stamp)? with(?:out)? time zone|date)\z/
+          $1
+        when /\A'(.*)'::interval\z/
+          $1
+          # Boolean type
+        when 'true'
+          true
+        when 'false'
+          false
+          # Geometric types
+        when /\A'(.*)'::(?:point|line|lseg|box|"?path"?|polygon|circle)\z/
+          $1
+          # Network address types
+        when /\A'(.*)'::(?:cidr|inet|macaddr)\z/
+          $1
+          # Bit string types
+        when /\AB'(.*)'::"?bit(?: varying)?"?\z/
+          $1
+          # XML type
+        when /\A'(.*)'::xml\z/m
+          $1
+          # Arrays
+        when /\A'(.*)'::"?\D+"?\[\]\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_limit(sql_type)
         case sql_type
-        when /^int2/i;      2
-        when /^smallint/i;  2
-        when /^int4/i;      nil
-        when /^integer/i;   nil
-        when /^int8/i;      8
-        when /^bigint/i;    8
-        when /^(bool|text|date|time|bytea)/i; nil # ACTIVERECORD_JDBC-135,139
+        when /^bigint/i then 8
+        when /^smallint/i then 2
         else super
         end
       end
 
-      def simplified_type(field_type)
-        return :integer if field_type =~ /^(big|)serial/i
-        return :string if field_type =~ /\[\]$/i || field_type =~ /^interval/i
-        return :string if field_type =~ /^(?:point|lseg|box|"?path"?|polygon|circle)/i
-        return :string if field_type =~ /^uuid/i
-        return :datetime if field_type =~ /^timestamp/i
-        return :float if field_type =~ /^(?:real|double precision)$/i
-        return :binary if field_type =~ /^bytea/i
-        return :boolean if field_type =~ /^bool/i
-        return :decimal if field_type == 'numeric(131089)'
-        super
+      # Extracts the scale from PostgreSQL-specific data types.
+      def extract_scale(sql_type)
+        # Money type has a fixed scale of 2.
+        sql_type =~ /^money/ ? 2 : super
       end
 
-      def cast_to_boolean(value)
-        return nil if value.nil?
-        if value == true || value == false
-          value
+      # Extracts the precision from PostgreSQL-specific data types.
+      def extract_precision(sql_type)
+        if sql_type == 'money'
+          self.class.money_precision
         else
-          %w(true t 1).include?(value.to_s.downcase)
+          super
         end
       end
 
-      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
-      def default_value(value)
-        # Boolean types
-        return "t" if value =~ /true/i
-        return "f" if value =~ /false/i
-
-        # Char/String/Bytea type values
-        return $1 if value =~ /^'(.*)'::(bpchar|text|character varying|bytea)$/
-
-        # Numeric values
-        return value.delete("()") if value =~ /^\(?-?[0-9]+(\.[0-9]*)?\)?/
-
-        # Fixed dates / timestamp
-        return $1 if value =~ /^'(.+)'::(date|timestamp)/
-
-        # Anything else is blank, some user type, or some function
-        # and we can't know the value of that, so return nil.
-        return nil
+      # Maps PostgreSQL-specific data types to logical Rails types.
+      def simplified_type(field_type)
+        case field_type
+          # Numeric and monetary types
+        when /^(?:real|double precision)$/ then :float
+          # Monetary types
+        when 'money' then :decimal
+          # Character types
+        when /^(?:character varying|bpchar)(?:\(\d+\))?$/ then :string
+          # Binary data types
+        when 'bytea' then :binary
+          # Date/time types
+        when /^timestamp with(?:out)? time zone$/ then :datetime
+        when 'interval' then :string
+          # Geometric types
+        when /^(?:point|line|lseg|box|"?path"?|polygon|circle)$/ then :string
+          # Network address types
+        when /^(?:cidr|inet|macaddr)$/ then :string
+          # Bit strings
+        when /^bit(?: varying)?(?:\(\d+\))?$/ then :string
+          # XML type
+        when 'xml' then :xml
+          # tsvector type
+        when 'tsvector' then :tsvector
+          # Arrays
+        when /^\D+\[\]$/ then :string
+          # Object identifier types
+        when 'oid' then :integer
+          # UUID type
+        when 'uuid' then :string
+          # Small and big integer types
+        when /^(?:small|big)int$/ then :integer
+          # Pass through all types that are not specific to PostgreSQL.
+        else
+          super
+        end
       end
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = "serial primary key"
-      tp[:string][:limit] = 255
-      tp[:integer][:limit] = nil
-      tp[:boolean] = { :name => "boolean" }
-      tp[:float] = { :name => "float" }
-      tp[:text] = { :name => "text" }
-      tp[:datetime] = { :name => "timestamp" }
-      tp[:timestamp] = { :name => "timestamp" }
-      tp[:time] = { :name => "time" }
-      tp[:date] = { :name => "date" }
-      tp[:decimal] = { :name => "decimal" }
-      tp
-    end
+    # constants taken from postgresql_adapter in rails project
+    ADAPTER_NAME = 'PostgreSQL'
+
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "serial primary key",
+      :string      => { :name => "character varying", :limit => 255 },
+      :text        => { :name => "text" },
+      :integer     => { :name => "integer" },
+      :float       => { :name => "float" },
+      :decimal     => { :name => "decimal" },
+      :datetime    => { :name => "timestamp" },
+      :timestamp   => { :name => "timestamp" },
+      :time        => { :name => "time" },
+      :date        => { :name => "date" },
+      :binary      => { :name => "bytea" },
+      :boolean     => { :name => "boolean" },
+      :xml         => { :name => "xml" },
+      :tsvector    => { :name => "tsvector" }
+    }
 
     def adapter_name #:nodoc:
-      'PostgreSQL'
+      ADAPTER_NAME
     end
 
-
     def self.arel2_visitors(config)
       {}.tap {|v| %w(postgresql pg jdbcpostgresql).each {|a| v[a] = ::Arel::Visitors::PostgreSQL } }
     end
@@ -119,6 +198,10 @@ module ::ArJdbc
         end
     end
 
+    def native_database_types
+      NATIVE_DATABASE_TYPES
+    end
+
     # Does PostgreSQL support migrations?
     def supports_migrations?
       true
@@ -247,64 +330,45 @@ module ::ArJdbc
       nil
     end
 
-    def pg_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-      sql = substitute_binds(sql, binds)
-
-      # Extract the table from the insert sql. Yuck.
-      table = sql.split(" ", 4)[2].gsub('"', '')
+    def primary_key(table)
+      pk_and_sequence = pk_and_sequence_for(table)
+      pk_and_sequence && pk_and_sequence.first
+    end
 
-      # Try an insert with 'returning id' if available (PG >= 8.2)
-      if supports_insert_with_returning? && id_value.nil?
-        pk, sequence_name = *pk_and_sequence_for(table) unless pk
-        if pk
-          sql = substitute_binds(sql, binds)
-          id_value = select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-          clear_query_cache #FIXME: Why now?
-          return id_value
-        end
+    # taken from rails postgresql adapter
+    # https://github.com/gfmurphy/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L611
+    def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+      unless pk
+        table_ref = extract_table_ref_from_insert_sql(sql)
+        pk = primary_key(table_ref) if table_ref
       end
 
-      # Otherwise, plain insert
-      execute(sql, name, binds)
-
-      # Don't need to look up id_value if we already have it.
-      # (and can't in case of non-sequence PK)
-      unless id_value
-        # If neither pk nor sequence name is given, look them up.
-        unless pk || sequence_name
-          pk, sequence_name = *pk_and_sequence_for(table)
-        end
+      sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
 
-        # If a pk is given, fallback to default sequence name.
-        # Don't fetch last insert id for a table without a pk.
-        if pk && sequence_name ||= default_sequence_name(table, pk)
-          id_value = last_insert_id(table, sequence_name)
-        end
-      end
-      id_value
+      [sql, binds]
     end
 
     def pg_columns(table_name, name=nil)
-      schema_name = @config[:schema_search_path]
-      if table_name =~ /\./
-        parts = table_name.split(/\./)
-        table_name = parts.pop
-        schema_name = parts.join(".")
+      column_definitions(table_name).map do |row|
+        ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new(
+          row["column_name"], row["column_default"], row["column_type"],
+          row["column_not_null"] == "f")
       end
-      schema_list = if schema_name.nil?
-          []
-        else
-          schema_name.split(/\s*,\s*/)
-        end
-      while schema_list.size > 1
-        s = schema_list.shift
-        begin
-          return @connection.columns_internal(table_name, name, s)
-        rescue ActiveRecord::JDBCError=>ignored_for_next_schema
-        end
-      end
-      s = schema_list.shift
-      return @connection.columns_internal(table_name, name, s)
+    end
+
+    # current database name
+    def current_database
+      exec_query("select current_database() as database").
+        first["database"]
+    end
+
+    # current database encoding
+    def encoding
+      exec_query(<<-end_sql).first["encoding"]
+        SELECT pg_encoding_to_char(pg_database.encoding) as encoding
+        FROM pg_database
+        WHERE pg_database.datname LIKE '#{current_database}'
+      end_sql
     end
 
     # Sets the maximum number columns postgres has, default 32
@@ -341,10 +405,10 @@ module ::ArJdbc
 
       insertion_order = []
       index_order = nil
-      
+
       result.each do |row|
         if current_index != row[0]
-        
+
           (index_order = row[4].split(' ')).each_with_index{ |v, i| index_order[i] = v.to_i }
           indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, row[0], row[1] == "t", [])
           current_index = row[0]
@@ -357,6 +421,11 @@ module ::ArJdbc
       indexes
     end
 
+    # take id from result of insert query
+    def last_inserted_id(result)
+      Hash[Array(*result)].fetch("id") { result }
+    end
+
     def last_insert_id(table, sequence_name)
       Integer(select_value("SELECT currval('#{sequence_name}')"))
     end
@@ -386,11 +455,6 @@ module ::ArJdbc
       select('select nspname from pg_namespace').map {|r| r["nspname"] }
     end
 
-    def primary_key(table)
-      pk_and_sequence = pk_and_sequence_for(table)
-      pk_and_sequence && pk_and_sequence.first
-    end
-
     def structure_dump
       database = @config[:database]
       if database.nil?
@@ -425,18 +489,17 @@ module ::ArJdbc
     # requires that the ORDER BY include the distinct column.
     #
     #   distinct("posts.id", "posts.created_at desc")
-    def distinct(columns, order_by)
-      return "DISTINCT #{columns}" if order_by.blank?
+    def distinct(columns, orders) #:nodoc:
+      return "DISTINCT #{columns}" if orders.empty?
 
-      # construct a clean list of column names from the ORDER BY clause, removing
-      # any asc/desc modifiers
-      order_columns = [order_by].flatten.map{|o| o.split(',').collect { |s| s.split.first } }.flatten.reject(&:blank?)
-      order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
+      # Construct a clean list of column names from the ORDER BY clause, removing
+      # any ASC/DESC modifiers
+      order_columns = orders.collect { |s| s.gsub(/\s+(ASC|DESC)\s*/i, '') }.
+        reject(&:blank?)
+      order_columns = order_columns.
+        zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
 
-      # return a DISTINCT ON() clause that's distinct on the columns we want but includes
-      # all the required columns for the ORDER BY to work properly
-      sql = "DISTINCT ON (#{columns}) #{columns}, "
-      sql << order_columns * ', '
+      "DISTINCT #{columns}, #{order_columns * ', '}"
     end
 
     # ORDER BY clause for the passed order option.
@@ -453,22 +516,31 @@ module ::ArJdbc
       sql.replace "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}"
     end
 
+    # from postgres_adapter.rb in rails project
+    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L412
+    # Quotes PostgreSQL-specific data types for SQL input.
     def quote(value, column = nil) #:nodoc:
       return super unless column
 
-      if value.kind_of?(String) && column.type == :binary
-        "E'#{escape_bytea(value)}'"
-      elsif value.kind_of?(String) && column.sql_type == 'xml'
-        "xml '#{quote_string(value)}'"
-      elsif value.kind_of?(Numeric) && column.sql_type == 'money'
+      case value
+      when Float
+        return super unless value.infinite? && column.type == :datetime
+        "'#{value.to_s.downcase}'"
+      when Numeric
+        return super unless column.sql_type == 'money'
         # Not truly string input, so doesn't require (or allow) escape string syntax.
         "'#{value}'"
-      elsif value.kind_of?(String) && column.sql_type =~ /^bit/
-        case value
-        when /^[01]*$/
-          "B'#{value}'" # Bit-string notation
-        when /^[0-9A-F]*$/i
-          "X'#{value}'" # Hexadecimal notation
+      when String
+        case column.sql_type
+        when 'bytea' then "'#{escape_bytea(value)}'"
+        when 'xml'   then "xml '#{quote_string(value)}'"
+        when /^bit/
+          case value
+          when /^[01]*$/      then "B'#{value}'" # Bit-string notation
+          when /^[0-9A-F]*$/i then "X'#{value}'" # Hexadecimal notation
+          end
+        else
+          super
         end
       else
         super
@@ -572,24 +644,64 @@ module ::ArJdbc
       execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
     end
 
-    def remove_index(table_name, options) #:nodoc:
-      execute "DROP INDEX #{index_name(table_name, options)}"
+    def remove_index!(table_name, index_name) #:nodoc:
+      execute "DROP INDEX #{quote_table_name(index_name)}"
+    end
+
+    def index_name_length
+      63
     end
 
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+    # Maps logical Rails types to PostgreSQL-specific data types.
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       return super unless type.to_s == 'integer'
+      return 'integer' unless limit
 
-      if limit.nil? || limit == 4
-        'integer'
-      elsif limit < 4
-        'smallint'
-      else
-        'bigint'
+      case limit
+      when 1, 2; 'smallint'
+      when 3, 4; 'integer'
+      when 5..8; 'bigint'
+      else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
       end
     end
 
-    def tables
-      @connection.tables(database_name, nil, nil, ["TABLE"])
+    def tables(name = nil)
+      exec_query(<<-SQL, 'SCHEMA').map { |row| row["tablename"] }
+          SELECT tablename
+          FROM pg_tables
+          WHERE schemaname = ANY (current_schemas(false))
+      SQL
+    end
+
+    def table_exists?(name)
+      schema, table = extract_schema_and_table(name.to_s)
+      return false unless table # Abstract classes is having nil table name
+
+      binds = [[nil, table.gsub(/(^"|"$)/,'')]]
+      binds << [nil, schema] if schema
+
+      exec_query(<<-SQL, 'SCHEMA', binds).first["table_count"] > 0
+          SELECT COUNT(*) as table_count
+          FROM pg_tables
+          WHERE tablename = ?
+          AND schemaname = #{schema ? "?" : "ANY (current_schemas(false))"}
+      SQL
+    end
+
+    # Extracts the table and schema name from +name+
+    def extract_schema_and_table(name)
+      schema, table = name.split('.', 2)
+
+      unless table # A table was provided without a schema
+        table  = schema
+        schema = nil
+      end
+
+      if name =~ /^"/ # Handle quoted table names
+        table  = name
+        schema = nil
+      end
+      [schema, table]
     end
 
     private
@@ -604,6 +716,35 @@ module ::ArJdbc
       end
     end
 
+    # Returns the list of a table's column names, data types, and default values.
+    #
+    # The underlying query is roughly:
+    #  SELECT column.name, column.type, default.value
+    #    FROM column LEFT JOIN default
+    #      ON column.table_id = default.table_id
+    #     AND column.num = default.column_num
+    #   WHERE column.table_id = get_table_id('table_name')
+    #     AND column.num > 0
+    #     AND NOT column.is_dropped
+    #   ORDER BY column.num
+    #
+    # If the table name is not prefixed with a schema, the database will
+    # take the first match from the schema search path.
+    #
+    # Query implementation notes:
+    #  - format_type includes the column size constraint, e.g. varchar(50)
+    #  - ::regclass is a function that gives the id for a table name
+    def column_definitions(table_name) #:nodoc:
+      exec_query(<<-end_sql, 'SCHEMA')
+            SELECT a.attname as column_name, format_type(a.atttypid, a.atttypmod) as column_type, d.adsrc as column_default, a.attnotnull as column_not_null
+              FROM pg_attribute a LEFT JOIN pg_attrdef d
+                ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+             WHERE a.attrelid = '#{quote_table_name(table_name)}'::regclass
+               AND a.attnum > 0 AND NOT a.attisdropped
+             ORDER BY a.attnum
+          end_sql
+    end
+
     def extract_pg_identifier_from_name(name)
       match_data = name[0,1] == '"' ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
 
@@ -613,6 +754,12 @@ module ::ArJdbc
         [match_data[1], (rest.length > 0 ? rest : nil)]
       end
     end
+
+    # from rails postgresl_adapter
+    def extract_table_ref_from_insert_sql(sql)
+      sql[/into\s+([^\(]*).*values\s*\(/i]
+      $1.strip if $1
+    end
   end
 end
 
@@ -634,9 +781,37 @@ module ActiveRecord::ConnectionAdapters
     end
   end
 
+  class PostgresJdbcConnection < JdbcConnection
+    alias :java_native_database_types :set_native_database_types
+
+    # override to prevent connection from loading hash from jdbc
+    # metadata, which can be expensive. We can do this since
+    # native_database_types is defined in the adapter to use a static hash
+    # not relying on the driver's metadata
+    def set_native_database_types
+      @native_types = {}
+    end
+  end
+
   class PostgreSQLAdapter < JdbcAdapter
     include ArJdbc::PostgreSQL
 
+    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+      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
+    end
+
+    def table_definition
+      TableDefinition.new(self)
+    end
+
     def jdbc_connection_class(spec)
       ::ArJdbc::PostgreSQL.jdbc_connection_class
     end
@@ -644,8 +819,7 @@ module ActiveRecord::ConnectionAdapters
     def jdbc_column_class
       ActiveRecord::ConnectionAdapters::PostgreSQLColumn
     end
-    
-    alias_chained_method :insert, :query_dirty, :pg_insert
+
     alias_chained_method :columns, :query_cache, :pg_columns
   end
 end