PostgreSQL
 sql >> Base de Dados >  >> RDS >> PostgreSQL

Como criar e excluir bancos de dados e tabelas no PostgreSQL


Introdução


PostgreSQL e outros sistemas de gerenciamento de banco de dados relacional usam bancos de dados e tabelas estruturar e organizar seus dados. Podemos rever a definição desses dois termos rapidamente:
  • bancos de dados: separar diferentes conjuntos de estruturas e dados uns dos outros
  • tabelas: definir a estrutura de dados e armazenar os valores de dados reais em bancos de dados

No PostgreSQL, também existe um objeto intermediário entre bancos de dados e tabelas chamado schema :
  • esquema: um namespace em um banco de dados que contém tabelas, índices, exibições e outros itens.



Este guia não trata diretamente do conceito de esquema do PostgreSQL, mas é bom saber que ele está lá.

Em vez disso, vamos nos concentrar em como criar e destruir bancos de dados e tabelas PostgreSQL. Os exemplos usarão principalmente SQL, mas no final, mostraremos como fazer algumas dessas tarefas usando a linha de comando. Essas alternativas usam ferramentas incluídas na instalação padrão do PostgreSQL que estão disponíveis se você tiver acesso administrativo ao host PostgreSQL.

Algumas das instruções abordadas neste guia, particularmente o PostgreSQL CREATE TABLE declaração, têm muitas opções adicionais que estavam fora do escopo deste artigo. Se você quiser informações adicionais, saiba mais consultando a documentação oficial do PostgreSQL.


Pré-requisitos


Para seguir este guia, você precisará fazer login em uma instância do PostgreSQL com um usuário com privilégios administrativos usando o psql cliente de linha de comando. Sua instância do PostgreSQL pode ser instalada localmente, remotamente ou provisionada por um provedor.

Especificamente, seu usuário do PostgreSQL precisará do CREATE DB privilégio ou seja um Superuser , que você pode verificar com o \du meta-comando em psql :
\du
 
                                   List of roles Role name |                         Attributes                         | Member of-----------+------------------------------------------------------------+----------- postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}

O postgres superusuário, que é criado automaticamente na instalação, tem os privilégios necessários, mas você pode usar qualquer usuário com o Create DB privilégio.


Criar um novo banco de dados


Assim que estiver conectado à sua instância do PostgreSQL usando psql ou qualquer outro cliente SQL, você pode criar um banco de dados usando SQL.

A sintaxe básica para criar um banco de dados é:
CREATE DATABASE db_name;

Isso criará um banco de dados chamado db_name no servidor atual com o usuário atual definido como proprietário do novo banco de dados usando as configurações padrão do banco de dados. Você pode ver as propriedades do padrão template1 template usando o seguinte psql meta-comando:
\l template1
 
                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +           |          |          |             |             | postgres=CTc/postgres(1 row)

Você pode adicionar parâmetros adicionais para alterar a forma como seu banco de dados é criado. Estas são algumas opções comuns:
  • CODIFICAÇÃO: define a codificação de caracteres para o banco de dados.
  • LC_COLLATE: define o agrupamento , ou classificar, ordem para o banco de dados. Esta é uma opção de localização que determina como os itens são organizados quando são pedidos.
  • LC_CTYPE: define a classificação de caracteres para o novo banco de dados. Esta é uma opção de localização que afeta quais caracteres são considerados maiúsculas, minúsculas e dígitos.

Isso pode ajudar a garantir que o banco de dados possa armazenar dados nos formatos que você planeja oferecer suporte e com as preferências de localização do seu projeto.

Por exemplo, para garantir que seu banco de dados seja criado com suporte a Unicode e substituir a própria localidade do servidor para usar a localização em inglês americano (todos eles correspondem aos valores no template1 mostrado acima, então nenhuma mudança realmente ocorrerá), você pode digitar:
CREATE DATABASE db_name  ENCODING 'UTF8'  LC_COLLATE 'en_US.UTF-8'  LC_CTYPE 'en_US.UTF-8';

Para acompanhar os exemplos deste guia, crie um banco de dados chamado school usando as configurações de localidade padrão da sua instância e a codificação de caracteres UTF8:
CREATE DATABASE school ENCODING 'UTF8';

