activerecord 4.0.4 → 4.1.16

data/lib/active_record/connection_adapters/postgresql/oid.rb

@@ -6,10 +6,6 @@ module ActiveRecord
       module OID
         class Type
           def type; end
-
-          def type_cast_for_write(value)
-            value
-          end
         end
 
         class Identity < Type
@@ -31,6 +27,9 @@ module ActiveRecord
         class Bytea < Type
           def type_cast(value)
             return if value.nil?
+            # This is a flawed heuristic, but it avoids truncation;
+            # we really shouldn’t be calling this with already-unescaped values
+            return value if value.dup.force_encoding("BINARY") =~ /\x00/
             PGconn.unescape_bytea value
           end
         end
@@ -141,7 +140,7 @@ module ActiveRecord
             case @subtype
             when :date
               from  = ConnectionAdapters::Column.value_to_date(extracted[:from])
-              from -= 1.day if extracted[:exclude_start]
+              from += 1.day if extracted[:exclude_start]
               to    = ConnectionAdapters::Column.value_to_date(extracted[:to])
             when :decimal
               from  = BigDecimal.new(extracted[:from].to_s)
@@ -152,7 +151,7 @@ module ActiveRecord
               to   = ConnectionAdapters::Column.string_to_time(extracted[:to])
             when :integer
               from = to_integer(extracted[:from]) rescue value ? 1 : 0
-              from -= 1 if extracted[:exclude_start]
+              from += 1 if extracted[:exclude_start]
               to   = to_integer(extracted[:to]) rescue value ? 1 : 0
             else
               return value
@@ -214,9 +213,14 @@ module ActiveRecord
 
         class Float < Type
           def type_cast(value)
-            return if value.nil?
-
-            value.to_f
+            case value
+              when nil;         nil
+              when 'Infinity';  ::Float::INFINITY
+              when '-Infinity'; -::Float::INFINITY
+              when 'NaN';       ::Float::NAN
+            else
+              value.to_f
+            end
           end
         end
 
@@ -229,11 +233,22 @@ module ActiveRecord
         end
 
         class Hstore < Type
+          def type_cast_for_write(value)
+            # roundtrip to ensure uniform uniform types
+            # TODO: This is not an efficient solution.
+            stringified = ConnectionAdapters::PostgreSQLColumn.hstore_to_string(value)
+            type_cast(stringified)
+          end
+
           def type_cast(value)
             return if value.nil?
 
             ConnectionAdapters::PostgreSQLColumn.string_to_hstore value
           end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          end
         end
 
         class Cidr < Type
@@ -245,11 +260,22 @@ module ActiveRecord
         end
 
         class Json < Type
+          def type_cast_for_write(value)
+            # roundtrip to ensure uniform uniform types
+            # TODO: This is not an efficient solution.
+            stringified = ConnectionAdapters::PostgreSQLColumn.json_to_string(value)
+            type_cast(stringified)
+          end
+
           def type_cast(value)
             return if value.nil?
 
             ConnectionAdapters::PostgreSQLColumn.string_to_json value
           end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          end
         end
 
         class TypeMap
@@ -289,17 +315,15 @@ module ActiveRecord
           end
         end
 
-        TYPE_MAP = TypeMap.new # :nodoc:
-
-        # When the PG adapter connects, the pg_type table is queried.  The
+        # When the PG adapter connects, the pg_type table is queried. The
         # key of this hash maps to the `typname` column from the table.
-        # TYPE_MAP is then dynamically built with oids as the key and type
+        # type_map is then dynamically built with oids as the key and type
         # objects as values.
         NAMES = Hash.new { |h,k| # :nodoc:
           h[k] = OID::Identity.new
         }
 
-        # Register an OID type named +name+ with a typcasting object in
+        # Register an OID type named +name+ with a typecasting object in
         # +type+.  +name+ should correspond to the `typname` column in
         # the `pg_type` table.
         def self.register_type(name, type)

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -16,14 +16,15 @@ module ActiveRecord
 
         # Quotes PostgreSQL-specific data types for SQL input.
         def quote(value, column = nil) #:nodoc:
-          return super unless column
+          return super unless column && column.type
 
           sql_type = type_to_sql(column.type, column.limit, column.precision, column.scale)
 
           case value
           when Range
             if /range$/ =~ sql_type
