ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
Methods
C
D
E
F
I
N
R
S
Instance Public methods
client_min_messages()

Returns the current client message level.

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

Set the client message level.

# File activerecord/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()

Returns the current database collation.

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 203
def collation
  select_value("SELECT datcollate FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
end
create_database(name, options = {})

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 activerecord/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)

Creates a schema for the given schema name.

# File activerecord/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()

Returns the current database ctype.

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 208
def ctype
  select_value("SELECT datctype FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
end
current_database()

Returns the current database name.

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

Returns the current schema name.

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 193
def current_schema
  select_value("SELECT current_schema", "SCHEMA")
end
drop_schema(schema_name, options = {})

Drops the schema for the given schema name.

# File activerecord/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()

Returns the current database encoding format.

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 198
def encoding
  select_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
end
fetch_type_metadata(column_name, sql_type, oid, fmod)
# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 606
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)
# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 521
        def foreign_keys(table_name)
          scope = quoted_scope(table_name)
          fk_info = select_all("            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)

Verifies existence of an index with a given name.

# File activerecord/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)

          select_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)
# File activerecord/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)

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

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 515
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)

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 activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 394
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)

Returns true if schema exists.

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

Returns an array of schema names.

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

Returns the active schema search path.

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

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 activerecord/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)
# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 269
def serial_sequence(table, column)
  select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", "SCHEMA")
end