Isso criará seu novo banco de dados usando as especificações que você forneceu.


Lista de bancos de dados existentes


Para determinar quais bancos de dados estão atualmente disponíveis em seu servidor ou cluster, você pode usar a seguinte instrução SQL:
SELECT datname FROM pg_database;

Isso listará cada um dos bancos de dados atualmente definidos no ambiente:
  datname----------- _dodb template1 template0 defaultdb school(5 rows)

Como mencionado anteriormente, se você estiver conectado usando o psql cliente, você também pode obter essas informações \l meta-comando:
\l

Isso mostrará os nomes de banco de dados disponíveis junto com seus proprietários, codificação, configurações de localidade e privilégios:
                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +           |          |          |             |             | postgres=CTc/postgres template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +           |          |          |             |             | postgres=CTc/postgres(5 rows)

A school banco de dados que criamos é exibido entre os outros bancos de dados no sistema. Essa é uma boa maneira de obter uma visão geral dos bancos de dados em seu servidor ou cluster.


Criar tabelas dentro de bancos de dados


Após criar um ou mais bancos de dados, você pode começar a definir tabelas para armazenar seus dados. As tabelas consistem em um nome e um esquema definido que determina os campos e tipos de dados que cada registro deve conter.

PostgreSQL CREATE TABLE sintaxe


Você pode criar tabelas usando o CREATE TABLE demonstração. Uma sintaxe básica simplificada para o comando se parece com o seguinte:
CREATE TABLE table_name (    column_name TYPE [column_constraint],    [table_constraint,]);

Os componentes da sintaxe acima incluem o seguinte:
  • CREATE TABLE table_name :A instrução de criação básica que sinaliza que você deseja definir uma tabela. O table_name placeholder deve ser substituído pelo nome da tabela que você deseja usar.
  • column_name TYPE :define uma coluna básica dentro da tabela. O column_name placeholder deve ser substituído pelo nome que você deseja usar para sua coluna. O TYPE especifica o tipo de dados PostgreSQL para a coluna. Os dados armazenados na tabela devem estar em conformidade com a estrutura da coluna e os tipos de dados da coluna para serem aceitos.
  • column_constraint :As restrições de coluna são restrições opcionais para adicionar mais restrições aos dados que podem ser armazenados na coluna. Por exemplo, você pode exigir que as entradas não sejam nulas, únicas ou números inteiros positivos.
  • table_constraints :as restrições de tabela são semelhantes às restrições de coluna, mas envolvem a interação de várias colunas. Por exemplo, você pode ter uma restrição de tabela que verifica se um DATE_OF_BIRTH é anterior a DATE_OF_DEATH em uma tabela.


Criar tabelas condicionalmente com o IF NOT EXISTS cláusula


Por padrão, se você tentar criar uma tabela no PostgreSQL que já exista no banco de dados, ocorrerá um erro. Para contornar este problema nos casos em que você deseja criar uma tabela se ela não estiver presente, mas apenas continuar se ela já existir, você pode usar o IF NOT EXISTS cláusula. O IF NOT EXISTS qualificador opcional que diz ao PostgreSQL para ignorar a instrução se o banco de dados já existir.

Para usar o IF NOT EXISTS cláusula, insira-a no comando após o CREATE TABLE sintaxe e antes do nome da tabela:
CREATE TABLE IF NOT EXISTS table_name (    column_name TYPE [column_constraint],    [table_constraint,]);

Esta variante tentará criar a tabela. Se uma tabela com esse nome já existir no banco de dados especificado, o PostgreSQL emitirá um aviso indicando que o nome da tabela já foi usado em vez de falhar com um erro.


Como criar tabelas no PostgreSQL


A sintaxe acima é suficiente para criar tabelas básicas. Como exemplo, criaremos duas tabelas em nossa school base de dados. Uma tabela será chamada de supplies e o outro será chamado de teachers :



Nos supplies tabela, queremos ter os seguintes campos:
  • ID: Um ID exclusivo para cada tipo de material escolar.
  • Nome: O nome de um item escolar específico.
  • Descrição: Uma breve descrição do item.
  • Fabricante: O nome do fabricante do item.
  • Cor: A cor do item.
  • Inventário: O número de itens que temos para um determinado tipo de material escolar. Isso nunca deve ser menor que 0.