-              "'#{PostgreSQLColumn.range_to_string(value)}'::#{sql_type}"
+              escaped = quote_string(PostgreSQLColumn.range_to_string(value))
+              "'#{escaped}'::#{sql_type}"
             else
               super
             end
@@ -70,8 +71,8 @@ module ActiveRecord
             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
+              when /\A[01]*\Z/      then "B'#{value}'" # Bit-string notation
+              when /\A[0-9A-F]*\Z/i then "X'#{value}'" # Hexadecimal notation
               end
             else
               super
@@ -86,8 +87,11 @@ module ActiveRecord
 
           case value
           when Range
-            return super(value, column) unless /range$/ =~ column.sql_type
-            PostgreSQLColumn.range_to_string(value)
+            if /range$/ =~ column.sql_type
+              PostgreSQLColumn.range_to_string(value)
+            else
+              super(value, column)
+            end
           when NilClass
             if column.array && array_member
               'NULL'
@@ -101,12 +105,21 @@ module ActiveRecord
             when 'point' then PostgreSQLColumn.point_to_string(value)
             when 'json' then PostgreSQLColumn.json_to_string(value)
             else
-              return super(value, column) unless column.array
-              PostgreSQLColumn.array_to_string(value, column, self)
+              if column.array
+                PostgreSQLColumn.array_to_string(value, column, self)
+              else
+                super(value, column)
+              end
             end
           when String
-            return super(value, column) unless 'bytea' == column.sql_type
-            { :value => value, :format => 1 }
+            if 'bytea' == column.sql_type
+              # 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, format: 1 }
+            else
+              super(value, column)
+            end
           when Hash
             case column.sql_type
             when 'hstore' then PostgreSQLColumn.hstore_to_string(value, array_member)
@@ -114,8 +127,11 @@ module ActiveRecord
             else super(value, column)
             end
           when IPAddr
-            return super(value, column) unless ['inet','cidr'].include? column.sql_type
-            PostgreSQLColumn.cidr_to_string(value)
+            if %w(inet cidr).include? column.sql_type
+              PostgreSQLColumn.cidr_to_string(value)
+            else
+              super(value, column)
+            end
           else
             super(value, column)
           end
@@ -167,6 +183,15 @@ module ActiveRecord
           end
           result
         end
+
+        # Does not quote function default values for UUID columns
+        def quote_default_value(value, column) #:nodoc:
+          if column.type == :uuid && value =~ /\(\)/
+            value
+          else
+            quote(value, column)
+          end
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -12,7 +12,7 @@ module ActiveRecord
 
         def visit_ColumnDefinition(o)
           sql = super
-          if o.primary_key? && o.type == :uuid
+          if o.primary_key? && o.type != :primary_key
             sql << " PRIMARY KEY "
             add_column_options!(sql, column_options(o))
           end
@@ -46,7 +46,7 @@ module ActiveRecord
         end
 
         # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
-        # <tt>:encoding</tt>, <tt>:collation</tt>, <tt>:ctype</tt>,
+        # <tt>:encoding</tt> (defaults to utf8), <tt>:collation</tt>, <tt>:ctype</tt>,
         # <tt>:tablespace</tt>, and <tt>:connection_limit</tt> (note that MySQL uses
         # <tt>:charset</tt> while PostgreSQL uses <tt>:encoding</tt>).
         #
@@ -56,8 +56,8 @@ module ActiveRecord
         def create_database(name, options = {})
           options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
 
-          option_string = options.sum do |key, value|
-            case key
+          option_string = options.inject("") do |memo, (key, value)|
+            memo += case key
             when :owner
               " OWNER = \"#{value}\""
             when :template
@@ -185,13 +185,15 @@ module ActiveRecord
         def columns(table_name)
           # Limit, precision, and scale are all handled by the superclass.
           column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
-            oid = OID::TYPE_MAP.fetch(oid.to_i, fmod.to_i) {
-              OID::Identity.new
-            }
+            oid = get_oid_type(oid.to_i, fmod.to_i, column_name)
             PostgreSQLColumn.new(column_name, default, oid, type, notnull == 'f')
           end
         end
 
+        def column_for(table_name, column_name) #:nodoc:
+          columns(table_name).detect { |c| c.name == column_name.to_s }
+        end
+
         # Returns the current database name.
         def current_database
           query('select current_database()', 'SCHEMA')[0][0]
