Module: ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
Instance Attribute Summary
Instance Method Summary
-
#add_exclusion_constraint(table_name, expression, **options)
Adds a new exclusion constraint to the table.
-
#add_foreign_key(from_table, to_table, **options)
-
#add_unique_constraint(table_name, column_name = nil, **options)
Adds a new unique constraint to the table.
-
#collation
Returns the current database collation.
-
#create_database(name, options = {})
-
#create_schema(schema_name, force: nil, if_not_exists: nil)
Creates a schema for the given schema name.
-
#ctype
Returns the current database ctype.
-
#current_database
Returns the current database name.
-
#current_schema
Returns the current schema name.
-
#drop_schema(schema_name, **options)
Drops the schema for the given schema name.
-
#encoding
Returns the current database encoding format.
-
#exclusion_constraints(table_name)
Returns an array of exclusion constraints for the given table.
-
#foreign_keys(table_name)
-
#foreign_table_exists?(table_name) ⇒ Boolean
-
#foreign_tables
-
#index_name_exists?(table_name, index_name) ⇒ Boolean
Verifies existence of an index with a given name.
-
#remove_exclusion_constraint(table_name, expression = nil, **options)
Removes the given exclusion constraint from the table.
-
#remove_unique_constraint(table_name, column_name = nil, **options)
Removes the given unique constraint from the table.
-
#rename_index(table_name, old_name, new_name)
Renames an index of a table.
-
#rename_table(table_name, new_name, **options)
-
#schema_exists?(name) ⇒ Boolean
Returns true if schema exists.
-
#schema_names
Returns an array of schema names.
-
#serial_sequence(table, column)
-
#unique_constraints(table_name)
Returns an array of unique constraints for the given table.
-
#validate_check_constraint(table_name, **options)
Validates the given check constraint.
-
#validate_constraint(table_name, constraint_name)
Validates the given constraint.
-
#validate_foreign_key(from_table, to_table = nil, **options)
Validates the given foreign key.
-
#add_column_for_alter(table_name, column_name, type, **options)
private
-
#add_index_opclass(quoted_columns, **options)
private
-
#add_options_for_index_columns(quoted_columns, **options)
private
-
#assert_valid_deferrable(deferrable)
private
-
#change_column_for_alter(table_name, column_name, type, **options)
private
-
#change_column_null_for_alter(table_name, column_name, null, default = nil)
private
-
#column_names_from_column_numbers(table_oid, column_numbers)
private
-
#create_alter_table(name)
private
-
#create_table_definition(name, **options)
private
-
#data_source_sql(name = nil, type: nil)
private
-
#exclusion_constraint_for(table_name, **options)
private
-
#exclusion_constraint_for!(table_name, expression: nil, **options)
private
-
#exclusion_constraint_name(table_name, **options)
private
-
#extract_constraint_deferrable(deferrable, deferred)
private
-
#extract_foreign_key_action(specifier)
private
-
#extract_schema_qualified_name(string)
private
-
#fetch_type_metadata(column_name, sql_type, oid, fmod)
private
-
#new_column_from_field(table_name, field, _definitions)
private
-
#quoted_scope(name = nil, type: nil)
private
-
#reference_name_for_table(table_name)
private
-
#sequence_name_from_parts(table_name, column_name, suffix)
private
-
#unique_constraint_for(table_name, **options)
private
-
#unique_constraint_for!(table_name, column: nil, **options)
private
-
#unique_constraint_name(table_name, **options)
private
-
#add_column(table_name, column_name, type, **options)
Internal use only
-
#add_index(table_name, column_name, **options)
Internal use only
-
#add_index_options(table_name, column_name, **options)
Internal use only
-
#build_change_column_default_definition(table_name, column_name, default_or_changes)
Internal use only
-
#build_change_column_definition(table_name, column_name, type, **options)
Internal use only
-
#build_create_index_definition(table_name, column_name, **options)
Internal use only
-
#change_column(table_name, column_name, type, **options)
Internal use only
-
#change_column_comment(table_name, column_name, comment_or_changes)
Internal use only
Adds comment for given table column or drops it if comment
is a nil
-
#change_column_default(table_name, column_name, default_or_changes)
Internal use only
Changes the default value of a table column.
-
#change_column_null(table_name, column_name, null, default = nil)
Internal use only
-
#change_table_comment(table_name, comment_or_changes)
Internal use only
Adds comment for given table or drops it if comment
is a nil
-
#check_constraints(table_name)
Internal use only
-
#columns_for_distinct(columns, orders)
Internal use only
-
#create_schema_dumper(options)
Internal use only
-
#default_sequence_name(table_name, pk = "id")
Internal use only
Returns the sequence name for a table’s primary key or some other specified key.
-
#drop_database(name)
Internal use only
-
#drop_table(*table_names, **options)
Internal use only
-
#exclusion_constraint_options(table_name, expression, options)
Internal use only
-
#foreign_key_column_for(table_name, column_name)
Internal use only
-
#index_name(table_name, options)
Internal use only
-
#indexes(table_name)
Internal use only
Returns an array of indexes for the given table.
-
#inherited_table_names(table_name)
Internal use only
Returns the inherited table name of a given table.
-
#pk_and_sequence_for(table)
Internal use only
Returns a table’s primary key and belonging sequence.
-
#primary_keys(table_name)
Internal use only
-
#quoted_include_columns_for_index(column_names)
Internal use only
-
#recreate_database(name, options = {})
Internal use only
Drops the database specified on the name
attribute and creates it again using the provided options
.
-
#remove_index(table_name, column_name = nil, **options)
Internal use only
-
#rename_column(table_name, column_name, new_column_name)
Internal use only
Renames a column in a table.
-
#reset_pk_sequence!(table, pk = nil, sequence = nil)
Internal use only
Resets the sequence of a table’s primary key to the maximum value.
-
#schema_creation
Internal use only
-
#set_pk_sequence!(table, value)
Internal use only
Sets the sequence of a table’s primary key to the specified value.
-
#table_comment(table_name)
Internal use only
Returns a comment stored in database for given table.
-
#table_options(table_name)
Internal use only
-
#table_partition_definition(table_name)
Internal use only
Returns the partition definition of a given table.
-
#type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil)
Internal use only
Maps logical ::Rails
types to PostgreSQL-specific data types.
-
#unique_constraint_options(table_name, column_name, options)
Internal use only
-
#update_table_definition(table_name, base)
Internal use only
Instance Attribute Details
#client_min_messages
Returns the current client message level.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 291
def client_min_messages
query_value("SHOW client_min_messages", "SCHEMA")
end
#client_min_messages=(level)
Set the client message level.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 296
def client_min_messages=(level)
internal_execute("SET client_min_messages TO '#{level}'", "SCHEMA")
end
#schema_search_path
Returns the active schema search path.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 286
def schema_search_path
@schema_search_path ||= query_value("SHOW search_path", "SCHEMA")
end
#schema_search_path=(schema_csv)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 278
def schema_search_path=(schema_csv)
if schema_csv
internal_execute("SET search_path TO #{schema_csv}")
@schema_search_path = schema_csv
end
end
Instance Method Details
#add_column(table_name, column_name, type, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 460
def add_column(table_name, column_name, type, **options) clear_cache!
super
change_column_comment(table_name, column_name, options[:]) if options.key?(:)
end
#add_column_for_alter(table_name, column_name, type, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1046
def add_column_for_alter(table_name, column_name, type, **options)
return super unless options.key?(:)
[super, Proc.new { change_column_comment(table_name, column_name, options[:]) }]
end
#add_exclusion_constraint(table_name, expression, **options)
Adds a new exclusion constraint to the table. expression
is a ::String
representation of a list of exclusion elements and operators.
add_exclusion_constraint :products, "price WITH =, availability_range WITH &&", using: :gist, name: "price_check"
generates:
ALTER TABLE "products" ADD CONSTRAINT price_check EXCLUDE USING gist (price WITH =, availability_range WITH &&)
The options
hash can include the following keys:
:name
-
The constraint name. Defaults to excl_rails_<identifier>
.
:deferrable
-
Specify whether or not the exclusion constraint should be deferrable. Valid values are false
or :immediate
or :deferred
to specify the default behavior. Defaults to false
.
:using
-
Specify which index method to use when creating this exclusion constraint (e.g. :btree
, :gist
etc).
:where
-
Specify an exclusion constraint on a subset of the table (internally PostgreSQL creates a partial index for this).
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 745
def add_exclusion_constraint(table_name, expression, **options)
options = exclusion_constraint_options(table_name, expression, options)
at = create_alter_table(table_name)
at.add_exclusion_constraint(expression, options)
execute schema_creation.accept(at)
end
#add_foreign_key(from_table, to_table, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 578
def add_foreign_key(from_table, to_table, **options)
assert_valid_deferrable(options[:deferrable])
super
end
#add_index(table_name, column_name, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 529
def add_index(table_name, column_name, **options) create_index = build_create_index_definition(table_name, column_name, **options)
result = execute schema_creation.accept(create_index)
index = create_index.index
execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.)}" if index.
result
end
#add_index_opclass(quoted_columns, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1066
def add_index_opclass(quoted_columns, **options)
opclasses = options_for_index_columns(options[:opclass])
quoted_columns.each do |name, column|
column << " #{opclasses[name]}" if opclasses[name].present?
end
end
#add_index_options(table_name, column_name, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 937
def add_index_options(table_name, column_name, **options) if (where = options[:where]) && table_exists?(table_name) && column_exists?(table_name, where)
options[:where] = quote_column_name(where)
end
super
end
#add_options_for_index_columns(quoted_columns, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1073
def add_options_for_index_columns(quoted_columns, **options)
quoted_columns = add_index_opclass(quoted_columns, **options)
super
end
#add_unique_constraint(table_name, column_name = nil, **options)
Adds a new unique constraint to the table.
add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_position", nulls_not_distinct: true
generates:
ALTER TABLE "sections" ADD CONSTRAINT unique_position UNIQUE (position) DEFERRABLE INITIALLY DEFERRED
If you want to change an existing unique index to deferrable, you can use :using_index
to create deferrable unique constraints.
add_unique_constraint :sections, deferrable: :deferred, name: "unique_position", using_index: "index_sections_on_position"
The options
hash can include the following keys:
:name
-
The constraint name. Defaults to uniq_rails_<identifier>
.
:deferrable
-
Specify whether or not the unique constraint should be deferrable. Valid values are false
or :immediate
or :deferred
to specify the default behavior. Defaults to false
.
:using_index
-
To specify an existing unique index name. Defaults to nil
.
:nulls_not_distinct
-
Create a unique constraint where NULLs are treated equally. Note: only supported by PostgreSQL version 15.0.0 and greater.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 796
def add_unique_constraint(table_name, column_name = nil, **options)
options = unique_constraint_options(table_name, column_name, options)
at = create_alter_table(table_name)
at.add_unique_constraint(column_name, options)
execute schema_creation.accept(at)
end
#assert_valid_deferrable(deferrable)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1031
def assert_valid_deferrable(deferrable)
return if !deferrable || %i(immediate deferred).include?(deferrable)
raise ArgumentError, "deferrable must be `:immediate` or `:deferred`, got: `#{deferrable.inspect}`"
end
#build_change_column_default_definition(table_name, column_name, default_or_changes)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 489
def build_change_column_default_definition(table_name, column_name, default_or_changes) column = column_for(table_name, column_name)
return unless column
default = (default_or_changes)
ChangeColumnDefaultDefinition.new(column, default)
end
#build_change_column_definition(table_name, column_name, type, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 478
def build_change_column_definition(table_name, column_name, type, **options) td = create_table_definition(table_name)
cd = td.new_column_definition(column_name, type, **options)
ChangeColumnDefinition.new(cd, column_name)
end
#build_create_index_definition(table_name, column_name, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 538
def build_create_index_definition(table_name, column_name, **options) index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)
CreateIndexDefinition.new(index, algorithm, if_not_exists)
end
#change_column(table_name, column_name, type, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 466
def change_column(table_name, column_name, type, **options) clear_cache!
sqls, procs = Array(change_column_for_alter(table_name, column_name, type, **options)).partition { |v| v.is_a?(String) }
execute "ALTER TABLE #{quote_table_name(table_name)} #{sqls.join(", ")}"
procs.each(&:call)
end
#change_column_default(table_name, column_name, default_or_changes)
This method is for internal use only.
Changes the default value of a table column.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 485
def change_column_default(table_name, column_name, default_or_changes) execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_default_for_alter(table_name, column_name, default_or_changes)}"
end
#change_column_for_alter(table_name, column_name, type, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1051
def change_column_for_alter(table_name, column_name, type, **options)
change_col_def = build_change_column_definition(table_name, column_name, type, **options)
sqls = [schema_creation.accept(change_col_def)]
sqls << Proc.new { change_column_comment(table_name, column_name, options[:]) } if options.key?(:)
sqls
end
#change_column_null(table_name, column_name, null, default = nil)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 497
def change_column_null(table_name, column_name, null, default = nil) validate_change_column_null_argument!(null)
clear_cache!
unless null || default.nil?
column = column_for(table_name, column_name)
execute "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(default, column)} WHERE #{quote_column_name(column_name)} IS NULL" if column
end
execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL"
end
#change_column_null_for_alter(table_name, column_name, null, default = nil)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1058
def change_column_null_for_alter(table_name, column_name, null, default = nil)
if default.nil?
"ALTER COLUMN #{quote_column_name(column_name)} #{null ? 'DROP' : 'SET'} NOT NULL"
else
Proc.new { change_column_null(table_name, column_name, null, default) }
end
end
#check_constraints(table_name)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 637
def check_constraints(table_name) scope = quoted_scope(table_name)
check_info = internal_exec_query(<<-SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
SELECT conname, pg_get_constraintdef(c.oid, true) AS constraintdef, c.convalidated AS valid
FROM pg_constraint c
JOIN pg_class t ON c.conrelid = t.oid
JOIN pg_namespace n ON n.oid = c.connamespace
WHERE c.contype = 'c'
AND t.relname = #{scope[:name]}
AND n.nspname = #{scope[:schema]}
SQL
check_info.map do |row|
options = {
name: row["conname"],
validate: row["valid"]
}
expression = row["constraintdef"][/CHECK \((.+)\)/m, 1]
CheckConstraintDefinition.new(table_name, expression, options)
end
end
#collation
Returns the current database collation.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 235
def collation
query_value("SELECT datcollate FROM pg_database WHERE datname = current_database()", "SCHEMA")
end
#column_names_from_column_numbers(table_oid, column_numbers)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1152
def column_names_from_column_numbers(table_oid, column_numbers)
Hash[query(<<~SQL, "SCHEMA")].values_at(*column_numbers).compact
SELECT a.attnum, a.attname
FROM pg_attribute a
WHERE a.attrelid = #{table_oid}
AND a.attnum IN (#{column_numbers.join(", ")})
SQL
end
#columns_for_distinct(columns, orders)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 868
def columns_for_distinct(columns, orders) order_columns = orders.compact_blank.map { |s|
s = visitor.compile(s) unless s.is_a?(String)
s.gsub(/\s+(?:ASC|DESC)\b/i, "")
.gsub(/\sNULLS\s(?:FIRST|LAST)\b/i, "")
}.compact_blank.map.with_index { |column, i| "#{column} AS alias_#{i}" }
(order_columns << super).join(", ")
end
#create_alter_table(name)
[ GitHub ]
#create_database(name, options = {})
[ GitHub ]
# 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.each_with_object(+"") do |(key, value), memo|
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, force: nil, if_not_exists: nil)
Creates a schema for the given schema name.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 256
def create_schema(schema_name, force: nil, if_not_exists: nil)
if force && if_not_exists
raise ArgumentError, "Options `:force` and `:if_not_exists` cannot be used simultaneously."
end
if force
drop_schema(schema_name, if_exists: true)
end
execute("CREATE SCHEMA#{' IF NOT EXISTS' if if_not_exists} #{quote_schema_name(schema_name)}")
end
#create_schema_dumper(options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 884
def create_schema_dumper(options) PostgreSQL::SchemaDumper.create(self, options)
end
#create_table_definition(name, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 958
def create_table_definition(name, **options)
PostgreSQL::TableDefinition.new(self, name, **options)
end
#ctype
Returns the current database ctype.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 240
def ctype
query_value("SELECT datctype FROM pg_database WHERE datname = current_database()", "SCHEMA")
end
#current_database
Returns the current database name.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 220
def current_database
query_value("SELECT current_database()", "SCHEMA")
end
#current_schema
Returns the current schema name.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 225
def current_schema
query_value("SELECT current_schema", "SCHEMA")
end
#data_source_sql(name = nil, type: nil)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1118
def data_source_sql(name = nil, type: nil)
scope = quoted_scope(name, type: type)
scope[:type] ||= "'r','v','m','p','f'"
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
#default_sequence_name(table_name, pk = "id")
This method is for internal use only.
Returns the sequence name for a table’s primary key or some other specified key.
[ GitHub ]
#drop_database(name)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 53
def drop_database(name) execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
end
#drop_schema(schema_name, **options)
Drops the schema for the given schema name.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 269
def drop_schema(schema_name, **options)
execute "DROP SCHEMA#{' IF EXISTS' if options[:if_exists]} #{quote_schema_name(schema_name)} CASCADE"
end
#drop_table(*table_names, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 57
def drop_table(*table_names, **options) table_names.each { |table_name| schema_cache.clear_data_source_cache!(table_name.to_s) }
execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{table_names.map { |table_name| quote_table_name(table_name) }.join(', ')}#{' CASCADE' if options[:force] == :cascade}"
end
#encoding
Returns the current database encoding format.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 230
def encoding
query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database()", "SCHEMA")
end
#exclusion_constraint_for(table_name, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1088
def exclusion_constraint_for(table_name, **options)
excl_name = exclusion_constraint_name(table_name, **options)
exclusion_constraints(table_name).detect { |excl| excl.name == excl_name }
end
#exclusion_constraint_for!(table_name, expression: nil, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1093
def exclusion_constraint_for!(table_name, expression: nil, **options)
exclusion_constraint_for(table_name, expression: expression, **options) ||
raise(ArgumentError, "Table '#{table_name}' has no exclusion constraint for #{expression || options}")
end
#exclusion_constraint_name(table_name, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1078
def exclusion_constraint_name(table_name, **options)
options.fetch(:name) do
expression = options.fetch(:expression)
identifier = "#{table_name}_#{expression}_excl"
hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
"excl_rails_#{hashed_identifier}"
end
end
#exclusion_constraint_options(table_name, expression, options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 753
def exclusion_constraint_options(table_name, expression, options) assert_valid_deferrable(options[:deferrable])
options = options.dup
options[:name] ||= exclusion_constraint_name(table_name, expression: expression, **options)
options
end
#exclusion_constraints(table_name)
Returns an array of exclusion constraints for the given table. The exclusion constraints are represented as ExclusionConstraintDefinition
objects.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 663
def exclusion_constraints(table_name)
scope = quoted_scope(table_name)
exclusion_info = internal_exec_query(<<-SQL, "SCHEMA")
SELECT conname, pg_get_constraintdef(c.oid) AS constraintdef, c.condeferrable, c.condeferred
FROM pg_constraint c
JOIN pg_class t ON c.conrelid = t.oid
JOIN pg_namespace n ON n.oid = c.connamespace
WHERE c.contype = 'x'
AND t.relname = #{scope[:name]}
AND n.nspname = #{scope[:schema]}
SQL
exclusion_info.map do |row|
method_and_elements, predicate = row["constraintdef"].split(" WHERE ")
method_and_elements_parts = method_and_elements.match(/EXCLUDE(?: USING (?<using>\S+))? \((?<expression>.+)\)/)
predicate.remove!(/ DEFERRABLE(?: INITIALLY (?:IMMEDIATE|DEFERRED))?/) if predicate
predicate = predicate.from(2).to(-3) if predicate
deferrable = (row["condeferrable"], row["condeferred"])
options = {
name: row["conname"],
using: method_and_elements_parts["using"].to_sym,
where: predicate,
deferrable: deferrable
}
ExclusionConstraintDefinition.new(table_name, method_and_elements_parts["expression"], options)
end
end
#foreign_key_column_for(table_name, column_name)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 932
def foreign_key_column_for(table_name, column_name) _schema, table_name = (table_name)
super
end
#foreign_keys(table_name)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 584
def foreign_keys(table_name)
scope = quoted_scope(table_name)
fk_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
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, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred, c.conkey, c.confkey, c.conrelid, c.confrelid
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
SQL
fk_info.map do |row|
to_table = Utils.unquote_identifier(row["to_table"])
conkey = row["conkey"].scan(/\d+/).map(&:to_i)
confkey = row["confkey"].scan(/\d+/).map(&:to_i)
if conkey.size > 1
column = column_names_from_column_numbers(row["conrelid"], conkey)
primary_key = column_names_from_column_numbers(row["confrelid"], confkey)
else
column = Utils.unquote_identifier(row["column"])
primary_key = row["primary_key"]
end
options = {
column: column,
name: row["name"],
primary_key: primary_key
}
options[:on_delete] = (row["on_delete"])
options[:on_update] = (row["on_update"])
options[:deferrable] = (row["deferrable"], row["deferred"])
options[:validate] = row["valid"]
ForeignKeyDefinition.new(table_name, to_table, options)
end
end
#foreign_table_exists?(table_name) ⇒ Boolean
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 633
def foreign_table_exists?(table_name)
query_values(data_source_sql(table_name, type: "FOREIGN TABLE"), "SCHEMA").any? if table_name.present?
end
#foreign_tables
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 629
def foreign_tables
query_values(data_source_sql(type: "FOREIGN TABLE"), "SCHEMA")
end
#index_name(table_name, options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 573
def index_name(table_name, options) _schema, table_name = (table_name.to_s)
super
end
#index_name_exists?(table_name, index_name) ⇒ Boolean
Verifies existence of an index with a given name.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 68
def index_name_exists?(table_name, index_name)
table = quoted_scope(table_name)
index = quoted_scope(index_name)
query_value(<<~SQL, "SCHEMA").to_i > 0
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 = t.relnamespace
WHERE i.relkind IN ('i', 'I')
AND i.relname = #{index[:name]}
AND t.relname = #{table[:name]}
AND n.nspname = #{table[:schema]}
SQL
end
#indexes(table_name)
This method is for internal use only.
Returns an array of indexes for the given table.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 86
def indexes(table_name) scope = quoted_scope(table_name)
result = query(<<~SQL, "SCHEMA")
SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
pg_catalog.obj_description(i.oid, 'pg_class') AS comment, d.indisvalid
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 = t.relnamespace
WHERE i.relkind IN ('i', 'I')
AND d.indisprimary = 'f'
AND t.relname = #{scope[:name]}
AND n.nspname = #{scope[:schema]}
ORDER BY i.relname
SQL
result.map do |row|
index_name = row[0]
unique = row[1]
indkey = row[2].split(" ").map(&:to_i)
inddef = row[3]
oid = row[4]
= row[5]
valid = row[6]
using, expressions, include, nulls_not_distinct, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: INCLUDE \((.+?)\))?( NULLS NOT DISTINCT)?(?: WHERE (.+))?\z/m).flatten
orders = {}
opclasses = {}
include_columns = include ? include.split(",").map { |c| Utils.unquote_identifier(c.strip.gsub('""', '"')) } : []
if indkey.include?(0)
columns = expressions
else
columns = column_names_from_column_numbers(oid, indkey)
columns.reject! { |c| include_columns.include?(c) }
expressions.scan(/(?<column>\w)"?\s?(?<opclass>\w_ops(_\w+)?)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
opclasses[column] = opclass.to_sym if opclass
if nulls
orders[column] = [desc, nulls].compact.join(" ")
else
orders[column] = :desc if desc
end
end
end
IndexDefinition.new(
table_name,
index_name,
unique,
columns,
orders: orders,
opclasses: opclasses,
where: where,
using: using.to_sym,
include: include_columns.presence,
nulls_not_distinct: nulls_not_distinct.present?,
comment: .presence,
valid: valid
)
end
end
#inherited_table_names(table_name)
This method is for internal use only.
Returns the inherited table name of a given table
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 204
def inherited_table_names(table_name) scope = quoted_scope(table_name, type: "BASE TABLE")
query_values(<<~SQL, "SCHEMA")
SELECT parent.relname
FROM pg_catalog.pg_inherits i
JOIN pg_catalog.pg_class child ON i.inhrelid = child.oid
JOIN pg_catalog.pg_class parent ON i.inhparent = parent.oid
LEFT JOIN pg_namespace n ON n.oid = child.relnamespace
WHERE child.relname = #{scope[:name]}
AND child.relkind IN (#{scope[:type]})
AND n.nspname = #{scope[:schema]}
SQL
end
#new_column_from_field(table_name, field, _definitions)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 966
def new_column_from_field(table_name, field, _definitions)
column_name, type, default, notnull, oid, fmod, collation, , identity, attgenerated = field
type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
default_value = (default)
if attgenerated.present?
default_function = default
else
default_function = (default_value, default)
end
if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
end
PostgreSQL::Column.new(
column_name,
default_value,
type_metadata,
!notnull,
default_function,
collation: collation,
comment: .presence,
serial: serial,
identity: identity.presence,
generated: attgenerated
)
end
#pk_and_sequence_for(table)
This method is for internal use only.
Returns a table’s primary key and belonging sequence.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 359
def pk_and_sequence_for(table) result = query(<<~SQL, "SCHEMA")[0]
SELECT attr.attname, nsp.nspname, seq.relname
FROM pg_class seq,
pg_attribute attr,
pg_depend dep,
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(quote_table_name(table))}::regclass
SQL
if result.nil? || result.empty?
result = query(<<~SQL, "SCHEMA")[0]
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
substr(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2),
strpos(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2), '.')+1)
ELSE split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2)
END
FROM pg_class t
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(quote_table_name(table))}::regclass
AND cons.contype = 'p'
AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate|gen_random_uuid'
SQL
end
pk = result.shift
if result.last
[pk, PostgreSQL::Name.new(*result)]
else
[pk, nil]
end
rescue
nil
end
#primary_keys(table_name)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 412
def primary_keys(table_name) query_values(<<~SQL, "SCHEMA")
SELECT a.attname
FROM (
SELECT indrelid, indkey, generate_subscripts(indkey, 1) idx
FROM pg_index
WHERE indrelid = #{quote(quote_table_name(table_name))}::regclass
AND indisprimary
) i
JOIN pg_attribute a
ON a.attrelid = i.indrelid
AND a.attnum = i.indkey[i.idx]
ORDER BY i.idx
SQL
end
#quoted_include_columns_for_index(column_names)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 944
def quoted_include_columns_for_index(column_names) return quote_column_name(column_names) if column_names.is_a?(Symbol)
quoted_columns = column_names.each_with_object({}) do |name, result|
result[name.to_sym] = quote_column_name(name).dup
end
add_options_for_index_columns(quoted_columns).values.join(", ")
end
#quoted_scope(name = nil, type: nil)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1129
def quoted_scope(name = nil, type: nil)
schema, name = (name)
type = \
case type
when "BASE TABLE"
"'r','p'"
when "VIEW"
"'v','m'"
when "FOREIGN TABLE"
"'f'"
end
scope = {}
scope[:schema] = schema ? quote(schema) : "ANY (current_schemas(false))"
scope[:name] = quote(name) if name
scope[:type] = type if type
scope
end
#recreate_database(name, options = {})
This method is for internal use only.
Drops the database specified on the name
attribute and creates it again using the provided options
.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 9
def recreate_database(name, options = {}) drop_database(name)
create_database(name, options)
end
#reference_name_for_table(table_name)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1041
def reference_name_for_table(table_name)
_schema, table_name = (table_name.to_s)
table_name.singularize
end
#remove_exclusion_constraint(table_name, expression = nil, **options)
Removes the given exclusion constraint from the table.
remove_exclusion_constraint :products, name: "price_check"
The expression
parameter will be ignored if present. It can be helpful to provide this in a migration’s change
method so it can be reverted. In that case, expression
will be used by #add_exclusion_constraint.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 768
def remove_exclusion_constraint(table_name, expression = nil, **options)
excl_name_to_delete = exclusion_constraint_for!(table_name, expression: expression, **options).name
remove_constraint(table_name, excl_name_to_delete)
end
#remove_index(table_name, column_name = nil, **options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 543
def remove_index(table_name, column_name = nil, **options) table = Utils.(table_name.to_s)
if options.key?(:name)
provided_index = Utils.(options[:name].to_s)
options[:name] = provided_index.identifier
table = PostgreSQL::Name.new(provided_index.schema, table.identifier) unless table.schema.present?
if provided_index.schema.present? && table.schema != provided_index.schema
raise ArgumentError.new("Index schema '#{provided_index.schema}' does not match table schema '#{table.schema}'")
end
end
return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
index_to_remove = PostgreSQL::Name.new(table.schema, index_name_for_remove(table.to_s, column_name, options))
execute "DROP INDEX #{index_algorithm(options[:algorithm])} #{quote_table_name(index_to_remove)}"
end
#remove_unique_constraint(table_name, column_name = nil, **options)
Removes the given unique constraint from the table.
remove_unique_constraint :sections, name: "unique_position"
The column_name
parameter will be ignored if present. It can be helpful to provide this in a migration’s change
method so it can be reverted. In that case, column_name
will be used by #add_unique_constraint.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 823
def remove_unique_constraint(table_name, column_name = nil, **options)
unique_name_to_delete = unique_constraint_for!(table_name, column: column_name, **options).name
remove_constraint(table_name, unique_name_to_delete)
end
#rename_column(table_name, column_name, new_column_name)
This method is for internal use only.
Renames a column in a table.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 523
def rename_column(table_name, column_name, new_column_name) clear_cache!
execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
rename_column_indexes(table_name, column_name, new_column_name)
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.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 566
def rename_index(table_name, old_name, new_name)
validate_index_length!(table_name, new_name)
schema, = (table_name)
execute "ALTER INDEX #{quote_table_name(schema) + '.' if schema}#{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
end
#rename_table(table_name, new_name, **options)
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')
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 434
def rename_table(table_name, new_name, **options)
validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
clear_cache!
schema_cache.clear_data_source_cache!(table_name.to_s)
schema_cache.clear_data_source_cache!(new_name.to_s)
execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
pk, seq = pk_and_sequence_for(new_name)
if pk
max_pkey_prefix = max_identifier_length - "_pkey".size
idx = "#{table_name[0, max_pkey_prefix]}_pkey"
new_idx = "#{new_name[0, max_pkey_prefix]}_pkey"
execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
max_seq_prefix = max_identifier_length - "_#{pk}_seq".size
if seq && seq.identifier == "#{table_name[0, max_seq_prefix]}_#{pk}_seq"
new_seq = "#{new_name[0, max_seq_prefix]}_#{pk}_seq"
execute "ALTER TABLE #{seq.quoted} RENAME TO #{quote_table_name(new_seq)}"
end
end
rename_table_indexes(table_name, new_name, **options)
end
#reset_pk_sequence!(table, pk = nil, sequence = nil)
This method is for internal use only.
Resets the sequence of a table’s primary key to the maximum value.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 331
def reset_pk_sequence!(table, pk = nil, sequence = nil) unless pk && sequence
default_pk, default_sequence = pk_and_sequence_for(table)
pk ||= default_pk
sequence ||= default_sequence
end
if @logger && pk && !sequence
@logger.warn "#{table} has primary key #{pk} with no default sequence."
end
if pk && sequence
quoted_sequence = quote_table_name(sequence)
max_pk = query_value("SELECT MAX(#{quote_column_name pk}) FROM #{quote_table_name(table)}", "SCHEMA")
if max_pk.nil?
if database_version >= 10_00_00
minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
else
minvalue = query_value("SELECT min_value FROM #{quoted_sequence}", "SCHEMA")
end
end
query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk || minvalue}, #{max_pk ? true : false})", "SCHEMA")
end
end
#schema_creation
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 953
def schema_creation PostgreSQL::SchemaCreation.new(self)
end
#schema_exists?(name) ⇒ Boolean
Returns true if schema exists.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 63
def schema_exists?(name)
query_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = #{quote(name)}", "SCHEMA").to_i > 0
end
#schema_names
Returns an array of schema names.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 245
def schema_names
query_values(<<~SQL, "SCHEMA")
SELECT nspname
FROM pg_namespace
WHERE nspname !~ '^pg_.*'
AND nspname NOT IN ('information_schema')
ORDER by nspname;
SQL
end
#sequence_name_from_parts(table_name, column_name, suffix)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1007
def sequence_name_from_parts(table_name, column_name, suffix)
over_length = [table_name, column_name, suffix].sum(&:length) + 2 - max_identifier_length
if over_length > 0
column_name_length = [(max_identifier_length - suffix.length - 2) / 2, column_name.length].min
over_length -= column_name.length - column_name_length
column_name = column_name[0, column_name_length - [over_length, 0].min]
end
if over_length > 0
table_name = table_name[0, table_name.length - over_length]
end
"#{table_name}_#{column_name}_#{suffix}"
end
#serial_sequence(table, column)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 311
def serial_sequence(table, column)
query_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})", "SCHEMA")
end
#set_pk_sequence!(table, value)
This method is for internal use only.
Sets the sequence of a table’s primary key to the specified value.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 316
def set_pk_sequence!(table, value) pk, sequence = pk_and_sequence_for(table)
if pk
if sequence
quoted_sequence = quote_table_name(sequence)
query_value("SELECT setval(#{quote(quoted_sequence)}, #{value})", "SCHEMA")
else
@logger.warn "#{table} has primary key #{pk} with no default sequence." if @logger
end
end
end
#table_options(table_name)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 154
def table_options(table_name) options = {}
= (table_name)
options[:] = if
inherited_table_names = inherited_table_names(table_name).presence
options[:options] = "INHERITS (#{inherited_table_names.join(", ")})" if inherited_table_names
if !options[:options] && supports_native_partitioning?
partition_definition = table_partition_definition(table_name)
options[:options] = "PARTITION BY #{partition_definition}" if partition_definition
end
options
end
#table_partition_definition(table_name)
This method is for internal use only.
Returns the partition definition of a given table
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 190
def table_partition_definition(table_name) scope = quoted_scope(table_name, type: "BASE TABLE")
query_value(<<~SQL, "SCHEMA")
SELECT pg_catalog.pg_get_partkeydef(c.oid)
FROM pg_catalog.pg_class c
LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
WHERE c.relname = #{scope[:name]}
AND c.relkind IN (#{scope[:type]})
AND n.nspname = #{scope[:schema]}
SQL
end
#type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil)
This method is for internal use only.
Maps logical ::Rails
types to PostgreSQL-specific data types.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 830
def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil, **) sql = \
case type.to_s
when "binary"
case limit
when nil, 0..0x3fffffff; super(type)
else raise ArgumentError, "No binary type has byte size #{limit}. The limit on binary can be at most 1GB - 1byte."
end
when "text"
case limit
when nil, 0..0x3fffffff; super(type)
else raise ArgumentError, "No text type has byte size #{limit}. The limit on text can be at most 1GB - 1byte."
end
when "integer"
case limit
when 1, 2; "smallint"
when nil, 3, 4; "integer"
when 5..8; "bigint"
else raise ArgumentError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead."
end
when "enum"
raise ArgumentError, "enum_type is required for enums" if enum_type.nil?
enum_type
else
super
end
sql = "#{sql}[]" if array && type != :primary_key
sql
end
#unique_constraint_for(table_name, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1108
def unique_constraint_for(table_name, **options)
name = unique_constraint_name(table_name, **options) unless options.key?(:column)
unique_constraints(table_name).detect { |unique_constraint| unique_constraint.defined_for?(name: name, **options) }
end
#unique_constraint_for!(table_name, column: nil, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1113
def unique_constraint_for!(table_name, column: nil, **options)
unique_constraint_for(table_name, column: column, **options) ||
raise(ArgumentError, "Table '#{table_name}' has no unique constraint for #{column || options}")
end
#unique_constraint_name(table_name, **options)
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 1098
def unique_constraint_name(table_name, **options)
options.fetch(:name) do
column_or_index = Array(options[:column] || options[:using_index]).map(&:to_s)
identifier = "#{table_name}_#{column_or_index * '_and_'}_unique"
hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
"uniq_rails_#{hashed_identifier}"
end
end
#unique_constraint_options(table_name, column_name, options)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 804
def unique_constraint_options(table_name, column_name, options) assert_valid_deferrable(options[:deferrable])
if column_name && options[:using_index]
raise ArgumentError, "Cannot specify both column_name and :using_index options."
end
options = options.dup
options[:name] ||= unique_constraint_name(table_name, column: column_name, **options)
options
end
#unique_constraints(table_name)
Returns an array of unique constraints for the given table. The unique constraints are represented as UniqueConstraintDefinition
objects.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 697
def unique_constraints(table_name)
scope = quoted_scope(table_name)
unique_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
SELECT c.conname, c.conrelid, c.conkey, c.condeferrable, c.condeferred, pg_get_constraintdef(c.oid) AS constraintdef
FROM pg_constraint c
JOIN pg_class t ON c.conrelid = t.oid
JOIN pg_namespace n ON n.oid = c.connamespace
WHERE c.contype = 'u'
AND t.relname = #{scope[:name]}
AND n.nspname = #{scope[:schema]}
SQL
unique_info.map do |row|
conkey = row["conkey"].delete("{}").split(",").map(&:to_i)
columns = column_names_from_column_numbers(row["conrelid"], conkey)
nulls_not_distinct = row["constraintdef"].start_with?("UNIQUE NULLS NOT DISTINCT")
deferrable = (row["condeferrable"], row["condeferred"])
options = {
name: row["conname"],
nulls_not_distinct: nulls_not_distinct,
deferrable: deferrable
}
UniqueConstraintDefinition.new(table_name, columns, options)
end
end
#update_table_definition(table_name, base)
This method is for internal use only.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 880
def update_table_definition(table_name, base) PostgreSQL::Table.new(table_name, base)
end
#validate_check_constraint(table_name, **options)
Validates the given check constraint.
validate_check_constraint :products, name: "price_check"
The options
hash accepts the same keys as add_check_constraint.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 926
def validate_check_constraint(table_name, **options)
chk_name_to_validate = check_constraint_for!(table_name, **options).name
validate_constraint table_name, chk_name_to_validate
end
#validate_constraint(table_name, constraint_name)
Validates the given constraint.
Validates the constraint named constraint_name
on accounts
.
validate_constraint :accounts, :constraint_name
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 893
def validate_constraint(table_name, constraint_name)
at = create_alter_table table_name
at.validate_constraint constraint_name
execute schema_creation.accept(at)
end
#validate_foreign_key(from_table, to_table = nil, **options)
Validates the given foreign key.
Validates the foreign key on accounts.branch_id
.
validate_foreign_key :accounts, :branches
Validates the foreign key on accounts.owner_id
.
validate_foreign_key :accounts, column: :owner_id
Validates the foreign key named special_fk_name
on the accounts
table.
validate_foreign_key :accounts, name: :special_fk_name
The options
hash accepts the same keys as #add_foreign_key.
[ GitHub ]
# File 'activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 915
def validate_foreign_key(from_table, to_table = nil, **options)
fk_name_to_validate = foreign_key_for!(from_table, to_table: to_table, **options).name
validate_constraint from_table, fk_name_to_validate
end