Module: ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
- Included in:
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
- Defined in:
- lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb
Instance Method Summary collapse
-
#add_column(table_name, column_name, type, **options) ⇒ Object
:nodoc:.
-
#add_index(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.
- #foreign_keys(table_name) ⇒ Object
- #foreign_table_exists?(table_name) ⇒ Boolean
- #foreign_tables ⇒ Object
-
#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:.
-
#recreate_database(name, options = {}) ⇒ Object
Drops the database specified on the
name
attribute and creates it again using the providedoptions
. -
#remove_index(table_name, column_name = nil, **options) ⇒ Object
:nodoc:.
-
#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) ⇒ 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_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.
-
#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:
396 397 398 399 400 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 396 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_index(table_name, column_name, **options) ⇒ Object
:nodoc:
444 445 446 447 448 449 450 451 452 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 444 def add_index(table_name, column_name, **) # :nodoc: index, algorithm, if_not_exists = (table_name, column_name, **) create_index = CreateIndexDefinition.new(index, algorithm, if_not_exists) result = execute schema_creation.accept(create_index) execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.comment)}" if index.comment result end |
#change_column(table_name, column_name, type, **options) ⇒ Object
:nodoc:
402 403 404 405 406 407 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 402 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
424 425 426 427 428 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 424 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.
410 411 412 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 410 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:
414 415 416 417 418 419 420 421 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 414 def change_column_null(table_name, column_name, null, default = nil) # :nodoc: 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)} #{change_column_null_for_alter(table_name, column_name, null, default)}" end |
#change_table_comment(table_name, comment_or_changes) ⇒ Object
Adds comment for given table or drops it if comment
is a nil
431 432 433 434 435 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 431 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:
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 524 def check_constraints(table_name) # :nodoc: scope = quoted_scope(table_name) check_info = exec_query(<<-SQL, "SCHEMA") 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.
237 238 239 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 237 def query_value("SHOW client_min_messages", "SCHEMA") end |
#client_min_messages=(level) ⇒ Object
Set the client message level.
242 243 244 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 242 def (level) execute("SET client_min_messages TO '#{level}'", "SCHEMA") end |
#collation ⇒ Object
Returns the current database collation.
189 190 191 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 189 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.
587 588 589 590 591 592 593 594 595 596 597 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 587 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/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/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.
210 211 212 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 210 def create_schema(schema_name) execute "CREATE SCHEMA #{quote_schema_name(schema_name)}" end |
#create_schema_dumper(options) ⇒ Object
:nodoc:
603 604 605 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 603 def create_schema_dumper() # :nodoc: PostgreSQL::SchemaDumper.create(self, ) end |
#ctype ⇒ Object
Returns the current database ctype.
194 195 196 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 194 def ctype query_value("SELECT datctype FROM pg_database WHERE datname = current_database()", "SCHEMA") end |
#current_database ⇒ Object
Returns the current database name.
174 175 176 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 174 def current_database query_value("SELECT current_database()", "SCHEMA") end |
#current_schema ⇒ Object
Returns the current schema name.
179 180 181 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 179 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.
247 248 249 250 251 252 253 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 247 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/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/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.
215 216 217 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 215 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/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/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.
184 185 186 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 184 def encoding query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database()", "SCHEMA") end |
#foreign_keys(table_name) ⇒ Object
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 483 def foreign_keys(table_name) scope = quoted_scope(table_name) fk_info = exec_query(<<~SQL, "SCHEMA") 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 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| = { column: row["column"], name: row["name"], primary_key: row["primary_key"] } [:on_delete] = extract_foreign_key_action(row["on_delete"]) [:on_update] = extract_foreign_key_action(row["on_update"]) [:deferrable] = extract_foreign_key_deferrable(row["deferrable"], row["deferred"]) [:validate] = row["valid"] ForeignKeyDefinition.new(table_name, row["to_table"], ) end end |
#foreign_table_exists?(table_name) ⇒ Boolean
520 521 522 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 520 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
516 517 518 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 516 def foreign_tables query_values(data_source_sql(type: "FOREIGN TABLE"), "SCHEMA") 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/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/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 = i.relnamespace WHERE i.relkind IN ('i', 'I') AND i.relname = #{index[:name]} AND t.relname = #{table[:name]} AND n.nspname = #{index[: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 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/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 FROM pg_class t INNER JOIN pg_index d ON t.oid = d.indrelid INNER JOIN pg_class i ON d.indexrelid = i.oid LEFT JOIN pg_namespace n ON n.oid = i.relnamespace WHERE i.relkind 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] using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/m).flatten orders = {} opclasses = {} if indkey.include?(0) columns = expressions else columns = Hash[query(<<~SQL, "SCHEMA")].values_at(*indkey).compact SELECT a.attnum, a.attname FROM pg_attribute a WHERE a.attrelid = #{oid} AND a.attnum IN (#{indkey.join(",")}) SQL # 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)?\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, comment: comment.presence ) end end |
#pk_and_sequence_for(table) ⇒ Object
Returns a table’s primary key and belonging sequence.
303 304 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 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 303 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' 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:
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 356 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 |
#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/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 9 def recreate_database(name, = {}) # :nodoc: drop_database(name) create_database(name, ) end |
#remove_index(table_name, column_name = nil, **options) ⇒ Object
:nodoc:
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 454 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 |
#rename_column(table_name, column_name, new_column_name) ⇒ Object
Renames a column in a table.
438 439 440 441 442 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 438 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.
477 478 479 480 481 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 477 def rename_index(table_name, old_name, new_name) validate_index_length!(table_name, new_name) execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}" end |
#rename_table(table_name, new_name) ⇒ 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')
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 378 def rename_table(table_name, new_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 idx = "#{table_name}_pkey" new_idx = "#{new_name}_pkey" execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}" if seq && seq.identifier == "#{table_name}_#{pk}_seq" new_seq = "#{new_name}_#{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.
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 275 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 >= 100000 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 ? max_pk : minvalue}, #{max_pk ? true : false})", "SCHEMA") end end |
#schema_exists?(name) ⇒ Boolean
Returns true if schema exists.
63 64 65 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/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.
199 200 201 202 203 204 205 206 207 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 199 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.
232 233 234 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 232 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.
224 225 226 227 228 229 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 224 def schema_search_path=(schema_csv) if schema_csv execute("SET search_path TO #{schema_csv}", "SCHEMA") @schema_search_path = schema_csv end end |
#serial_sequence(table, column) ⇒ Object
255 256 257 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 255 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.
260 261 262 263 264 265 266 267 268 269 270 271 272 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 260 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
159 160 161 162 163 164 165 166 167 168 169 170 171 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 159 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:
152 153 154 155 156 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 152 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.
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 582 583 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 549 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 |
#update_table_definition(table_name, base) ⇒ Object
:nodoc:
599 600 601 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 599 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.
645 646 647 648 649 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 645 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
612 613 614 615 616 617 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 612 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.
634 635 636 637 638 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/activerecord-7.0.4/lib/active_record/connection_adapters/postgresql/schema_statements.rb', line 634 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 |