Ticket #8049: postgresql_adapter.diff

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -2 +2 @@
-
-module ActiveRecord
-  class Base
-
- # :nodoc:
- 'postgres'
+.
+
+('postgres')
-
-      config = config.symbolize_keys
-      host     = config[:host]
@@ -12 +12 @@
-      username = config[:username].to_s
-      password = config[:password].to_s
-
-      min_messages = config[:min_messages]
-
-      if config.has_key?(:database)
-        database = config[:database]
-      else
- ArgumentError, "No database specified. Missing argument: database."
+(ArgumentError, 'No database specified. Missing argument: database.')
-      end
-
-
-
-
+
+
+
+
+
-
-
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    end
-  end
-
-
-
-
+
+
-    #
-    # Options:
-    #
@@ -48 +222 @@
-    # * <tt>:min_messages</tt> -- An optional client min messages that is using in a SET client_min_messages TO <min_messages> call on connection.
-    # * <tt>:allow_concurrency</tt> -- If true, use async query methods so Ruby threads don't deadlock; otherwise, use blocking query methods.
-    class PostgreSQLAdapter < AbstractAdapter
+      # Returns 'PostgreSQL' as adapter name for identification purposes.
-      def adapter_name
-        'PostgreSQL'
-      end
-
-
+
+
-        super(connection, logger)
-fig =
+nection_parameters, @config = connection_parameters,
-
-
-
-
-
+
-      end
-
-Is this connection alive and ready for queries?
+Returns if this connection is alive and ready for queries.
-      def active?
-        if @connection.respond_to?(:status)
-          @connection.status == PGconn::CONNECTION_OK
-        else
-
+
+
-          true
-        end
- is available
+ection is available.
-      rescue PGError, NoMethodError
-        false
-      end
-
- then reopen
+s and then reopens
-      def reconnect!
-        # TODO: postgres-pr doesn't have PGconn#reset.
-        if @connection.respond_to?(:reset)
-          @connection.reset
-          configure_connection
+        else
+          disconnect!
+          connect
-        end
-      end
-
+      # Closes the connection.
-      def disconnect!
-        # Both postgres and postgres-pr respond to :close
-        @connection.close rescue nil
-      end
-
-
+ #:nodoc:
-        {
-"serial primary key"
-"character varying"
-"text"
-"integer"
-"float"
-"decimal"
-"timestamp"
-"timestamp"
-"time"
-"date"
-"bytea"
-"boolean"
+'serial PRIMARY KEY'
+'character varying'
+'text'
+'integer'
+'float'
+'decimal'
+'timestamp'
+'timestamp'
+'time'
+'date'
+'bytea'
+'boolean'
-        }
-      end
-
+      # Returns true to indicate that PostgreSQL supports migrations.
-      def supports_migrations?
-        true
-      end
-
+      # Returns the configured supported identifier length supported by PostgreSQL,
+      # or report the default of 63 on PostgreSQL 7.
-      def table_alias_length
-63
+@table_alias_length ||= (postgresql_version >= 80000 ? query('SHOW max_identifier_length')[0][0].to_i : 63)
-      end
-
-      # QUOTING ==================================================
-
-
+
+
-        if value.kind_of?(String) && column && column.type == :binary
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else
-          super
-        end
-      end
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        %("#{name}")
-      end
-
-
-
+
+
+
-        if value.acts_like?(:time) && value.respond_to?(:usec)
-          "#{super}.#{sprintf("%06d", value.usec)}"
-        else
@@ -137 +349 @@
-        end
-      end
-
-
-      # DATABASE STATEMENTS ======================================
-
-
+
+
-        execute(sql, name)
-" "
+' '
-        id_value || last_insert_id(table, sequence_name || default_sequence_name(table, pk))
-      end
-
+      # Queries the database and returns the results in an Array or nil otherwise.
-      def query(sql, name = nil) #:nodoc:
-        log(sql, name) do
-          if @async
@@ -156 +369 @@
-        end
-      end
-
-
+
+
+
-        log(sql, name) do
-          if @async
-            @connection.async_exec(sql)
@@ -166 +381 @@
-        end
-      end
-
-
+
+
-        execute(sql, name).cmdtuples
-      end
-
-
-
+
+
+
-      end
-
-
-
+
+
+
-      end
-
-
-
+
+
+
-      end
-
-      # SCHEMA STATEMENTS ========================================
-
- the list of all tables in the schema search path
- #:nodoc:
+s the list of all tables in the schema search path or a specified schema
+
-        schemas = schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
-        query(<<-SQL, name).map { |row| row[0] }
-          SELECT tablename
@@ -194 +413 @@
-        SQL
-      end
-
-
+
+
-        result = query(<<-SQL, name)
-          SELECT i.relname, d.indisunique, a.attname
-            FROM pg_class t, pg_class i, pg_index d, pg_attribute a
@@ -217 +437 @@
-
-        result.each do |row|
-          if current_index != row[0]
-"t"
+'t'
-            current_index = row[0]
-          end
-
@@ -227 +447 @@
-        indexes
-      end
-
-
-
-
-
+
+
+
+
+
-        end
-      end
-
-
-
-
-
+
+
+
+
+
+
-        if schema_csv
- "SET search_path TO #{schema_csv}"
-nil
+("SET search_path TO #{schema_csv}")
+schema_csv
-        end
-      end
-
-
+
+
-        @schema_search_path ||= query('SHOW search_path')[0][0]
-      end
-
-
+
+
-        default_pk, default_seq = pk_and_sequence_for(table_name)
-        default_seq || "#{table_name}_#{pk || default_pk || 'id'}_seq"
-      end
-
-sequence to the max value of the table's pk if present
-
-and
+the sequence of a table's primary key to the maximum value
+ #:nodoc:
+&&
-          default_pk, default_sequence = pk_and_sequence_for(table)
-          pk ||= default_pk
-          sequence ||= default_sequence
-        end
-        if pk
-          if sequence
- <<-end_sql, 'Reset sequence'
+(<<-end_sql, 'Reset sequence')
-              SELECT setval('#{sequence}', (SELECT COALESCE(MAX(#{pk})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table}), false)
-            end_sql
-          else
- "#{table} has primary key #{pk} with no default sequence"
+("#{table} has primary key #{pk} with no default sequence")
-          end
-        end
-      end
-
-Find a table's primary key and
-
+Returns a table's primary key and belonging
+ #:nodoc:
-        # First try looking for a sequence with a dependency on the
-        # given table's primary key.
-K
-name.nspname, 
+rimary key
+
-          FROM pg_class      seq,
-               pg_attribute  attr,
-               pg_depend     dep,
-               pg_namespace  name,
-               pg_constraint cons
-          WHERE seq.oid           = dep.objid
-            AND seq.relnamespace  = name.oid
-            AND seq.relkind       = 'S'
-            AND attr.attrelid     = dep.refobjid
-            AND attr.attnum       = dep.refobjsubid
@@ -293 +517 @@
-            AND dep.refobjid      = '#{table}'::regclass
-        end_sql
-
-or
+||
-          # If that fails, try parsing the primary key's default value.
-          # Support the 7.x and 8.0 nextval('foo'::text) as well as
-          # the 8.1+ nextval('foo'::regclass).
-
-
-
+
+
-            FROM pg_class       t
-            JOIN pg_namespace   name ON (t.relnamespace = name.oid)
-            JOIN pg_attribute   attr ON (t.oid = attrelid)
-            JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
-            JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
@@ -310 +532 @@
-              AND def.adsrc ~* 'nextval'
-          end_sql
-        end
-
-We cannot qualify unqualified sequences, as rails doesn't qualify any table access, using the search path
+
+[primary_key, sequence]
-        [result.first, result.last]
-      rescue
-        nil
-      end
-
+      # Renames a table.
-      def rename_table(name, new_name)
- "ALTER TABLE #{name} RENAME TO #{new_name}"
+("ALTER TABLE #{name} RENAME TO #{new_name}")
-      end
-
+      # Adds a column to a table.
-      def add_column(table_name, column_name, type, options = {})
-        default = options[:default]
-        notnull = options[:null] == false
@@ -341 +565 @@
-        end
-      end
-
-
+
+
-        begin
- "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+("ALTER TABLE #{table_name} ALTER COLUMN #{column_name} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}")
-        rescue ActiveRecord::StatementInvalid
-G7, so we
+ostgreSQL 7, so we have to
-          begin_db_transaction
-          add_column(table_name, "#{column_name}_ar_tmp", type, options)
- "UPDATE #{table_name} SET #{column_name}_ar_tmp = CAST(#{column_name} AS #{type_to_sql(type, options[:limit], options[:precision], options[:scale])})"
+("UPDATE #{table_name} SET #{column_name}_ar_tmp = CAST(#{column_name} AS #{type_to_sql(type, options[:limit], options[:precision], options[:scale])})")
-          remove_column(table_name, column_name)
-          rename_column(table_name, "#{column_name}_ar_tmp", column_name)
-          commit_db_transaction
@@ -359 +584 @@
-        end
-      end
-
-
-
+
+
+
-      end
-
-
-
+
+
+
-      end
-
-
-
+
+
+
-      end
-
-
+
+
-        return super unless type.to_s == 'integer'
-
-        if limit.nil? || limit == 4
@@ -382 +611 @@
-          'bigint'
-        end
-      end
-
-
+
+Returns a 
-      #
-      # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
-      # requires that the ORDER BY include the distinct column.
-      #
-      #   distinct("posts.id", "posts.created_at desc")
-
+ #:nodoc:
-        return "DISTINCT #{columns}" if order_by.blank?
-
-c
-asc/desc modifiers
+C
+ASC/DESC modifiers.
-        order_columns = order_by.split(',').collect { |s| s.split.first }
- &:blank?
+(&:blank?)
-        order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
-
-r
-
+R
+.
-        sql = "DISTINCT ON (#{columns}) #{columns}, "
-        sql << order_columns * ', '
-      end
-
-
- 
+
+Returns a 
+
-      # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON, so we work around this
-      # by wrapping the sql as a sub-select and ordering in that query.
-
+ #:nodoc:
-        return sql if options[:order].blank?
-
+
-        order = options[:order].split(',').collect { |s| s.strip }.reject(&:blank?)
-        order.map! { |s| 'DESC' if s =~ /\bdesc$/i }
-        order = order.zip((0...order.size).to_a).map { |s,i| "id_list.alias_#{i} #{s}" }.join(', ')
-
- "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}"
+
+("SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}")
-      end
-
+      protected
+        # Returns the version of the connected PostgreSQL version.
+        def postgresql_version
+          @postgresql_version ||=
+            if @connection.respond_to?(:server_version)
+              @connection.server_version
+            else
+              # Mimic PGconn.server_version behavior
+              begin
+                query('SELECT version()')[0][0] =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
+                ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+              rescue
+                0
+              end
+            end
+        end
+
-      private
-
-
-
-
+
+
-
+        # Connects to a PostgreSQL server and sets up the adapter depending on the
+        # connected server's characteristics.
+        def connect
+          @connection = PGconn.connect(*@connection_parameters)
+          PGconn.translate_results = false if PGconn.respond_to?(:translate_results=)
+
+          # Ignore async_exec and async_query when using postgres-pr.
+          @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
+
+          # Use escape string syntax if available. We cannot do this lazily when encountering
+          # the first string, because that could then break any transactions in progress.
+          # See: http://www.postgresql.org/docs/current/static/runtime-config-compatible.html
+          begin
+            execute('SHOW standard_conforming_strings')
+            self.class.instance_eval do
+              define_method(:quoted_string_prefix) { 'E' }
+            end
+          rescue ActiveRecord::StatementInvalid
+            # If PostgreSQL doesn't know the standard_conforming_strings parameter then it doesn't
+            # support escape string syntax. Don't override the inherited quoted_string_prefix.
+          end
+
+          # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
+          # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
+          # should know about this but can't detect it there, so deal with it here.
+          money_precision = (postgresql_version >= 80300) ? 19 : 10
+          PostgreSQLColumn.module_eval(<<-end_eval)
+            def extract_precision(sql_type)
+              if sql_type =~ /^money$/
+                #{money_precision}
+              else
+                super
+              end
+            end
+          end_eval
+
+          configure_connection
+        end
+
+        # Configures the encoding, verbosity, and schema search path of the connection.
+        # This is called by #connect and should not be called manually.
-        def configure_connection
-          if @config[:encoding]
-
+
+
+
+
+
-          end
-          if @config[:min_messages]
-            execute("SET client_min_messages TO '#{@config[:min_messages]}'")
-          end
+          self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
-        end
-
-
-
+
+
+
-        end
-
+        # Executes a SELECT query and returns the results, performing any data type
+        # conversions that require to be performed here instead of in PostgreSQLColumn.
-        def select(sql, name = nil)
-          res = execute(sql, name)
-          results = res.result
@@ -445 +738 @@
-            fields = res.fields
-            results.each do |row|
-              hashed_row = {}
-
-
+l
+l
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                end
-
-
+l
-              end
-              rows << hashed_row
-            end
@@ -464 +767 @@
-          return rows
-        end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-        #
-        # The underlying query is roughly:
-        #  SELECT column.name, column.type, default.value
@@ -530 +785 @@
-        # 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
-
- <<-end_sql
+ #:nodoc:
+(<<-end_sql)
-            SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc, a.attnotnull
-              FROM pg_attribute a LEFT JOIN pg_attrdef d
-
+
+
-             WHERE a.attrelid = '#{table_name}'::regclass
-
+
+
-             ORDER BY a.attnum
-          end_sql
-        end
-
-        # Translate PostgreSQL-specific types into simplified SQL types.
-        # These are special cases; standard types are handled by
-        # ConnectionAdapters::Column#simplified_type.
-        def translate_field_type(field_type)
-          # Match the beginning of field_type since it may have a size constraint on the end.
-          case field_type
-            # PostgreSQL array data types.
-            when /\[\]$/i  then 'string'
-            when /^timestamp/i    then 'datetime'