activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/lib/arjdbc/oracle/connection_methods.rb

@@ -7,6 +7,6 @@ class ActiveRecord::Base
       config[:adapter_spec] = ::ArJdbc::Oracle
       jdbc_connection(config)
     end
+    alias_method :jdbcoracle_connection, :oracle_connection
   end
-end
-
+end

data/lib/arjdbc/postgresql.rb

@@ -1,3 +1,3 @@
 require 'arjdbc/jdbc'
-require 'arjdbc/postgresql/connection_methods'
 require 'arjdbc/postgresql/adapter'
+require 'arjdbc/postgresql/connection_methods'

data/lib/arjdbc/postgresql/adapter.rb

@@ -1,6 +1,4 @@
-module ActiveRecord::ConnectionAdapters
-  PostgreSQLAdapter = Class.new(AbstractAdapter) unless const_defined?(:PostgreSQLAdapter)
-end
+require 'arjdbc/postgresql/explain_support'
 
 module ::ArJdbc
   module PostgreSQL
@@ -167,29 +165,16 @@ module ::ArJdbc
     # 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:
       ADAPTER_NAME
     end
 
     def self.arel2_visitors(config)
-      {}.tap {|v| %w(postgresql pg jdbcpostgresql).each {|a| v[a] = ::Arel::Visitors::PostgreSQL } }
+      {
+        'postgresql' => ::Arel::Visitors::PostgreSQL,
+        'jdbcpostgresql' => ::Arel::Visitors::PostgreSQL,
+        'pg' => ::Arel::Visitors::PostgreSQL
+      }
     end
 
     def postgresql_version
@@ -204,66 +189,94 @@ module ::ArJdbc
         end
     end
 
+    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 native_database_types
       NATIVE_DATABASE_TYPES
     end
-
-    # Does PostgreSQL support migrations?
-    def supports_migrations?
-      true
-    end
-
+    
     # Enable standard-conforming strings if available.
     def standard_conforming_strings=(enable)
-      old, self.client_min_messages = client_min_messages, 'panic'
-      value = if(enable) then "on" else "off" end
-      execute("SET standard_conforming_strings = #{value}", 'SCHEMA')
-      @standard_conforming_strings = (value == "on")
-    rescue
-      @standard_conforming_strings = :unsupported
-    ensure
-      self.client_min_messages = old
+      client_min_messages = self.client_min_messages
+      begin
+        self.client_min_messages = 'panic'
+        value = enable ? "on" : "off"
+        execute("SET standard_conforming_strings = #{value}", 'SCHEMA')
+        @standard_conforming_strings = ( value == "on" )
+      rescue
+        @standard_conforming_strings = :unsupported
+      ensure
+        self.client_min_messages = client_min_messages
+      end
     end
 
-    def standard_conforming_strings? #:nodoc:
+    def standard_conforming_strings? # :nodoc:
       if @standard_conforming_strings.nil?
+        client_min_messages = self.client_min_messages
         begin
-          old, self.client_min_messages = client_min_messages, 'panic'
+          self.client_min_messages = 'panic'
           value = select_one('SHOW standard_conforming_strings', 'SCHEMA')['standard_conforming_strings']
-          @standard_conforming_strings = (value == "on")
+          @standard_conforming_strings = ( value == "on" )
         rescue
           @standard_conforming_strings = :unsupported
         ensure
-          self.client_min_messages = old
+          self.client_min_messages = client_min_messages
         end
       end
+      @standard_conforming_strings == true # return false if :unsupported
+    end
 
-      # Return false if unsupported.
-      @standard_conforming_strings == true
+    # Does PostgreSQL support migrations?
+    def supports_migrations? # :nodoc:
+      true
     end
 
+    # Does PostgreSQL support finding primary key on non-Active Record tables?
+    def supports_primary_key? # :nodoc:
+      true
+    end
+    
     # Does PostgreSQL support standard conforming strings?
-    def supports_standard_conforming_strings?
+    def supports_standard_conforming_strings? # :nodoc:
       standard_conforming_strings?
       @standard_conforming_strings != :unsupported
     end
 
-    def supports_hex_escaped_bytea?
+    def supports_hex_escaped_bytea? # :nodoc:
       postgresql_version >= 90000
     end
 
-    def supports_insert_with_returning?
+    def supports_insert_with_returning? # :nodoc:
       postgresql_version >= 80200
     end
 
-    def supports_ddl_transactions?
+    def supports_ddl_transactions? # :nodoc:
       true
     end
 
-    def supports_savepoints?
+    def supports_index_sort_order? # :nodoc:
       true
     end
-
+    
+    def supports_savepoints? # :nodoc:
+      true
+    end
+    
     def create_savepoint
       execute("SAVEPOINT #{current_savepoint_name}")
     end
