# module ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements

### Public Instance Methods

client_min_messages() click to toggle source

Returns the current client message level.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 251
    def client_min_messages
      query_value("SHOW client_min_messages", "SCHEMA")
    end

client_min_messages=(level) click to toggle source

Set the client message level.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 256
    def client_min_messages=(level)
      execute("SET client_min_messages TO '#{level}'", "SCHEMA")
    end

collation() click to toggle source

Returns the current database collation.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 203
    def collation
      query_value("SELECT datcollate FROM pg_database WHERE datname = current_database()", "SCHEMA")
    end

create_database(name, options = {}) click to toggle source

Create a new PostgreSQL database. Options include `:owner`, `:template`, `:encoding` (defaults to utf8), `:collation`, `:ctype`, `:tablespace`, and `:connection_limit` (note that MySQL uses `:charset` while PostgreSQL uses `:encoding`).

Example:

    create_database config[:database], config
    create_database 'foo_development', encoding: 'unicode'

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 22
    def create_database(name, options = {})
      options = { encoding: "utf8" }.merge!(options.symbolize_keys)

      option_string = options.inject("") do |memo, (key, value)|
        memo += case key
                when :owner
                  " OWNER = \"#{value}\""
                when :template
                  " TEMPLATE = \"#{value}\""
                when :encoding
                  " ENCODING = '#{value}'"
                when :collation
                  " LC_COLLATE = '#{value}'"
                when :ctype
                  " LC_CTYPE = '#{value}'"
                when :tablespace
                  " TABLESPACE = \"#{value}\""
                when :connection_limit
                  " CONNECTION LIMIT = #{value}"
        else
                  ""
        end
      end

      execute "CREATE DATABASE #{quote_table_name(name)}#{option_string}"
    end

create_schema(schema_name) click to toggle source

Creates a schema for the given schema name.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 224
    def create_schema(schema_name)
      execute "CREATE SCHEMA #{quote_schema_name(schema_name)}"
    end

ctype() click to toggle source

Returns the current database ctype.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 208
    def ctype
      query_value("SELECT datctype FROM pg_database WHERE datname = current_database()", "SCHEMA")
    end

current_database() click to toggle source

Returns the current database name.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 188
    def current_database
      query_value("SELECT current_database()", "SCHEMA")
    end

current_schema() click to toggle source

Returns the current schema name.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 193
    def current_schema
      query_value("SELECT current_schema", "SCHEMA")
    end

drop_schema(schema_name, options = {}) click to toggle source

Drops the schema for the given schema name.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 229
    def drop_schema(schema_name, options = {})
      execute "DROP SCHEMA#{' IF EXISTS' if options[:if_exists]} #{quote_schema_name(schema_name)} CASCADE"
    end

encoding() click to toggle source

Returns the current database encoding format.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 198
    def encoding
      query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database()", "SCHEMA")
    end

fetch_type_metadata(column_name, sql_type, oid, fmod) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 604
    def fetch_type_metadata(column_name, sql_type, oid, fmod)
      cast_type = get_oid_type(oid, fmod, column_name, sql_type)
      simple_type = SqlTypeMetadata.new(
        sql_type: sql_type,
        type: cast_type.type,
        limit: cast_type.limit,
        precision: cast_type.precision,
        scale: cast_type.scale,
      )
      PostgreSQLTypeMetadata.new(simple_type, oid: oid, fmod: fmod)
    end