@@ -380,7 +382,10 @@ module ActiveRecord
           pk, seq = pk_and_sequence_for(new_name)
           if seq == "#{table_name}_#{pk}_seq"
             new_seq = "#{new_name}_#{pk}_seq"
+            idx = "#{table_name}_pkey"
+            new_idx = "#{new_name}_pkey"
             execute "ALTER TABLE #{quote_table_name(seq)} RENAME TO #{quote_table_name(new_seq)}"
+            execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
           end
 
           rename_table_indexes(table_name, new_name)
@@ -408,13 +413,16 @@ module ActiveRecord
         # Changes the default value of a table column.
         def change_column_default(table_name, column_name, default)
           clear_cache!
-          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}"
+          column = column_for(table_name, column_name)
+
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote_default_value(default, column)}" if column
         end
 
         def change_column_null(table_name, column_name, null, default = nil)
           clear_cache!
           unless null || default.nil?
-            execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+            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
@@ -484,11 +492,12 @@ module ActiveRecord
         # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
         # requires that the ORDER BY include the distinct column.
         def columns_for_distinct(columns, orders) #:nodoc:
-          order_columns = orders.map{ |s|
+          order_columns = orders.reject(&:blank?).map{ |s|
               # Convert Arel node to string
               s = s.to_sql unless s.is_a?(String)
               # Remove any ASC/DESC modifiers
-              s.gsub(/\s+(ASC|DESC)\s*(NULLS\s+(FIRST|LAST)\s*)?/i, '')
+              s.gsub(/\s+(?:ASC|DESC)\b/i, '')
+               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
             }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
           [super, *order_columns].join(', ')

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -20,8 +20,8 @@ module ActiveRecord
     VALID_CONN_PARAMS = [:host, :hostaddr, :port, :dbname, :user, :password, :connect_timeout,
                          :client_encoding, :options, :application_name, :fallback_application_name,
                          :keepalives, :keepalives_idle, :keepalives_interval, :keepalives_count,
-                         :tty, :sslmode, :requiressl, :sslcert, :sslkey, :sslrootcert, :sslcrl,
-                         :requirepeer, :krbsrvname, :gsslib, :service]
+                         :tty, :sslmode, :requiressl, :sslcompression, :sslcert, :sslkey,
+                         :sslrootcert, :sslcrl, :requirepeer, :krbsrvname, :gsslib, :service]
 
     # Establishes a connection to the database that's used by all Active Record objects
     def postgresql_connection(config)
