Module: ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
- Included in:
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
- Defined in:
- lib/active_record/connection_adapters/postgresql/schema_statements.rb
Instance Method Summary collapse
-
#add_column(table_name, column_name, type, **options) ⇒ Object
:nodoc:.
-
#add_exclusion_constraint(table_name, expression, **options) ⇒ Object
Adds a new exclusion constraint to the table.
- #add_foreign_key(from_table, to_table, **options) ⇒ Object
-
#add_index(table_name, column_name, **options) ⇒ Object
:nodoc:.
-
#add_index_options(table_name, column_name, **options) ⇒ Object
:nodoc:.
-
#add_unique_constraint(table_name, column_name = nil, **options) ⇒ Object
Adds a new unique constraint to the table.
-
#build_change_column_default_definition(table_name, column_name, default_or_changes) ⇒ Object
:nodoc:.
-
#build_change_column_definition(table_name, column_name, type, **options) ⇒ Object
Builds a ChangeColumnDefinition object.
-
#build_create_index_definition(table_name, column_name, **options) ⇒ Object
:nodoc:.
-
#change_column(table_name, column_name, type, **options) ⇒ Object
:nodoc:.
-
#change_column_comment(table_name, column_name, comment_or_changes) ⇒ Object
Adds comment for given table column or drops it if
comment
is anil
. -
#change_column_default(table_name, column_name, default_or_changes) ⇒ Object
Changes the default value of a table column.
-
#change_column_null(table_name, column_name, null, default = nil) ⇒ Object
:nodoc:.
-
#change_table_comment(table_name, comment_or_changes) ⇒ Object
Adds comment for given table or drops it if
comment
is anil
. -
#check_constraints(table_name) ⇒ Object
:nodoc:.
-
#client_min_messages ⇒ Object
Returns the current client message level.
-
#client_min_messages=(level) ⇒ Object
Set the client message level.
-
#collation ⇒ Object
Returns the current database collation.
-
#columns_for_distinct(columns, orders) ⇒ Object
PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and requires that the ORDER BY include the distinct column.
-
#create_database(name, options = {}) ⇒ Object
Create a new PostgreSQL database.
-
#create_schema(schema_name) ⇒ Object
Creates a schema for the given schema name.
-
#create_schema_dumper(options) ⇒ Object
:nodoc:.
-
#ctype ⇒ Object
Returns the current database ctype.
-
#current_database ⇒ Object
Returns the current database name.
-
#current_schema ⇒ Object
Returns the current schema name.
-
#default_sequence_name(table_name, pk = "id") ⇒ Object
Returns the sequence name for a table’s primary key or some other specified key.
-
#drop_database(name) ⇒ Object
Drops a PostgreSQL database.
-
#drop_schema(schema_name, **options) ⇒ Object
Drops the schema for the given schema name.
-
#drop_table(table_name, **options) ⇒ Object
:nodoc:.
-
#encoding ⇒ Object
Returns the current database encoding format.
-
#exclusion_constraint_options(table_name, expression, options) ⇒ Object
:nodoc:.
-
#exclusion_constraints(table_name) ⇒ Object
Returns an array of exclusion constraints for the given table.
-
#foreign_key_column_for(table_name, column_name) ⇒ Object
:nodoc:.
- #foreign_keys(table_name) ⇒ Object
- #foreign_table_exists?(table_name) ⇒ Boolean
- #foreign_tables ⇒ Object
-
#index_name(table_name, options) ⇒ Object
:nodoc:.
-
#index_name_exists?(table_name, index_name) ⇒ Boolean
Verifies existence of an index with a given name.
-
#indexes(table_name) ⇒ Object
Returns an array of indexes for the given table.
-
#pk_and_sequence_for(table) ⇒ Object
Returns a table’s primary key and belonging sequence.
-
#primary_keys(table_name) ⇒ Object
:nodoc:.
-
#quoted_include_columns_for_index(column_names) ⇒ Object
:nodoc:.
-
#recreate_database(name, options = {}) ⇒ Object
Drops the database specified on the
name
attribute and creates it again using the providedoptions
. -
#remove_exclusion_constraint(table_name, expression = nil, **options) ⇒ Object
Removes the given exclusion constraint from the table.
-
#remove_index(table_name, column_name = nil, **options) ⇒ Object
:nodoc:.
-
#remove_unique_constraint(table_name, column_name = nil, **options) ⇒ Object
Removes the given unique constraint from the table.
-
#rename_column(table_name, column_name, new_column_name) ⇒ Object
Renames a column in a table.
-
#rename_index(table_name, old_name, new_name) ⇒ Object
Renames an index of a table.
-
#rename_table(table_name, new_name, **options) ⇒ Object
Renames a table.
-
#reset_pk_sequence!(table, pk = nil, sequence = nil) ⇒ Object
Resets the sequence of a table’s primary key to the maximum value.
-
#schema_creation ⇒ Object
:nodoc:.
-
#schema_exists?(name) ⇒ Boolean
Returns true if schema exists.
-
#schema_names ⇒ Object
Returns an array of schema names.
-
#schema_search_path ⇒ Object
Returns the active schema search path.
-
#schema_search_path=(schema_csv) ⇒ Object
Sets the schema search path to a string of comma-separated schema names.
- #serial_sequence(table, column) ⇒ Object
-
#set_pk_sequence!(table, value) ⇒ Object
Sets the sequence of a table’s primary key to the specified value.
-
#table_comment(table_name) ⇒ Object
Returns a comment stored in database for given table.
-
#table_options(table_name) ⇒ Object
:nodoc:.
-
#type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil) ⇒ Object
Maps logical Rails types to PostgreSQL-specific data types.
-
#unique_constraint_options(table_name, column_name, options) ⇒ Object
:nodoc:.
-
#unique_constraints(table_name) ⇒ Object
Returns an array of unique constraints for the given table.
-
#update_table_definition(table_name, base) ⇒ Object
:nodoc:.
-
#validate_check_constraint(table_name, **options) ⇒ Object
Validates the given check constraint.
-
#validate_constraint(table_name, constraint_name) ⇒ Object
Validates the given constraint.
-
#validate_foreign_key(from_table, to_table = nil, **options) ⇒ Object
Validates the given foreign key.
Instance Method Details
#add_column(table_name, column_name, type, **options) ⇒ Object
:nodoc:
406 407 408 409 410 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 406 def add_column(table_name, column_name, type, **) # :nodoc: clear_cache! super change_column_comment(table_name, column_name, [:comment]) if .key?(:comment) end |
#add_exclusion_constraint(table_name, expression, **options) ⇒ Object
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 tofalse
.
693 694 695 696 697 698 699 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 693 def add_exclusion_constraint(table_name, expression, **) = (table_name, expression, ) at = create_alter_table(table_name) at.add_exclusion_constraint(expression, ) execute schema_creation.accept(at) end |
#add_foreign_key(from_table, to_table, **options) ⇒ Object
524 525 526 527 528 529 530 531 532 533 534 535 536 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 524 def add_foreign_key(from_table, to_table, **) if [:deferrable] == true ActiveRecord.deprecator.warn(<<~MSG) `deferrable: true` is deprecated in favor of `deferrable: :immediate`, and will be removed in Rails 7.2. MSG [:deferrable] = :immediate end assert_valid_deferrable([:deferrable]) super end |
#add_index(table_name, column_name, **options) ⇒ Object
:nodoc:
475 476 477 478 479 480 481 482 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 475 def add_index(table_name, column_name, **) # :nodoc: create_index = build_create_index_definition(table_name, column_name, **) result = execute schema_creation.accept(create_index) index = create_index.index execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.comment)}" if index.comment result end |
#add_index_options(table_name, column_name, **options) ⇒ Object
:nodoc:
888 889 890 891 892 893 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 888 def (table_name, column_name, **) # :nodoc: if (where = [:where]) && table_exists?(table_name) && column_exists?(table_name, where) [:where] = quote_column_name(where) end super end |
#add_unique_constraint(table_name, column_name = nil, **options) ⇒ Object
Adds a new unique constraint to the table.
add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_position"
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 tofalse
. :using_index
-
To specify an existing unique index name. Defaults to
nil
.
744 745 746 747 748 749 750 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 744 def add_unique_constraint(table_name, column_name = nil, **) = (table_name, column_name, ) at = create_alter_table(table_name) at.add_unique_constraint(column_name, ) execute schema_creation.accept(at) end |
#build_change_column_default_definition(table_name, column_name, default_or_changes) ⇒ Object
:nodoc:
435 436 437 438 439 440 441 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 435 def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc: column = column_for(table_name, column_name) return unless column default = extract_new_default_value(default_or_changes) ChangeColumnDefaultDefinition.new(column, default) end |
#build_change_column_definition(table_name, column_name, type, **options) ⇒ Object
Builds a ChangeColumnDefinition object.
This definition object contains information about the column change that would occur if the same arguments were passed to #change_column. See #change_column for information about passing a table_name
, column_name
, type
and other options that can be passed.
424 425 426 427 428 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 424 def build_change_column_definition(table_name, column_name, type, **) # :nodoc: td = create_table_definition(table_name) cd = td.new_column_definition(column_name, type, **) ChangeColumnDefinition.new(cd, column_name) end |
#build_create_index_definition(table_name, column_name, **options) ⇒ Object
:nodoc:
484 485 486 487 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 484 def build_create_index_definition(table_name, column_name, **) # :nodoc: index, algorithm, if_not_exists = (table_name, column_name, **) CreateIndexDefinition.new(index, algorithm, if_not_exists) end |
#change_column(table_name, column_name, type, **options) ⇒ Object
:nodoc:
412 413 414 415 416 417 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 412 def change_column(table_name, column_name, type, **) # :nodoc: clear_cache! sqls, procs = Array(change_column_for_alter(table_name, column_name, type, **)).partition { |v| v.is_a?(String) } execute "ALTER TABLE #{quote_table_name(table_name)} #{sqls.join(", ")}" procs.each(&:call) end |
#change_column_comment(table_name, column_name, comment_or_changes) ⇒ Object
Adds comment for given table column or drops it if comment
is a nil
455 456 457 458 459 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 455 def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc: clear_cache! comment = extract_new_comment_value(comment_or_changes) execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS #{quote(comment)}" end |
#change_column_default(table_name, column_name, default_or_changes) ⇒ Object
Changes the default value of a table column.
431 432 433 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 431 def change_column_default(table_name, column_name, default_or_changes) # :nodoc: execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_default_for_alter(table_name, column_name, default_or_changes)}" end |
#change_column_null(table_name, column_name, null, default = nil) ⇒ Object
:nodoc:
443 444 445 446 447 448 449 450 451 452 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 443 def change_column_null(table_name, column_name, null, default = nil) # :nodoc: 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_table_comment(table_name, comment_or_changes) ⇒ Object
Adds comment for given table or drops it if comment
is a nil
462 463 464 465 466 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 462 def change_table_comment(table_name, comment_or_changes) # :nodoc: clear_cache! comment = extract_new_comment_value(comment_or_changes) execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}" end |
#check_constraints(table_name) ⇒ Object
:nodoc:
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 591 def check_constraints(table_name) # :nodoc: 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| = { name: row["conname"], validate: row["valid"] } expression = row["constraintdef"][/CHECK \((.+)\)/m, 1] CheckConstraintDefinition.new(table_name, expression, ) end end |
#client_min_messages ⇒ Object
Returns the current client message level.
239 240 241 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 239 def query_value("SHOW client_min_messages", "SCHEMA") end |
#client_min_messages=(level) ⇒ Object
Set the client message level.
244 245 246 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 244 def (level) internal_execute("SET client_min_messages TO '#{level}'") end |
#collation ⇒ Object
Returns the current database collation.
191 192 193 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 191 def collation query_value("SELECT datcollate FROM pg_database WHERE datname = current_database()", "SCHEMA") end |
#columns_for_distinct(columns, orders) ⇒ Object
PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and requires that the ORDER BY include the distinct column.
819 820 821 822 823 824 825 826 827 828 829 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 819 def columns_for_distinct(columns, orders) # :nodoc: order_columns = orders.compact_blank.map { |s| # Convert Arel node to string s = visitor.compile(s) 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, "") }.compact_blank.map.with_index { |column, i| "#{column} AS alias_#{i}" } (order_columns << super).join(", ") end |
#create_database(name, options = {}) ⇒ Object
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'
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 22 def create_database(name, = {}) = { encoding: "utf8" }.merge!(.symbolize_keys) option_string = .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) ⇒ Object
Creates a schema for the given schema name.
212 213 214 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 212 def create_schema(schema_name) execute "CREATE SCHEMA #{quote_schema_name(schema_name)}" end |
#create_schema_dumper(options) ⇒ Object
:nodoc:
835 836 837 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 835 def create_schema_dumper() # :nodoc: PostgreSQL::SchemaDumper.create(self, ) end |
#ctype ⇒ Object
Returns the current database ctype.
196 197 198 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 196 def ctype query_value("SELECT datctype FROM pg_database WHERE datname = current_database()", "SCHEMA") end |
#current_database ⇒ Object
Returns the current database name.
176 177 178 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 176 def current_database query_value("SELECT current_database()", "SCHEMA") end |
#current_schema ⇒ Object
Returns the current schema name.
181 182 183 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 181 def current_schema query_value("SELECT current_schema", "SCHEMA") end |
#default_sequence_name(table_name, pk = "id") ⇒ Object
Returns the sequence name for a table’s primary key or some other specified key.
249 250 251 252 253 254 255 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 249 def default_sequence_name(table_name, pk = "id") # :nodoc: result = serial_sequence(table_name, pk) return nil unless result Utils.extract_schema_qualified_name(result).to_s rescue ActiveRecord::StatementInvalid PostgreSQL::Name.new(nil, "#{table_name}_#{pk}_seq").to_s end |
#drop_database(name) ⇒ Object
Drops a PostgreSQL database.
Example:
drop_database 'matt_development'
53 54 55 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 53 def drop_database(name) # :nodoc: execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}" end |
#drop_schema(schema_name, **options) ⇒ Object
Drops the schema for the given schema name.
217 218 219 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 217 def drop_schema(schema_name, **) execute "DROP SCHEMA#{' IF EXISTS' if [:if_exists]} #{quote_schema_name(schema_name)} CASCADE" end |
#drop_table(table_name, **options) ⇒ Object
:nodoc:
57 58 59 60 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 57 def drop_table(table_name, **) # :nodoc: schema_cache.clear_data_source_cache!(table_name.to_s) execute "DROP TABLE#{' IF EXISTS' if [:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if [:force] == :cascade}" end |
#encoding ⇒ Object
Returns the current database encoding format.
186 187 188 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 186 def encoding query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database()", "SCHEMA") end |
#exclusion_constraint_options(table_name, expression, options) ⇒ Object
:nodoc:
701 702 703 704 705 706 707 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 701 def (table_name, expression, ) # :nodoc: assert_valid_deferrable([:deferrable]) = .dup [:name] ||= exclusion_constraint_name(table_name, expression: expression, **) end |
#exclusion_constraints(table_name) ⇒ Object
Returns an array of exclusion constraints for the given table. The exclusion constraints are represented as ExclusionConstraintDefinition objects.
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 617 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 # strip 2 opening and closing parentheses deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"]) = { name: row["conname"], using: method_and_elements_parts["using"].to_sym, where: predicate, deferrable: deferrable } ExclusionConstraintDefinition.new(table_name, method_and_elements_parts["expression"], ) end end |
#foreign_key_column_for(table_name, column_name) ⇒ Object
:nodoc:
883 884 885 886 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 883 def foreign_key_column_for(table_name, column_name) # :nodoc: _schema, table_name = extract_schema_qualified_name(table_name) super end |
#foreign_keys(table_name) ⇒ Object
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 538 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 = { column: column, name: row["name"], primary_key: primary_key } [:on_delete] = extract_foreign_key_action(row["on_delete"]) [:on_update] = extract_foreign_key_action(row["on_update"]) [:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"]) [:validate] = row["valid"] ForeignKeyDefinition.new(table_name, to_table, ) end end |
#foreign_table_exists?(table_name) ⇒ Boolean
587 588 589 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 587 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 ⇒ Object
583 584 585 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 583 def foreign_tables query_values(data_source_sql(type: "FOREIGN TABLE"), "SCHEMA") end |
#index_name(table_name, options) ⇒ Object
:nodoc:
519 520 521 522 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 519 def index_name(table_name, ) # :nodoc: _schema, table_name = extract_schema_qualified_name(table_name.to_s) super end |
#index_name_exists?(table_name, index_name) ⇒ Boolean
Verifies existence of an index with a given name.
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
# File '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) ⇒ Object
Returns an array of indexes for the given table.
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 86 def indexes(table_name) # :nodoc: 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] comment = 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(&:strip) : [] if indkey.include?(0) columns = expressions else columns = column_names_from_column_numbers(oid, indkey) # prevent INCLUDE columns from being matched columns.reject! { |c| include_columns.include?(c) } # add info on sort order (only desc order is explicitly specified, asc is the default) # and non-default opclasses 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: comment.presence, valid: valid ) end end |
#pk_and_sequence_for(table) ⇒ Object
Returns a table’s primary key and belonging sequence.
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 305 def pk_and_sequence_for(table) # :nodoc: # First try looking for a sequence with a dependency on the # given table's primary key. 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) ⇒ Object
:nodoc:
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 358 def primary_keys(table_name) # :nodoc: 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) ⇒ Object
:nodoc:
895 896 897 898 899 900 901 902 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 895 def quoted_include_columns_for_index(column_names) # :nodoc: 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 (quoted_columns).values.join(", ") end |
#recreate_database(name, options = {}) ⇒ Object
Drops the database specified on the name
attribute and creates it again using the provided options
.
9 10 11 12 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 9 def recreate_database(name, = {}) # :nodoc: drop_database(name) create_database(name, ) end |
#remove_exclusion_constraint(table_name, expression = nil, **options) ⇒ Object
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.
716 717 718 719 720 721 722 723 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 716 def remove_exclusion_constraint(table_name, expression = nil, **) excl_name_to_delete = exclusion_constraint_for!(table_name, expression: expression, **).name at = create_alter_table(table_name) at.drop_exclusion_constraint(excl_name_to_delete) execute schema_creation.accept(at) end |
#remove_index(table_name, column_name = nil, **options) ⇒ Object
:nodoc:
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 489 def remove_index(table_name, column_name = nil, **) # :nodoc: table = Utils.extract_schema_qualified_name(table_name.to_s) if .key?(:name) provided_index = Utils.extract_schema_qualified_name([:name].to_s) [: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 [:if_exists] && !index_exists?(table_name, column_name, **) index_to_remove = PostgreSQL::Name.new(table.schema, index_name_for_remove(table.to_s, column_name, )) execute "DROP INDEX #{index_algorithm([:algorithm])} #{quote_table_name(index_to_remove)}" end |
#remove_unique_constraint(table_name, column_name = nil, **options) ⇒ Object
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.
771 772 773 774 775 776 777 778 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 771 def remove_unique_constraint(table_name, column_name = nil, **) unique_name_to_delete = unique_constraint_for!(table_name, column: column_name, **).name at = create_alter_table(table_name) at.drop_unique_constraint(unique_name_to_delete) execute schema_creation.accept(at) end |
#rename_column(table_name, column_name, new_column_name) ⇒ Object
Renames a column in a table.
469 470 471 472 473 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 469 def rename_column(table_name, column_name, new_column_name) # :nodoc: 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) ⇒ Object
Renames an index of a table. Raises error if length of new index name is greater than allowed limit.
512 513 514 515 516 517 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 512 def rename_index(table_name, old_name, new_name) validate_index_length!(table_name, new_name) schema, = extract_schema_qualified_name(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) ⇒ Object
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')
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 380 def rename_table(table_name, new_name, **) validate_table_length!(new_name) unless [:_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 # PostgreSQL automatically creates an index for PRIMARY KEY with name consisting of # truncated table name and "_pkey" suffix fitting into max_identifier_length number of characters. 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)}" # PostgreSQL automatically creates a sequence for PRIMARY KEY with name consisting of # truncated table name and "#{primary_key}_seq" suffix fitting into max_identifier_length number of characters. 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) end |
#reset_pk_sequence!(table, pk = nil, sequence = nil) ⇒ Object
Resets the sequence of a table’s primary key to the maximum value.
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 277 def reset_pk_sequence!(table, pk = nil, sequence = nil) # :nodoc: 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 ⇒ Object
:nodoc:
904 905 906 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 904 def schema_creation # :nodoc: PostgreSQL::SchemaCreation.new(self) end |
#schema_exists?(name) ⇒ Boolean
Returns true if schema exists.
63 64 65 |
# File '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 ⇒ Object
Returns an array of schema names.
201 202 203 204 205 206 207 208 209 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 201 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 |
#schema_search_path ⇒ Object
Returns the active schema search path.
234 235 236 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 234 def schema_search_path @schema_search_path ||= query_value("SHOW search_path", "SCHEMA") end |
#schema_search_path=(schema_csv) ⇒ Object
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.
226 227 228 229 230 231 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 226 def schema_search_path=(schema_csv) if schema_csv internal_execute("SET search_path TO #{schema_csv}") @schema_search_path = schema_csv end end |
#serial_sequence(table, column) ⇒ Object
257 258 259 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 257 def serial_sequence(table, column) query_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})", "SCHEMA") end |
#set_pk_sequence!(table, value) ⇒ Object
Sets the sequence of a table’s primary key to the specified value.
262 263 264 265 266 267 268 269 270 271 272 273 274 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 262 def set_pk_sequence!(table, value) # :nodoc: 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_comment(table_name) ⇒ Object
Returns a comment stored in database for given table
161 162 163 164 165 166 167 168 169 170 171 172 173 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 161 def table_comment(table_name) # :nodoc: scope = quoted_scope(table_name, type: "BASE TABLE") if scope[:name] query_value(<<~SQL, "SCHEMA") SELECT pg_catalog.obj_description(c.oid, 'pg_class') 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 end |
#table_options(table_name) ⇒ Object
:nodoc:
154 155 156 157 158 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 154 def (table_name) # :nodoc: if comment = table_comment(table_name) { comment: comment } end end |
#type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil) ⇒ Object
Maps logical Rails types to PostgreSQL-specific data types.
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 781 def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, enum_type: nil, **) # :nodoc: sql = \ case type.to_s when "binary" # PostgreSQL doesn't support limits on binary (bytea) columns. # The hard limit is 1GB, because of a 32-bit size field, and TOAST. 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" # PostgreSQL doesn't support limits on text columns. # The hard limit is 1GB, according to section 8.3 in the manual. 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_options(table_name, column_name, options) ⇒ Object
:nodoc:
752 753 754 755 756 757 758 759 760 761 762 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 752 def (table_name, column_name, ) # :nodoc: assert_valid_deferrable([:deferrable]) if column_name && [:using_index] raise ArgumentError, "Cannot specify both column_name and :using_index options." end = .dup [:name] ||= unique_constraint_name(table_name, column: column_name, **) end |
#unique_constraints(table_name) ⇒ Object
Returns an array of unique constraints for the given table. The unique constraints are represented as UniqueConstraintDefinition objects.
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 651 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 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) deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"]) = { name: row["conname"], deferrable: deferrable } UniqueConstraintDefinition.new(table_name, columns, ) end end |
#update_table_definition(table_name, base) ⇒ Object
:nodoc:
831 832 833 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 831 def update_table_definition(table_name, base) # :nodoc: PostgreSQL::Table.new(table_name, base) end |
#validate_check_constraint(table_name, **options) ⇒ Object
Validates the given check constraint.
validate_check_constraint :products, name: "price_check"
The options
hash accepts the same keys as add_check_constraint.
877 878 879 880 881 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 877 def validate_check_constraint(table_name, **) chk_name_to_validate = check_constraint_for!(table_name, **).name validate_constraint table_name, chk_name_to_validate end |
#validate_constraint(table_name, constraint_name) ⇒ Object
Validates the given constraint.
Validates the constraint named constraint_name
on accounts
.
validate_constraint :accounts, :constraint_name
844 845 846 847 848 849 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 844 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) ⇒ Object
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 SchemaStatements#add_foreign_key.
866 867 868 869 870 |
# File 'lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 866 def validate_foreign_key(from_table, to_table = nil, **) fk_name_to_validate = foreign_key_for!(from_table, to_table: to_table, **).name validate_constraint from_table, fk_name_to_validate end |