foreign_keys(table_name) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 519
            def foreign_keys(table_name)
              scope = quoted_scope(table_name)
              fk_info = exec_query("            SELECT t2.oid::regclass::text 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 = #{scope[:name]}
                  AND t3.nspname = #{scope[:schema]}
                ORDER BY c.conname
    ".strip_heredoc, "SCHEMA")

              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

index_name_exists?(table_name, index_name, default = nil) click to toggle source

Verifies existence of an index with a given name.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 67
            def index_name_exists?(table_name, index_name, default = nil)
              unless default.nil?
                ActiveSupport::Deprecation.warn("              Passing default to #index_name_exists? is deprecated without replacement.
    ".squish)
              end
              table = quoted_scope(table_name)
              index = quoted_scope(index_name)

              query_value("            SELECT COUNT(*)
                FROM pg_class t
                INNER JOIN pg_index d ON t.oid = d.indrelid
                INNER JOIN pg_class i ON d.indexrelid = i.oid
                LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
                WHERE i.relkind = 'i'
                  AND i.relname = #{index[:name]}
                  AND t.relname = #{table[:name]}
                  AND n.nspname = #{index[:schema]}
    ", "SCHEMA").to_i > 0
            end

new_column_from_field(table_name, field) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 147
    def new_column_from_field(table_name, field) # :nondoc:
      column_name, type, default, notnull, oid, fmod, collation, comment = field
      oid = oid.to_i
      fmod = fmod.to_i
      type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
      default_value = extract_value_from_default(default)
      default_function = extract_default_function(default_value, default)
      PostgreSQLColumn.new(
        column_name,
        default_value,
        type_metadata,
        !notnull,
        table_name,
        default_function,
        collation,
        comment: comment.presence
      )
    end

rename_index(table_name, old_name, new_name) click to toggle source

Renames an index of a table. Raises error if length of new index name is greater than allowed limit.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 513
    def rename_index(table_name, old_name, new_name)
      validate_index_length!(table_name, new_name)

      execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
    end

rename_table(table_name, new_name) click to toggle source

Renames a table. Also renames a table's primary key sequence if the sequence name exists and matches the Active Record default.

Example:

    rename_table('octopuses', 'octopi')

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 392
    def rename_table(table_name, new_name)
      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 && seq.identifier == "#{table_name}_#{pk}_seq"
        new_seq = "#{new_name}_#{pk}_seq"
        idx = "#{table_name}_pkey"
        new_idx = "#{new_name}_pkey"
        execute "ALTER TABLE #{seq.quoted} 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)
    end

schema_exists?(name) click to toggle source

Returns true if schema exists.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 62
    def schema_exists?(name)
      query_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = #{quote(name)}", "SCHEMA").to_i > 0
    end

schema_names() click to toggle source

Returns an array of schema names.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 213
            def schema_names
              query_values("            SELECT nspname
                  FROM pg_namespace
                 WHERE nspname !~ '^pg_.*'
                   AND nspname NOT IN ('information_schema')
                 ORDER by nspname;
    ", "SCHEMA")
            end

schema_search_path() click to toggle source

Returns the active schema search path.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 246
    def schema_search_path
      @schema_search_path ||= query_value("SHOW search_path", "SCHEMA")
    end

schema_search_path=(schema_csv) click to toggle source

Sets the schema search path to a string of comma-separated schema names. Names beginning with $ have to be quoted (e.g. $user => '$user'). See: www.postgresql.org/docs/current/static/ddl-schemas.html

This should be not be called manually but set in database.yml.

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 238
    def schema_search_path=(schema_csv)
      if schema_csv
        execute("SET search_path TO #{schema_csv}", "SCHEMA")
        @schema_search_path = schema_csv
      end
    end

serial_sequence(table, column) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 269
    def serial_sequence(table, column)
      query_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})", "SCHEMA")
    end

### Private Instance Methods

data_source_sql(name = nil, type: nil) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 617
    def data_source_sql(name = nil, type: nil)
      scope = quoted_scope(name, type: type)
      scope[:type] ||= "'r','v','m'" # (r)elation/table, (v)iew, (m)aterialized view

      sql = "SELECT c.relname FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace"
      sql << " WHERE n.nspname = #{scope[:schema]}"
      sql << " AND c.relname = #{scope[:name]}" if scope[:name]
      sql << " AND c.relkind IN (#{scope[:type]})"
      sql
    end

extract_schema_qualified_name(string) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 644
    def extract_schema_qualified_name(string)
      name = Utils.extract_schema_qualified_name(string.to_s)
      [name.schema, name.identifier]
    end

quoted_scope(name = nil, type: nil) click to toggle source

    # File lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 628
    def quoted_scope(name = nil, type: nil)
      schema, name = extract_schema_qualified_name(name)
      type =                case type
        when "BASE TABLE"
          "'r'"
        when "VIEW"
          "'v','m'"
        end
      scope = {}
      scope[:schema] = schema ? quote(schema) : "ANY (current_schemas(false))"
      scope[:name] = quote(name) if name
      scope[:type] = type if type
      scope
    end