@@ -364,10 +377,8 @@ module ::ArJdbc
       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
+          sql = to_sql(sql, binds)
+          return select_value("#{sql} RETURNING #{quote_column_name(pk)}")
         end
       end
 
@@ -390,14 +401,8 @@ module ::ArJdbc
       end
       id_value
     end
-
-    def primary_key(table)
-      pk_and_sequence = pk_and_sequence_for(table)
-      pk_and_sequence && pk_and_sequence.first
-    end
-
-    # taken from rails postgresql adapter
-    # https://github.com/gfmurphy/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L611
+    
+    # taken from rails postgresql_adapter.rb
     def sql_for_insert(sql, pk, id_value, sequence_name, binds)
       unless pk
         table_ref = extract_table_ref_from_insert_sql(sql)
@@ -408,6 +413,11 @@ module ::ArJdbc
 
       [sql, binds]
     end
+    
+    def primary_key(table)
+      pk_and_sequence = pk_and_sequence_for(table)
+      pk_and_sequence && pk_and_sequence.first
+    end
 
     def pg_columns(table_name, name=nil)
       column_definitions(table_name).map do |row|
@@ -502,7 +512,7 @@ module ::ArJdbc
     def create_database(name, options = {})
       options = options.with_indifferent_access
       create_query = "CREATE DATABASE \"#{name}\" ENCODING='#{options[:encoding] || 'utf8'}'"
-      create_query += options.symbolize_keys.sum do |key, value|
+      create_query += options.symbolize_keys.sum('') do |key, value|
         case key
           when :owner
             " OWNER = \"#{value}\""
@@ -548,7 +558,7 @@ module ::ArJdbc
       ENV['PGHOST']     = @config[:host] if @config[:host]
       ENV['PGPORT']     = @config[:port].to_s if @config[:port]
       ENV['PGPASSWORD'] = @config[:password].to_s if @config[:password]
-      search_path = "--schema=#{schema_search_path}" if schema_search_path
+      search_path = "--schema=#{@config[:schema_search_path]}" if @config[:schema_search_path]
 
       @connection.connection.close
       begin
@@ -643,10 +653,16 @@ module ::ArJdbc
         "'#{value}'"
       when String
         case column.sql_type
-        when 'bytea' then "E'#{escape_bytea(value)}'::bytea"
+        when 'bytea' then "E'#{escape_bytea(value)}'::bytea" # "'#{escape_bytea(value)}'"
         when 'xml'   then "xml '#{quote_string(value)}'"
         when /^bit/
           case value
+          # NOTE: as reported with #60 this is not quite "right" :
+          #  "0103" will be treated as hexadecimal string
+          #  "0102" will be treated as hexadecimal string
+          #  "0101" will be treated as binary string
+          #  "0100" will be treated as binary string
+          # ... but is kept due Rails compatibility
           when /^[01]*$/      then "B'#{value}'" # Bit-string notation
           when /^[0-9A-F]*$/i then "X'#{value}'" # Hexadecimal notation
           end
@@ -660,30 +676,29 @@ module ::ArJdbc
 
     # Quotes a string, escaping any ' (single quote) and \ (backslash)
     # characters.
-    def quote_string(s)
-      quoted = s.gsub(/'/, "''")
-      if !standard_conforming_strings?
+    def quote_string(string)
+      quoted = string.gsub("'", "''")
+      unless standard_conforming_strings?
         quoted.gsub!(/\\/, '\&\&')
       end
-
       quoted
     end
 
-    def escape_bytea(s)
-      if s
+    def escape_bytea(string)
+      if string
         if supports_hex_escaped_bytea?
-          "\\\\x#{s.unpack("H*")[0]}"
+          "\\\\x#{string.unpack("H*")[0]}"
         else
           result = ''
-          s.each_byte { |c| result << sprintf('\\\\%03o', c) }
+          string.each_byte { |c| result << sprintf('\\\\%03o', c) }
           result
         end
       end
     end
-
+    
     def quote_table_name(name)
       schema, name_part = extract_pg_identifier_from_name(name.to_s)
-
+        
       unless name_part
         quote_column_name(schema)
       else
@@ -691,11 +706,11 @@ module ::ArJdbc
         "#{quote_column_name(schema)}.#{quote_column_name(table_name)}"
       end
     end
-
+    
     def quote_column_name(name)
       %("#{name.to_s.gsub("\"", "\"\"")}")
     end
-
+    
     def quoted_date(value) #:nodoc:
       if value.acts_like?(:time) && value.respond_to?(:usec)
         "#{super}.#{sprintf("%06d", value.usec)}"
