ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 371
        def bulk_change_table(table_name, operations)
          sql_fragments = []
          non_combinable_operations = []

          operations.each do |command, args|
            table, arguments = args.shift, args
            method = :"#{command}_for_alter"

            if respond_to?(method, true)
              sqls, procs = Array(send(method, table, *arguments)).partition { |v| v.is_a?(String) }
              sql_fragments << sqls
              non_combinable_operations.concat(procs)
            else
              execute "ALTER TABLE #{quote_table_name(table_name)} #{sql_fragments.join(", ")}" unless sql_fragments.empty?
              non_combinable_operations.each(&:call)
              sql_fragments = []
              non_combinable_operations = []
              send(command, table, *arguments)
            end
          end

          execute "ALTER TABLE #{quote_table_name(table_name)} #{sql_fragments.join(", ")}" unless sql_fragments.empty?
          non_combinable_operations.each(&:call)
        end

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

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

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

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

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

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

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

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

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

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

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

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

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 503
        def foreign_keys(table_name)
          scope = quoted_scope(table_name)
          fk_info = exec_query(<<-SQL.strip_heredoc, "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
            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|
            options = {
              column: row["column"],
              name: row["name"],
              primary_key: row["primary_key"]
            }

            options[:on_delete] = extract_foreign_key_action(row["on_delete"])
            options[:on_update] = extract_foreign_key_action(row["on_update"])
            options[:validate] = row["valid"]

            ForeignKeyDefinition.new(table_name, row["to_table"], options)
          end
        end

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 538
        def foreign_table_exists?(table_name)
          query_values(data_source_sql(table_name, type: "FOREIGN TABLE"), "SCHEMA").any? if table_name.present?
        end

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 534
        def foreign_tables
          query_values(data_source_sql(type: "FOREIGN TABLE"), "SCHEMA")
        end

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 67
        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 = 'i'
              AND i.relname = #{index[:name]}
              AND t.relname = #{table[:name]}
              AND n.nspname = #{index[:schema]}
          SQL
        end

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

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 402
        def rename_table(table_name, new_name)
          clear_cache!
          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
          pk, seq = pk_and_sequence_for(new_name)
          if 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

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

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

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

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

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

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 602
        def validate_constraint(table_name, constraint_name)
          return unless supports_validate_constraints?

          at = create_alter_table table_name
          at.validate_constraint constraint_name

          execute schema_creation.accept(at)
        end

# File activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb, line 626
        def validate_foreign_key(from_table, options_or_to_table = {})
          return unless supports_validate_constraints?

          fk_name_to_validate = foreign_key_for!(from_table, options_or_to_table).name

          validate_constraint from_table, fk_name_to_validate
        end