activerecord 4.1.16 → 4.2.0.beta1

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

@@ -1,12 +1,12 @@
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
-      module ReferentialIntegrity
-        def supports_disable_referential_integrity? #:nodoc:
+    module PostgreSQL
+      module ReferentialIntegrity # :nodoc:
+        def supports_disable_referential_integrity? # :nodoc:
           true
         end
 
-        def disable_referential_integrity #:nodoc:
+        def disable_referential_integrity # :nodoc:
           if supports_disable_referential_integrity?
             begin
               execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))

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

@@ -0,0 +1,154 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      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 citext(name, options = {})
+          column(name, :citext, options)
+        end
+
+        def point(name, options = {})
+          column(name, :point, options)
+        end
+
+        def bit(name, options)
+          column(name, :bit, options)
+        end
+
+        def bit_varying(name, options)
+          column(name, :bit_varying, options)
+        end
+
+        def money(name, options)
+          column(name, :money, options)
+        end
+      end
+
+      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+        attr_accessor :array
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        # Defines the primary key field.
+        # Use of the native PostgreSQL UUID type is supported, and can be used
+        # by defining your tables as such:
+        #
+        #   create_table :stuffs, id: :uuid do |t|
+        #     t.string :content
+        #     t.timestamps
+        #   end
+        #
+        # By default, this will use the +uuid_generate_v4()+ function from the
+        # +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+:
+        #
+        #   create_table :stuffs, id: false do |t|
+        #     t.primary_key :id, :uuid, default: nil
+        #     t.uuid :foo_id
+        #     t.timestamps
+        #   end
+        #
+        # 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.
+        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
+
+        def column(name, type = nil, options = {})
+          super
+          column = self[name]
+          column.array = options[:array]
+
+          self
+        end
+
+        private
+
+          def create_column_definition(name, type)
+            PostgreSQL::ColumnDefinition.new name, type
+          end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLAdapter < AbstractAdapter
+    module PostgreSQL
       class SchemaCreation < AbstractAdapter::SchemaCreation
         private
 
         def visit_AddColumn(o)
-          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale)
           sql = "ADD COLUMN #{quote_column_name(o.name)} #{sql_type}"
           add_column_options!(sql, column_options(o))
         end
@@ -31,10 +31,14 @@ module ActiveRecord
             super
           end
         end
-      end
 
-      def schema_creation
-        SchemaCreation.new self
+        def type_for_column(column)
+          if column.array
+            @conn.lookup_cast_type("#{column.sql_type}[]")
+          else
+            super
+          end
+        end
       end
 
       module SchemaStatements
@@ -56,8 +60,8 @@ module ActiveRecord
         def create_database(name, options = {})
           options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
 
-          option_string = options.inject("") do |memo, (key, value)|
-            memo += case key
+          option_string = options.sum do |key, value|
+            case key
             when :owner
               " OWNER = \"#{value}\""
             when :template
@@ -101,19 +105,16 @@ module ActiveRecord
         # If the schema is not specified as part of +name+ then it will only find tables within
         # the current schema search path (regardless of permissions to access tables in other schemas)
         def table_exists?(name)
-          schema, table = Utils.extract_schema_and_table(name.to_s)
-          return false unless table
-
-          binds = [[nil, table]]
-          binds << [nil, schema] if schema
+          name = Utils.extract_schema_qualified_name(name.to_s)
+          return false unless name.identifier
 
           exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
               SELECT COUNT(*)
               FROM pg_class c
               LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relkind in ('v','r')
-              AND c.relname = '#{table.gsub(/(^"|"$)/,'')}'
-              AND n.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
+              WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+              AND c.relname = '#{name.identifier}'
+              AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
           SQL
         end
 
@@ -185,13 +186,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 = get_oid_type(oid.to_i, fmod.to_i, column_name)
-            PostgreSQLColumn.new(column_name, default, oid, type, notnull == 'f')
+            oid = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
+            default_value = extract_value_from_default(oid, default)
+            default_function = extract_default_function(default_value, default)
+            new_column(column_name, default_value, oid, type, notnull == 'f', default_function)
           end
         end
 
-        def column_for(table_name, column_name) #:nodoc:
-          columns(table_name).detect { |c| c.name == column_name.to_s }
+        def new_column(name, default, cast_type, sql_type = nil, null = true, default_function = nil) # :nodoc:
+          PostgreSQLColumn.new(name, default, cast_type, sql_type, null, default_function)
         end
 
         # Returns the current database name.
@@ -278,9 +281,9 @@ module ActiveRecord
         def default_sequence_name(table_name, pk = nil) #:nodoc:
           result = serial_sequence(table_name, pk || 'id')
           return nil unless result
-          result.split('.').last
+          Utils.extract_schema_qualified_name(result)
         rescue ActiveRecord::StatementInvalid
-          "#{table_name}_#{pk || 'id'}_seq"
+          PostgreSQL::Name.new(nil, "#{table_name}_#{pk || 'id'}_seq")
         end
 
         def serial_sequence(table, column)
@@ -317,24 +320,27 @@ module ActiveRecord
           # First try looking for a sequence with a dependency on the
           # given table's primary key.
           result = query(<<-end_sql, 'SCHEMA')[0]
-            SELECT attr.attname, seq.relname
+            SELECT attr.attname, nsp.nspname, seq.relname
             FROM pg_class      seq,
                  pg_attribute  attr,
                  pg_depend     dep,