@@ -704,7 +719,7 @@ module ::ArJdbc
       end
     end
 
-    def disable_referential_integrity(&block) #:nodoc:
+    def disable_referential_integrity # :nodoc:
       execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
       yield
     ensure
@@ -785,17 +800,22 @@ module ::ArJdbc
 
     # 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
-
-      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.")
+      case type.to_sym
+      when :integer
+        return 'integer' unless limit
+        case limit.to_i
+          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
+      when :binary
+        super(type, nil, nil, nil)
+      else
+        super
       end
     end
-
+    
     def tables(name = nil)
       exec_query(<<-SQL, 'SCHEMA').map { |row| row["tablename"] }
           SELECT tablename
@@ -886,11 +906,12 @@ module ::ArJdbc
       end
     end
 
-    # from rails postgresl_adapter
-    def extract_table_ref_from_insert_sql(sql)
+    # taken from rails postgresql_adapter.rb
+    def extract_table_ref_from_insert_sql(sql) # :nodoc:
       sql[/into\s+([^\(]*).*values\s*\(/i]
       $1.strip if $1
     end
+    
   end
 end
 
@@ -926,6 +947,7 @@ module ActiveRecord::ConnectionAdapters
 
   class PostgreSQLAdapter < JdbcAdapter
     include ArJdbc::PostgreSQL
+    include ArJdbc::PostgreSQL::ExplainSupport
 
     def initialize(*args)
       super
@@ -957,5 +979,31 @@ module ActiveRecord::ConnectionAdapters
     end
 
     alias_chained_method :columns, :query_cache, :pg_columns
+    
+    # some QUOTING caching :
+    
+    @@quoted_table_names = {}
+    
+    def quote_table_name(name)
+      unless quoted = @@quoted_table_names[name]
+        quoted = super
+        @@quoted_table_names[name] = quoted.freeze
+      end
+      quoted
+    end
+    
+    @@quoted_column_names = {}
+    
+    def quote_column_name(name)
+      unless quoted = @@quoted_column_names[name]
+        quoted = super
+        @@quoted_column_names[name] = quoted.freeze
+      end
+      quoted
+    end
+    
   end
 end
+
+# Don't need to load native postgres adapter
+$LOADED_FEATURES << 'active_record/connection_adapters/postgresql_adapter.rb'

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -1,11 +1,13 @@
-# Don't need to load native postgres adapter
-$LOADED_FEATURES << "active_record/connection_adapters/postgresql_adapter.rb"
-
 class ActiveRecord::Base
   class << self
     def postgresql_connection(config)
-      require 'active_record/connection_adapters/jdbcpostgresql_adapter'
+      begin
+        require 'jdbc/postgres'
+        ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
+      rescue LoadError # assuming driver.jar is on the class-path
+      end
 
+      config[:username] ||= Java::JavaLang::System.get_property("user.name")
       config[:host] ||= "localhost"
       config[:port] ||= 5432
       config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"

data/lib/arjdbc/postgresql/explain_support.rb

@@ -0,0 +1,55 @@
+module ::ArJdbc
+  module PostgreSQL
+    module ExplainSupport
+      def supports_explain?
+        true
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN #{to_sql(arel, binds)}"
+        raw_result = execute(sql, "EXPLAIN", binds)
+        # TODO we should refactor to exce_query once it returns Result ASAP :
+        keys = raw_result[0] ? raw_result[0].keys : {}
+        rows = raw_result.map { |hash| hash.values }
+        ExplainPrettyPrinter.new.pp ActiveRecord::Result.new(keys, rows)
+      end
+
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+        # PostgreSQL shell:
+        #
+        # QUERY PLAN
+        # ------------------------------------------------------------------------------
+        # Nested Loop Left Join (cost=0.00..37.24 rows=8 width=0)
+        # Join Filter: (posts.user_id = users.id)
+        # -> Index Scan using users_pkey on users (cost=0.00..8.27 rows=1 width=4)
+        # Index Cond: (id = 1)
+        # -> Seq Scan on posts (cost=0.00..28.88 rows=8 width=4)
+        # Filter: (posts.user_id = 1)
+        # (6 rows)
+        #
+        def pp(result)
+          header = result.columns.first
+          lines = result.rows.map(&:first)
+
+          # We add 2 because there's one char of padding at both sides, note
+          # the extra hyphens in the example above.
+          width = [header, *lines].map(&:length).max + 2
+
+          pp = []
+
+          pp << header.center(width).rstrip
+          pp << '-' * width
+
+          pp += lines.map {|line| " #{line}"}
+
+          nrows = result.rows.length
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          pp << "(#{nrows} #{rows_label})"
+
+          pp.join("\n") + "\n"
+        end
+      end
+    end
+  end
+end