Podemos criar os supplies tabela com as qualidades acima usando o seguinte SQL.

Primeiro, mude para a school banco de dados que você criou com psql digitando:
\c school

Isso mudará o banco de dados que nossos comandos futuros terão como alvo. Seu prompt deve mudar para refletir o banco de dados.

Em seguida, crie os supplies tabela com a seguinte afirmação:
CREATE TABLE supplies (  id INT PRIMARY KEY,  name VARCHAR,  description VARCHAR,  manufacturer VARCHAR,  color VARCHAR,  inventory int CHECK (inventory > 0));

Isso criará os supplies tabela dentro da school base de dados. A PRIMARY KEY restrição de coluna é uma restrição especial usada para indicar colunas que podem identificar exclusivamente registros dentro da tabela. Como tal, a restrição especifica que a coluna não pode ser nula e deve ser exclusiva. O PostgreSQL cria índices para colunas de chave primária para aumentar a velocidade de consulta.

Verifique se a nova tabela está presente digitando:
\dt
 
          List of relations Schema |   Name   | Type  |  Owner  --------+----------+-------+--------- public | supplies | table | doadmin(1 row)

Verifique se o esquema reflete o design pretendido digitando:
\d supplies
 
                      Table "public.supplies"    Column    |       Type        | Collation | Nullable | Default--------------+-------------------+-----------+----------+--------- id           | integer           |           | not null | name         | character varying |           |          | description  | character varying |           |          | manufacturer | character varying |           |          | color        | character varying |           |          | inventory    | integer           |           |          |Indexes:    "supplies_pkey" PRIMARY KEY, btree (id)Check constraints:    "supplies_inventory_check" CHECK (inventory > 0)

Podemos ver cada uma das colunas e tipos de dados que especificamos. A restrição de coluna que definimos para o inventory coluna é listada no final.

Em seguida, criaremos um teachers tabela. Nesta tabela, as seguintes colunas devem estar presentes:
  • ID do funcionário :um número de identificação de funcionário exclusivo.
  • Nome :o primeiro nome do professor.
  • Sobrenome :o sobrenome do professor.
  • Assunto :o assunto que o professor é contratado para ensinar.
  • Nível da série :a série dos alunos que o professor é contratado para ensinar.

Crie os teachers table com o esquema acima com o seguinte SQL:
CREATE TABLE teachers (  id INT PRIMARY KEY,  first_name VARCHAR,  last_name VARCHAR,  subject VARCHAR,  grade_level int);


Como criar tabelas com chaves primárias e chaves estrangeiras


Você pode encontrar informações sobre como criar tabelas com chaves primárias e estrangeiras em alguns de nossos outros guias do PostgreSQL. Chaves primárias e chaves estrangeiras são tipos de restrição de banco de dados no PostgreSQL.

Uma chave primária é uma coluna ou coluna especial com garantia de exclusividade nas linhas da mesma tabela. Todas as chaves primárias podem ser usadas para identificar exclusivamente uma linha específica. As chaves primárias não apenas garantem que cada linha tenha um valor exclusivo para as colunas de chave primária, mas também garantem que nenhuma linha contenha NULL valores para essa coluna. Freqüentemente, a chave primária no PostgreSQL usa o seguinte formato para especificar uma chave primária de incremento atribuída automaticamente:id SERIAL PRIMARY KEY .

As chaves estrangeiras são uma maneira de garantir que uma coluna ou colunas em uma tabela correspondam aos valores contidos em outra tabela. Isso ajuda a garantir a integridade referencial entre as tabelas.



Como visualizar tabelas no PostgreSQL


No PostgreSQL, você pode listar tabelas de algumas maneiras diferentes, dependendo de quais informações você está procurando.

Se você quiser ver quais tabelas estão disponíveis em seu banco de dados, você pode usar o \dt meta-comando incluído com o psql client para listar todas as tabelas, como demonstramos acima:
\dt
 
          List of relations Schema |   Name   | Type  |  Owner--------+----------+-------+--------- public | supplies | table | doadmin public | teachers | table | doadmin(2 rows)