-                 pg_constraint cons
+                 pg_constraint cons,
+                 pg_namespace  nsp
             WHERE seq.oid           = dep.objid
               AND seq.relkind       = 'S'
               AND attr.attrelid     = dep.refobjid
               AND attr.attnum       = dep.refobjsubid
               AND attr.attrelid     = cons.conrelid
               AND attr.attnum       = cons.conkey[1]
+              AND seq.relnamespace  = nsp.oid
               AND cons.contype      = 'p'
+              AND dep.classid       = 'pg_class'::regclass
               AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
           end_sql
 
           if result.nil? or result.empty?
             result = query(<<-end_sql, 'SCHEMA')[0]
-              SELECT attr.attname,
+              SELECT attr.attname, nsp.nspname,
                 CASE
                   WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
                   WHEN split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2) ~ '.' THEN
@@ -346,13 +352,19 @@ module ActiveRecord
               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])
+              JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
               WHERE t.oid = '#{quote_table_name(table)}'::regclass
                 AND cons.contype = 'p'
                 AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate'
             end_sql
           end
 
-          [result.first, result.last]
+          pk = result.shift
+          if result.last
+            [pk, PostgreSQL::Name.new(*result)]
+          else
+            [pk, nil]
+          end
         rescue
           nil
         end
@@ -371,8 +383,8 @@ module ActiveRecord
         end
 
         # Renames a table.
-        # Also renames a table's primary key sequence if the sequence name matches the
-        # Active Record default.
+        # Also renames a table's primary key sequence if the sequence name exists and
+        # matches the Active Record default.
         #
         # Example:
         #   rename_table('octopuses', 'octopi')
@@ -380,12 +392,9 @@ module ActiveRecord
           clear_cache!
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
           pk, seq = pk_and_sequence_for(new_name)
-          if seq == "#{table_name}_#{pk}_seq"
+          if seq && seq.identifier == "#{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)
@@ -414,8 +423,16 @@ module ActiveRecord
         def change_column_default(table_name, column_name, default)
           clear_cache!
           column = column_for(table_name, column_name)
+          return unless column
 
-          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT #{quote_default_value(default, column)}" if column
+          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
 
         def change_column_null(table_name, column_name, null, default = nil)
@@ -447,6 +464,42 @@ module ActiveRecord
           execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
         end
 
+        def foreign_keys(table_name)
+          fk_info = select_all <<-SQL.strip_heredoc
+            SELECT t2.relname 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
+          SQL
+
+          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
+
+        def extract_foreign_key_action(specifier) # :nodoc:
+          case specifier
+          when 'c'; :cascade
+          when 'n'; :nullify
+          when 'r'; :restrict
+          end
+        end
+
         def index_name_length
           63
         end
@@ -496,8 +549,7 @@ module ActiveRecord
               # Convert Arel node to string
               s = s.to_sql unless s.is_a?(String)
               # Remove any ASC/DESC modifiers
-              s.gsub(/\s+(?:ASC|DESC)\b/i, '')
-               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
+              s.gsub(/\s+(?:ASC|DESC)?\s*(?:NULLS\s+(?:FIRST|LAST)\s*)?/i, '')
             }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
           [super, *order_columns].join(', ')

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

@@ -0,0 +1,66 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      # Value Object to hold a schema qualified name.
+      # This is usually the name of a PostgreSQL relation but it can also represent
+      # schema qualified type names. +schema+ and +identifier+ are unquoted to prevent
+      # double quoting.
+      class Name # :nodoc:
+        SEPARATOR = "."
+        attr_reader :schema, :identifier
+
+        def initialize(schema, identifier)
+          @schema, @identifier = unquote(schema), unquote(identifier)
+        end
+
+        def to_s
+          parts.join SEPARATOR
+        end
+
+        def quoted
+          parts.map { |p| PGconn.quote_ident(p) }.join SEPARATOR
+        end
+
+        def ==(o)
+          o.class == self.class && o.parts == parts
+        end
+        alias_method :eql?, :==
+
+        def hash
+          parts.hash
+        end
+
+        protected
+          def unquote(part)
+            return unless part
+            part.gsub(/(^"|"$)/,'')
+          end
+
+          def parts
+            @parts ||= [@schema, @identifier].compact
+          end
+      end
+
+      module Utils # :nodoc:
+        extend self
+
+        # Returns an instance of <tt>ActiveRecord::ConnectionAdapters::PostgreSQL::Name</tt>
+        # extracted from +string+.
+        # +schema+ is nil if not specified in +string+.
+        # +schema+ and +identifier+ exclude surrounding quotes (regardless of whether provided in +string+)
+        # +string+ supports the range of schema/table references understood by PostgreSQL, for example:
+        #
+        # * <tt>table_name</tt>
+        # * <tt>"table.name"</tt>
+        # * <tt>schema_name.table_name</tt>
+        # * <tt>schema_name."table.name"</tt>
+        # * <tt>"schema_name".table_name</tt>
+        # * <tt>"schema.name"."table name"</tt>
+        def extract_schema_qualified_name(string)
+          table, schema = string.scan(/[^".\s]+|"[^"]*"/)[0..1].reverse
+          PostgreSQL::Name.new(schema, table)
+        end
+      end
+    end
+  end
+end