@@ -96,7 +96,7 @@ module ActiveRecord
             $1
           # Character types
           when /\A\(?'(.*)'::.*\b(?:character varying|bpchar|text)\z/m
-            $1
+            $1.gsub(/''/, "'")
           # Binary data types
           when /\A'(.*)'::bytea\z/m
             $1
@@ -141,6 +141,14 @@ module ActiveRecord
         end
       end
 
+      def type_cast_for_write(value)
+        if @oid_type.respond_to?(:type_cast_for_write)
+          @oid_type.type_cast_for_write(value)
+        else
+          super
+        end
+      end
+
       def type_cast(value)
         return if value.nil?
         return super if encoded?
@@ -148,6 +156,10 @@ module ActiveRecord
         @oid_type.type_cast value
       end
 
+      def accessor
+        @oid_type.accessor
+      end
+
       private
 
         def has_default_function?(default_value, default)
@@ -356,10 +368,10 @@ module ActiveRecord
         #   end
         #
         # By default, this will use the +uuid_generate_v4()+ function from the
-        # +uuid-ossp+ extension, which MUST be enabled on your databse.  To enable
+        # +uuid-ossp+ extension, which MUST be enabled on your database. To enable
         # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
-        # migrations To use a UUID primary key without +uuid-ossp+ enabled, you can
-        # set the +:default+ option to nil:
+        # migrations. To use a UUID primary key without +uuid-ossp+ enabled, you can
+        # set the +:default+ option to +nil+:
         #
         #   create_table :stuffs, id: false do |t|
         #     t.primary_key :id, :uuid, default: nil
@@ -370,11 +382,10 @@ module ActiveRecord
         # You may also pass a different UUID generation function from +uuid-ossp+
         # or another library.
         #
-        # Note that setting the UUID primary key default value to +nil+
-        # will require you to assure that you always provide a UUID value
-        # before saving a record (as primary keys cannot be nil).  This might be
-        # done via the SecureRandom.uuid method and a +before_save+ callback,
-        # for instance.
+        # Note that setting the UUID primary key default value to +nil+ will
+        # require you to assure that you always provide a UUID value before saving
+        # a record (as primary keys cannot be +nil+). This might be done via the
+        # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
         def primary_key(name, type = :primary_key, options = {})
           return super unless type == :uuid
           options[:default] = options.fetch(:default, 'uuid_generate_v4()')
@@ -437,6 +448,7 @@ module ActiveRecord
       include ReferentialIntegrity
       include SchemaStatements
       include DatabaseStatements
+      include Savepoints
 
       # Returns 'PostgreSQL' as adapter name for identification purposes.
       def adapter_name
@@ -561,7 +573,8 @@ module ActiveRecord
           raise "Your version of PostgreSQL (#{postgresql_version}) is too old, please upgrade!"
         end
 
-        initialize_type_map
+        @type_map = OID::TypeMap.new
+        initialize_type_map(type_map)
         @local_tz = execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
         @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
       end
@@ -632,12 +645,6 @@ module ActiveRecord
         true
       end
 
-      # Returns true, since this connection adapter supports savepoints.
-      def supports_savepoints?
-        true
-      end
-
-      # Returns true.
       def supports_explain?
         true
       end
@@ -749,65 +756,92 @@ module ActiveRecord
 
       private
 
+        def type_map
+          @type_map
+        end
+
+        def get_oid_type(oid, fmod, column_name)
+          type_map.fetch(oid, fmod) {
+            warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
+            type_map[oid] = OID::Identity.new
+          }
+        end
+
         def reload_type_map
-          OID::TYPE_MAP.clear
-          initialize_type_map
+          type_map.clear
+          initialize_type_map(type_map)
         end
 
-        def initialize_type_map
+        def add_oid(row, records_by_oid, type_map)
+          return type_map if type_map.key? row['type_elem'].to_i
+
+          if OID.registered_type? row['typname']
+            # this composite type is explicitly registered
+            vector = OID::NAMES[row['typname']]
+          else
+            # use the default for composite types
+            unless type_map.key? row['typelem'].to_i
+              add_oid records_by_oid[row['typelem']], records_by_oid, type_map
+            end
+
+            vector = OID::Vector.new row['typdelim'], type_map[row['typelem'].to_i]
+          end
+
+          type_map[row['oid'].to_i] = vector
+          type_map
+        end
+
+        def initialize_type_map(type_map)
           result = execute('SELECT oid, typname, typelem, typdelim, typinput FROM pg_type', 'SCHEMA')
           leaves, nodes = result.partition { |row| row['typelem'] == '0' }
 
           # populate the leaf nodes
           leaves.find_all { |row| OID.registered_type? row['typname'] }.each do |row|
-            OID::TYPE_MAP[row['oid'].to_i] = OID::NAMES[row['typname']]
+            type_map[row['oid'].to_i] = OID::NAMES[row['typname']]
           end
 
+          records_by_oid = result.group_by { |row| row['oid'] }
+
           arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
 
           # populate composite types
-          nodes.find_all { |row| OID::TYPE_MAP.key? row['typelem'].to_i }.each do |row|
-            if OID.registered_type? row['typname']
-              # this composite type is explicitly registered
-              vector = OID::NAMES[row['typname']]
-            else
-              # use the default for composite types
-              vector = OID::Vector.new row['typdelim'], OID::TYPE_MAP[row['typelem'].to_i]
-            end
-
-            OID::TYPE_MAP[row['oid'].to_i] = vector
+          nodes.each do |row|
+            add_oid row, records_by_oid, type_map
           end
 
           # populate array types
-          arrays.find_all { |row| OID::TYPE_MAP.key? row['typelem'].to_i }.each do |row|
-            array = OID::Array.new  OID::TYPE_MAP[row['typelem'].to_i]
-            OID::TYPE_MAP[row['oid'].to_i] = array
+          arrays.find_all { |row| type_map.key? row['typelem'].to_i }.each do |row|
+            array = OID::Array.new  type_map[row['typelem'].to_i]
+            type_map[row['oid'].to_i] = array
           end
         end
 
         FEATURE_NOT_SUPPORTED = "0A000" #:nodoc:
 
-        def exec_no_cache(sql, binds)
-          @connection.async_exec(sql)
+        def exec_no_cache(sql, name, binds)
+          log(sql, name, binds) { @connection.async_exec(sql, []) }
         end
 
-        def exec_cache(sql, binds)
-          stmt_key = prepare_statement sql
+        def exec_cache(sql, name, binds)
+          stmt_key = prepare_statement(sql)
+          type_casted_binds = binds.map { |col, val|
+            [col, type_cast(val, col)]
+          }
+
+          log(sql, name, type_casted_binds, stmt_key) do
+            @connection.send_query_prepared(stmt_key, type_casted_binds.map { |_, val| val })
+            @connection.block
+            @connection.get_last_result
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          pgerror = e.original_exception
 
-          # Clear the queue
-          @connection.get_last_result
-          @connection.send_query_prepared(stmt_key, binds.map { |col, val|
-            type_cast(val, col)
-          })
-          @connection.block
-          @connection.get_last_result
-        rescue PGError => e
           # Get the PG code for the failure.  Annoyingly, the code for
           # prepared statements whose return value may have changed is
           # FEATURE_NOT_SUPPORTED.  Check here for more details:
           # http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
           begin
-            code = e.result.result_error_field(PGresult::PG_DIAG_SQLSTATE)
+            code = pgerror.result.result_error_field(PGresult::PG_DIAG_SQLSTATE)
           rescue
             raise e
           end
@@ -831,7 +865,13 @@ module ActiveRecord
           sql_key = sql_key(sql)
           unless @statements.key? sql_key
             nextkey = @statements.next_key
-            @connection.prepare nextkey, sql
+            begin
+              @connection.prepare nextkey, sql
+            rescue => e
+              raise translate_exception_class(e, sql)
+            end
+            # Clear the queue
+            @connection.get_last_result
             @statements[sql_key] = nextkey
           end
           @statements[sql_key]
@@ -853,6 +893,12 @@ module ActiveRecord
           PostgreSQLColumn.money_precision = (postgresql_version >= 80300) ? 19 : 10
 
           configure_connection
+        rescue ::PG::Error => error
+          if error.message.include?("does not exist")
+            raise ActiveRecord::NoDatabaseError.new(error.message)
+          else
+            raise error
+          end
         end
 
         # Configures the encoding, verbosity, schema search path, and time zone of the connection.
@@ -949,12 +995,12 @@ module ActiveRecord
         end
 
         def extract_table_ref_from_insert_sql(sql)
-          sql[/into\s+([^\(]*).*values\s*\(/i]
+          sql[/into\s+([^\(]*).*values\s*\(/im]
           $1.strip if $1
         end
 
-        def create_table_definition(name, temporary, options)
-          TableDefinition.new native_database_types, name, temporary, options
+        def create_table_definition(name, temporary, options, as = nil)
+          TableDefinition.new native_database_types, name, temporary, options, as
         end
     end
   end

data/lib/active_record/connection_adapters/schema_cache.rb

@@ -1,4 +1,3 @@
-require 'active_support/deprecation/reporting'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -16,13 +15,8 @@ module ActiveRecord
         prepare_default_proc
       end
 
-      def primary_keys(table_name = nil)
-        if table_name
-          @primary_keys[table_name]
-        else
-          ActiveSupport::Deprecation.warn('call primary_keys with a table name!')
-          @primary_keys.dup
-        end
+      def primary_keys(table_name)
+        @primary_keys[table_name]
       end
 
       # A cached lookup for table existence.
@@ -41,34 +35,19 @@ module ActiveRecord
         end
       end
 
-      def tables(name = nil)
-        if name
-          @tables[name]
-        else
-          ActiveSupport::Deprecation.warn('call tables with a name!')
-          @tables.dup
-        end
+      def tables(name)
+        @tables[name]
       end
 
       # Get the columns for a table
-      def columns(table = nil)
-        if table
-          @columns[table]
-        else
-          ActiveSupport::Deprecation.warn('call columns with a table name!')
-          @columns.dup
-        end
+      def columns(table)
+        @columns[table]
       end
 
       # Get the columns for a table as a hash, key is the column name
       # value is the column object.
-      def columns_hash(table = nil)
-        if table
-          @columns_hash[table]
-        else
-          ActiveSupport::Deprecation.warn('call columns_hash with a table name!')
-          @columns_hash.dup
-        end
+      def columns_hash(table)
+        @columns_hash[table]
       end
 
       # Clears out internal caches