Você também pode verificar se o esquema da tabela corresponde às suas especificações:
\d teachers
 
                     Table "public.teachers"   Column    |       Type        | Collation | Nullable | Default-------------+-------------------+-----------+----------+--------- id          | integer           |           | not null | first_name  | character varying |           |          | last_name   | character varying |           |          | subject     | character varying |           |          | grade_level | integer           |           |          |Indexes:    "teachers_pkey" PRIMARY KEY, btree (id)

Os teachers tabela parece corresponder à nossa definição.


Alterar tabelas


Se você precisar alterar o esquema de uma tabela existente no PostgreSQL, você pode usar o ALTER TABLE comando. A ALTER TABLE comando é muito semelhante ao CREATE TABLE comando, mas opera em uma tabela existente.

Alterar sintaxe da tabela


A sintaxe básica para modificar tabelas no PostgreSQL é assim:
ALTER TABLE <table_name> <change_command> <change_parameters>

O <change_command> indica o tipo exato de alteração que você gostaria de fazer, se envolve definir opções diferentes na tabela, adicionar ou remover colunas ou alterar tipos ou restrições. O <change_parameters> parte do comando contém qualquer informação adicional que o PostgreSQL precisa para completar a mudança.


Adicionar colunas a tabelas


Você pode adicionar uma coluna a uma tabela PostgreSQL com o comando ADD COLUMN comando de mudança. Os parâmetros de alteração incluirão o nome da coluna, o tipo e as opções, assim como você os especificaria no CREATE TABLE comando.

Por exemplo, para adicionar uma coluna chamada missing_column do text digite para uma tabela chamada some_table , você digitaria:
ALTER TABLE some_table ADD COLUMN missing_column text;


Removendo colunas de tabelas


Se, em vez disso, você quiser remover uma coluna existente, poderá usar o DROP COLUMN comando em vez disso. Você precisa especificar o nome da coluna que deseja remover como parâmetro de alteração:
ALTER TABLE some_table DROP COLUMN useless_column;


Alterando o tipo de dados de uma coluna


Para alterar o tipo de dados que o PostgreSQL usa para uma coluna específica, você pode usar ALTER COLUMN comando de mudança com o SET DATA TYPE comando de coluna. Os parâmetros incluem o nome da coluna, seu novo tipo e um opcional USING cláusula para especificar como o tipo antigo deve ser convertido para o novo tipo.

Por exemplo, para definir o valor de um id coluna no resident tabela para um int usando uma conversão explícita, podemos digitar o seguinte:
ALTER TABLE resident ALTER COLUMN id SET DATA TYPE int USING id::int;


Outras alterações de tabela


Muitos outros tipos de mudanças podem ser alcançados com o ALTER TABLE comando. Para mais informações sobre as opções disponíveis, confira a documentação oficial do PostgreSQL para ALTER TABLE .



Soltar tabelas


Se você deseja excluir uma tabela, você pode usar o DROP TABLE instrução SQL. Isso excluirá a tabela, bem como todos os dados armazenados nela.

A sintaxe básica fica assim:
DROP TABLE table_name;

Isso excluirá a tabela se ela existir e gerará um erro se o nome da tabela não existir.

Se você deseja excluir a tabela se ela existir e não fazer nada se ela não existir, você pode incluir o IF EXISTS qualificador dentro da declaração:
DROP TABLE IF EXISTS table_name;

As tabelas que têm dependências de outras tabelas ou objetos não podem ser excluídas por padrão enquanto essas dependências existirem. Para evitar o erro, você pode incluir opcionalmente o CASCADE parâmetro, que descarta automaticamente quaisquer dependências junto com a tabela:
DROP TABLE table_name CASCADE;

Se alguma tabela tiver uma chave estrangeira restrição, que faz referência à tabela que você está excluindo, essa restrição será excluída automaticamente.

Exclua os supplies tabela que criamos anteriormente digitando:
DROP TABLE supplies;

Manteremos os teachers database para demonstrar que a instrução para excluir bancos de dados também remove todos os objetos filho, como tabelas.


Descartar bancos de dados


O DROP DATABASE instrui o PostgreSQL a deletar o banco de dados especificado. A sintaxe básica fica assim:
DROP DATABASE database_name;

Substitua o database_name placeholder com o nome do banco de dados que você deseja remover. Isso excluirá o banco de dados se ele for encontrado. Se o banco de dados não puder ser encontrado, ocorrerá um erro:
DROP DATABASE some_database;
 
ERROR:  database "some_database" does not exist

Se você deseja excluir o banco de dados se ele existir e não fazer nada, inclua o opcional IF EXISTS opção:
DROP DATABASE IF EXISTS some_database;
 
NOTICE:  database "some_database" does not exist, skippingDROP DATABASE

Isso removerá o banco de dados ou não fará nada se ele não puder ser encontrado.

Para remover a school banco de dados que usamos neste guia, liste os bancos de dados existentes em seu sistema:
\l
 
                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +           |          |          |             |             | postgres=CTc/postgres template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +           |          |          |             |             | postgres=CTc/postgres(5 rows)

Abra uma nova conexão com um dos bancos de dados que você não deseja excluir:
\c defaultdb

Quando a nova conexão for aberta, exclua a school banco de dados com o seguinte comando:
DROP DATABASE school;

Isso removerá a school banco de dados junto com os teachers tabela definida dentro.

Se você tem acompanhado o SQL, pode terminar aqui ou pular para a conclusão. Se você quiser aprender sobre como criar e excluir bancos de dados da linha de comando, continue na próxima seção.


Usando ferramentas de linha de comando administrativas para criar e excluir bancos de dados


Se você tiver acesso shell ao servidor ou cluster em que o PostgreSQL está instalado, poderá ter acesso a algumas ferramentas de linha de comando adicionais que podem ajudar a criar e excluir bancos de dados. O createdb e dropdb comandos são empacotados com o PostgreSQL quando ele é instalado.

Criar um novo banco de dados a partir da linha de comando


A sintaxe básica para o createdb comando (que deve ser executado por um usuário do sistema com acesso de administrador ao PostgreSQL) é:
createdb db_name

Isso criará um banco de dados chamado db_name dentro do PostgreSQL usando as configurações padrão.

O comando também aceita opções para alterar seu comportamento, bem como a variante SQL que você viu anteriormente. Você pode descobrir mais sobre essas opções com man createdb . Algumas das opções mais importantes são:
  • --encoding= :define a codificação de caracteres para o banco de dados.
  • --locale= :define a localidade do banco de dados.

Isso pode ajudar a garantir que o banco de dados possa armazenar dados nos formatos que você planeja oferecer suporte e com as preferências de localização do seu projeto.

Por exemplo, para garantir que seu banco de dados seja criado com suporte a Unicode e substituir a própria localidade do servidor para usar a localização em inglês americano, você pode digitar:
createdb --encoding=UTF8 --locale=en_US db_name

Supondo que você tenha as permissões corretas, o banco de dados será criado de acordo com suas especificações.

Para acompanhar os exemplos deste guia, você pode criar um banco de dados chamado school usando a localidade padrão e a codificação de caracteres UTF8 digitando:
createdb --encoding=UTF8 school

Você pode então se conectar ao banco de dados usando psql para configurar suas tabelas como de costume.


Solte bancos de dados da linha de comando


O dropdb comando espelha o DROP DATABASE instrução SQL. Possui a seguinte sintaxe básica:
dropdb database_name

Altere o database_name placeholder para referenciar o banco de dados que você deseja excluir.

Por padrão, este comando resultará em um erro se o banco de dados especificado não puder ser encontrado. Para evitar isso, você pode incluir o opcional --if-exists bandeira:
dropdb --if-exists database_name

Isso excluirá o banco de dados especificado, se ele existir. Caso contrário, não fará nada.

Para excluir a school banco de dados que criamos anteriormente, digite:
dropdb school

Isso removerá o banco de dados e quaisquer elementos filhos, como tabelas, dentro dele.



Conclusão


Este artigo abordou os conceitos básicos de como criar e excluir bancos de dados e tabelas no PostgreSQL. Estes são alguns dos comandos mais básicos necessários para configurar um sistema de banco de dados e definir a estrutura de seus dados.

Como mencionado anteriormente, as instruções SQL abordadas neste tutorial do PostgreSQL, particularmente o CREATE TABLE declaração, tem muitos parâmetros adicionais que podem ser usados ​​para alterar o comportamento do PostgreSQL. Você pode descobrir mais sobre isso consultando a documentação oficial do PostgreSQL.