Introdução

Nós escrevemos este pequeno livro para aqueles que apenas começam familiarizando-se com o
mundo do PostgreSQL. A partir de neste livro, você aprenderá:

• PostgreSQL - do que se trata ____________________________________________________ 2

• Instalação em Linux e Windows ________________________________________________ . 14
• Conectando-se a um servidor, escrevendo consultas SQL, e usando transações __________ p.27
• Aprender SQL em um banco de dados de demonstração ____________________________ .56
• Sobre os recursos de pesquisa de texto completo __________________________________ p.85
• Trabalhar com dados JSON ___________________________________________________ p.93
• Usando PostgreSQL com seu aplicativo ________________________________________ p. 102
• Sobre um aplicativo pgAdmin útil ______________________________________________ p.116
• Documentação e treinamentos ________________________________________________ p.124
• Acompanhar todas as atualizações _____________________________________________ p.135
• Sobre a empresa Postgres Professional ________________________________________ p .138

Esperamos que nosso livro faça sua primeira experiência com PostgreSQL mais agradável e ajuda
você a se misturar a comunidade PostgreSQL.
Uma cópia eletrônica deste livro está disponível em postgrespro.com/educação / introbook.
Boa sorte!
Sobre PostgreSQL
PostgreSQL é o código aberto mais rico em recursos DBMS. Desenvolvido em ambiente acadêmico,
este SGBD reuniu uma ampla comunidade de desenvolvedores por meio de sua longa história. Hoje
em dia, o PostgreSQL oferece todas as funções nacionalidade exigida pela maioria dos clientes e é
ativamente usada em todo o mundo para criar alta carga crítica para os negócios sistemas.

Um pouco de história
O PostgreSQL moderno se origina do projeto POSTGRES, que foi liderado por Michael Stonebraker,
professor da Universidade da California, Berkeley. Antes deste trabalho, Michael Stonebraker estava
gerenciando o desenvolvimento do INGRES.
Foi um dos primeiros DBMS relacionais, e o POSTGRES apareceu como resultado de repensar todo
o trabalho anterior e o desejo de superar as limitações de seu rígido sistema de tipo.
O projeto foi iniciado em 1985 e, em 1988, vários artigos científicos publicados que descreviam o
modelo de dados, linguagem de consulta POSTQUEL (SQL não era um 2
padrão aceito na época), e estrutura de armazenamento de dados
ture.
POSTGRES às vezes é considerado um dos chamados
DBMS pós-relacional. As restrições do modelo relacional tinham
sempre foi criticado, sendo o outro lado do seu rigor
e simplicidade. No entanto, a disseminação da tecnologia de informática
ogia em todas as esferas da vida exigia novas aplicações, e
os bancos de dados tiveram que suportar novos tipos de dados e tal
recursos como herança ou criação e gerenciamento de
objetos complexos.
A primeira versão deste DBMS apareceu em 1989. Os dados
base estava sendo melhorada por vários anos, mas em 1993,
quando a versão 4.2 foi lançada, o projeto foi encerrado.
No entanto, apesar do cancelamento oficial, o código aberto
e licença BSD permitida aos ex-alunos da UC Berkeley, Andrew Yu
e Jolly Chen, para retomar seu desenvolvimento em 1994. Eles
substituiu a linguagem de consulta POSTQUEL por SQL, que tinha
tornou-se um padrão geralmente aceito naquela época. o
projeto foi renomeado para Postgres95.
Em 1996, tornou-se óbvio que o nome Postgres95
não resistiria ao teste do tempo, e um novo nome foi
selecionado: PostgreSQL. Este nome reflete a conexão
entre o projeto POSTGRES original e a adoção de SQL.
É por isso que PostgreSQL é pronunciado como “Post-Gres-QL,”
ou simplesmente “postgres”, mas não “postgre”.
O primeiro lançamento do PostgreSQL tinha a versão 6.0, mantendo o
esquema de numeração original. O projeto cresceu, e seu
a gestão foi assumida inicialmente por um pequeno grupo
3

Página 5
de usuários e desenvolvedores ativos, que foi denominado “Pós-
greSQL Global Development Group. ”
Desenvolvimento
A equipe principal do projeto toma todas as decisões principais
sobre o desenvolvimento e lançamento de novas versões do PostgreSQL.
No momento, a equipe é composta por cinco pessoas.
Além dos desenvolvedores que contribuem com o projeto
de vez em quando, há um grupo de desenvolvedores principais
que fizeram uma contribuição significativa para o PostgreSQL.
Eles são chamados de contribuintes principais. Há também um grupo
de committers que têm acesso de gravação à fonte
repositório de código. Os membros do grupo mudam com o tempo, novos
desenvolvedores ingressam na comunidade, outros abandonam o projeto.
Para a lista atual de desenvolvedores, consulte o PostgreSQL oficial
site: www.postgresql.org.
O ciclo de lançamento do PostgreSQL geralmente leva cerca de um ano. Dentro
neste período, a comunidade recebe patches com bug
correções, atualizações e novos recursos de todos os dispostos
contribuir. Tradicionalmente, todos os patches são discutidos em
a lista de discussão pgsql-hackers. Se a comunidade encontrar o
ideia útil, sua implementação está correta e o código
passa por uma revisão de código obrigatória por outros desenvolvedores, o
patch está incluído na próxima versão.
Em algum ponto, a estabilização do código é anunciada: tudo novo
os recursos são adiados para a próxima versão; único bug
correções e melhorias para os patches já incluídos
4

Página 6
são aceitos. Dentro do ciclo de lançamento, as versões beta ap-
pera. Mais perto do final do ciclo de lançamento, um lançamento
candidato é construído, e logo uma nova versão principal do Post-
greSQL é lançado.
O número da versão principal costumava consistir em dois números
bers, mas em 2017 decidiu-se começar a usar um único
número. Assim, a versão 9.6 foi seguida pelo PostgreSQL 10,
que é a versão mais recente do produto agora. Nas próximas
o lançamento principal está planejado para o outono de 2018; será Post-
greSQL 11.
Conforme a nova versão está sendo desenvolvida, os desenvolvedores descobrem
e consertar bugs nele. As correções mais críticas são backported
às versões anteriores. Como o número dessas correções será
vem significativo, a comunidade lança versões menores,
que são compatíveis com os principais correspondentes.
Por exemplo, a versão 9.6.3 contém correções de bug para 9.6, enquanto
10.2 fornece correções para PostgreSQL 10.
Apoio, suporte
PostgreSQL Global Development Group oferece suporte principal
lançamentos por cinco anos. Suporte e desenvolvimento
são gerenciados por meio de listas de discussão. Um bug arquivado corretamente
relatório tem todas as chances de ser resolvido muito rápido: bug
as correções costumam ser lançadas em 24 horas.
Além do apoio da comunidade, uma série de empresas
nies em todo o mundo fornecem suporte comercial 24x7
5

Página 7
para PostgreSQL, incluindo Postgres Profes da Rússia
sional (www.postgrespro.com) .
Estado atual
PostgreSQL é um dos bancos de dados mais populares. Sediada
na base sólida do desenvolvimento acadêmico, sobre
seus 20 anos de história PostgreSQL evoluiu para uma empresa
DBMS de nível de prêmio que agora é uma alternativa real para comp
bases de dados comerciais. Você pode ver por si mesmo olhando
nos principais recursos do PostgreSQL 10, que é o mais recente
versão lançada agora.
Confiabilidade e estabilidade
A confiabilidade é especialmente importante em um aplicativo de nível empresarial
plicações que lidam com dados críticos de negócios. Para esta finalidade
pose, o PostgreSQL fornece suporte para servidores hot standby,
recuperação point-in-time, diferentes tipos de replicação (syn-
crônico, assíncrono, cascata).
Segurança
PostgreSQL suporta conexões SSL seguras e fornece
vários métodos de autenticação, incluindo au-
autenticação, certificados de cliente e autenticação externa
serviços de instalação (LDAP, RADIUS, PAM, Kerberos).
6
Página 8
Para gerenciamento de usuários e controle de acesso ao banco de dados, o
os seguintes recursos são fornecidos:
• Criação e gerenciamento de novos usuários e funções de grupo
• Controle de acesso ao banco de dados baseado em usuário e função
objetos
• Segurança em nível de linha e coluna
• Suporte SELinux por meio de uma função SE-PostgreSQL embutida
nacionalidade (controle de acesso obrigatório)
Conformidade com o padrão SQL
Conforme o padrão ANSI SQL evoluiu, seu suporte foi contra
constantemente sendo adicionado ao PostgreSQL. Isso é verdade para todos
versões do padrão: SQL-92, SQL: 1999, SQL: 2003,
SQL: 2008, SQL: 2011. Suporte JSON, que era padrão
izado em SQL: 2016, está planejado para PostgreSQL 11. Em geral
geral, o PostgreSQL fornece uma alta taxa de conformidade padrão
mance, suportando 160 de 179 recursos obrigatórios,
bem como muitos opcionais.
Suporte para transações
PostgreSQL fornece suporte completo para propriedades ACID e
garante o isolamento eficaz da transação usando o multi
método de controle de simultaneidade de versão (MVCC). Este método
permite evitar o bloqueio em todos os casos, exceto para concorrentes
atualizações da mesma linha por diferentes processos. Lendo
7

Página 9
transações nunca bloqueiam a escrita, e a escrita nunca
leitura de blocos. Isso é verdade mesmo para a série mais estrita
nível de isolamento considerável. Usando um inovador Serializable
Sistema de isolamento de instantâneo, este nível garante que haja
não há anomalias de serialização e garante que
a execução da transação atual leva ao mesmo resultado que
uma das possíveis execuções sequenciais.
Para desenvolvedores de aplicativos
Os desenvolvedores de aplicativos obtêm um rico conjunto de ferramentas para a criação de
aplicativos
plicações de qualquer tipo:
• Suporte para várias linguagens de programação de servidor:
PL / pgSQL embutido (que está intimamente integrado com
SQL), C para tarefas de desempenho crítico, Perl, Python,
Tcl, bem como JavaScript, Java e muito mais.
• APIs para acessar DBMS de aplicativos escritos em
qualquer idioma, incluindo o ODBC padrão e
APIs JDBC.
• Uma seleção de objetos de banco de dados que permitem efetuar
implementar ativamente a lógica de qualquer complexidade no
lado do servidor: tabelas e índices, restrições de integridade,
visualizações e visualizações materializadas, sequências, partição
ing, subqueries e with-queries (incluindo recorrentes
sive), funções de agregação e janela, armazenadas
funções, gatilhos, etc.
8

Página 10
• Sistema integrado de pesquisa de texto completo flexível com suporte
para todos os idiomas europeus (incluindo russo),
estendido com métodos de acesso de índice eficazes.
• Suporte para dados semiestruturados, semelhante a NoSQL
bancos de dados: armazenamento hstore para pares de chave / valor, xml,
json (tanto na representação de texto quanto em um efetivo
representação jsonb binária).
• Wrappers de dados externos. Este recurso permite adicionar
novas fontes de dados como tabelas externas pelo SQL / MED
padrão. Você pode usar qualquer DBMS principal como um externo
fonte de dados final. PostgreSQL fornece suporte completo para
dados estrangeiros, incluindo acesso de gravação e distribuição
execução da consulta.
Escalabilidade e Desempenho
PostgreSQL tira proveito do moderno multi-core
arquitetura do processador. Seu desempenho cresce quase linearmente
logo que o número de núcleos aumenta.
A partir da versão 9.6, o PostgreSQL permite
processamento de dados, que agora suporta leituras paralelas (em
incluindo varreduras de índice), junções e agregação de dados. Estes
recursos permitem usar recursos de hardware de forma mais eficaz
para acelerar as consultas.
9

Página 11
Planejador de Consulta
PostgreSQL usa um planejador de consulta baseado em custo. Usando o
estatísticas coletadas e levando em consideração ambos os op-
erações e tempo de CPU em seus modelos matemáticos, o
O planejador pode otimizar as consultas mais complexas. Pode usar tudo
métodos de acesso e tipos de junção disponíveis no estado da
DBMS comercial de arte.
Indexando
O PostgreSQL fornece vários métodos de índice. Além de
as árvores B tradicionais, você pode usar o seguinte método
ods:
• GiST: uma árvore de pesquisa balanceada generalizada. Este ac-
método cesso pode ser usado para os dados que não podem
ser normalizado. Por exemplo, R-trees para indexar pontos
em uma superfície que suporta k-vizinhos mais próximos (k-NN)
pesquisa ou indexação de intervalos sobrepostos.
• SP-GiST: uma árvore de pesquisa não balanceada generalizada
com base na divisão do intervalo de pesquisa em não inter
seccionar partições aninhadas. Por exemplo, quad-trees
e árvores radix.
• GIN: índice invertido generalizado. É usado principalmente em
pesquisa de texto completo para encontrar documentos que contenham o
palavra usada na consulta de pesquisa. Outro exemplo é
pesquisa em matrizes de dados.
10

Página 12
• RUM: uma melhoria do método GIN para full-
Pesquisa de texto. Disponível como uma extensão, este índice
tipo pode acelerar a pesquisa de frase e retornar o retorno
resultados classificados por relevância.
• BRIN: um pequeno índice que fornece uma compensação entre
o tamanho do índice e a eficiência da pesquisa. É útil para
grandes tabelas agrupadas.
• Bloom: um índice baseado no filtro Bloom (apareceu
no PostgreSQL 9.6). Ter um representante compacto
ção, este índice pode filtrar rapidamente
tuplas, mas requer uma nova verificação do restante
uns.
Graças à extensibilidade, novos métodos de acesso ao índice
aparecer constantemente.
Muitos tipos de índice podem ser construídos em uma única coluna
umn e várias colunas. Independentemente do tipo, você
também pode construir índices em expressões arbitrárias, também
as cria índices parciais apenas para linhas específicas. Cobertura
índices podem acelerar as consultas, pois todos os dados necessários são
recuperado do próprio índice, evitando o acesso ao heap.
Vários índices podem ser combinados automaticamente usando
bitmaps, que podem acelerar o acesso ao índice.
Suporte multiplataforma
PostgreSQL é executado em sistemas operacionais Unix (incluindo
distribuições Linux de servidor e cliente), FreeBSD, Solaris,
macOS, bem como sistemas Windows.
11

Página 13
Seu código C de fonte aberta portátil permite construir Post-
greSQL em uma variedade de plataformas, mesmo se não houver pacote
idade apoiada pela comunidade.
Extensibilidade
Uma das principais vantagens da arquitetura PostgreSQL
é extensibilidade. Sem alterar o código do sistema central,
os usuários podem adicionar os seguintes recursos:
• Tipos de dados
• Funções e operadores para trabalhar com novos dados
tipos
• Métodos de acesso ao índice
• Linguagens de programação de servidor
• Wrappers de dados estrangeiros (FDW)
• Extensões carregáveis
O suporte completo de extensões permite que você decida
desenvolver novos recursos de qualquer complexidade que possa ser in-
paralisado sob demanda, sem alterar o núcleo do PostgreSQL.
Por exemplo, os seguintes sistemas complexos são construídos como
extensões:
• CitusDB implementa distribuição de dados entre diferentes
diferentes instâncias do PostgreSQL (fragmentação) e mas-
execução de consulta paralela sivamente.
• PostGIS fornece um processamento de dados de geoinformação
sistema.
12

Página 14
O pacote padrão do PostgreSQL 10 sozinho inclui cerca de
cinquenta extensões que provaram ser úteis e confiáveis
capaz.
Disponibilidade
A licença PostgreSQL permite o uso ilimitado deste DBMS,
modificação de código, bem como integração de PostgreSQL
em outros produtos, incluindo comerciais e
software de origem.
Independência
PostgreSQL não pertence a nenhuma empresa; é desenvolver
operado pela comunidade internacional, que inclui de-
velopers de todo o mundo. Isso significa que os sistemas
usando PostgreSQL não dependem de um fornecedor específico,
mantendo assim o investimento em todas as circunstâncias.
13

Página 15
Instalação e início rápido
O que é necessário para começar a usar o PostgreSQL? Nisso
capítulo, vamos explicar como instalar e gerenciar Post-
serviço greSQL e, em seguida, mostre como configurar um serviço simples
banco de dados e criar tabelas nele. Também cobriremos o
noções básicas da linguagem SQL, que é usada para consultas de dados.
É uma boa ideia começar a tentar comandos SQL enquanto você
estão lendo este capítulo.
Recomendamos o uso do Postgres Pro Standard 10 distribuição
ção desenvolvida pela empresa Postgres Professional. isto
é totalmente compatível com o PostgreSQL vanilla, mas inclui
várias extensões adicionais. Muitas vezes, esta distribuição
ção também inclui alguns recursos que devem ser incluídos
no PostgreSQL antes de seu lançamento oficial. Observe
que a licença do Postgres Pro difere da do PostgreSQL.
Todos os exemplos neste livro também funcionarão com vanilla Post-
greSQL, que pode ser instalado a partir da comunidade web-
site ou seu repositório de pacotes.
Vamos começar. Dependendo do seu sistema operacional,
A instalação e configuração do PostgreSQL serão diferentes. Se você é
usando o Windows, continue lendo; para Linux baseado em Debian ou Ubuntu
sistemas, vá para a p. 22
14

Página 16
Para outros sistemas operacionais, você pode ver a instalação em
structions online : postgrespro.com/products/download.
Se não houver distribuição para o seu sistema operacional, use
vanilla PostgreSQL. Suas instruções de instalação estão disponíveis
disponível em www.postgresql.org/download.
janelas
Instalação
Baixe o instalador DBMS de nosso site:
postgrespro.com/products/postgrespro/download/
Mais recentes.
Dependendo da sua versão do Windows, escolha o 32- ou
Instalador de 64 bits. Inicie o arquivo baixado e selecione
o idioma de instalação.
O instalador fornece uma interface de assistente convencional:
você pode simplesmente continuar clicando no botão “Próximo” se você
estão bem com as opções padrão. Vamos examinar o principal
passos.
15

Página 17
Escolha os componentes:
Mantenha ambas as opções selecionadas se não tiver certeza de qual
um para escolher.
16

Página 18
Pasta de instalação:
Por padrão, o servidor Postgres Pro é instalado em
C: \ Arquivos de programas \ PostgrePro \ 10 (ou C: \ Arquivos de programas
(x86) \ PostgrePro \ 10 para a versão de 32 bits em um 64 bits
sistema).
17

Página 19
Você também pode especificar o diretório para armazenar os bancos de dados.
Este diretório conterá todas as informações armazenadas no DBMS,
portanto, certifique-se de ter espaço em disco suficiente se estiver planejando
tentando manter uma grande quantidade de dados.
18

Página 20
Opções de servidor:
Se você está planejando armazenar seus dados em outro idioma
do que o inglês, certifique-se de escolher o lo-
cale (ou deixe a opção “Configuração do sistema operacional”, se o seu Windows
as configurações de local são configuradas apropriadamente).
Digite e confirme a senha para o DBMS postgres
usuário (ou seja, o superusuário do banco de dados). Você também deve selecionar
a caixa de seleção “Configurar variáveis de ambiente” para conectar
para o servidor Postgres Pro em nome do usuário do sistema operacional atual.
Você pode deixar as configurações padrão em todos os outros campos.
19

Página 21
Se você está planejando instalar o Postgres Pro para fins educacionais
apenas para fins, você pode selecionar “Usar o conjunto padrão
opções ”para que o DBMS ocupe menos RAM.
Gerenciando o serviço e os arquivos principais
Quando o Postgres Pro é instalado, o “postgrepro-X64-10”
serviço está registrado em seu sistema (em sistemas de 32 bits,
é “postgrespro-X86-10”). Este serviço é lançado automaticamente
automaticamente na inicialização do sistema no Serviço de Rede
conta. Se necessário, você pode alterar as configurações de serviço
usando as opções padrão do Windows.
20

Página 22
Para interromper temporariamente o serviço do servidor de banco de dados, execute o
Programa “Stop Server” da subpasta do menu Iniciar que
você selecionou no momento da instalação:
Para iniciar o serviço, você pode executar o “Start Server” pro
grama da mesma pasta.
Se ocorrer um erro na inicialização do serviço, você pode ver o
log do servidor para descobrir sua causa. O arquivo de log está localizado
no subdiretório “log” do diretório do banco de dados cho-
sen no momento da instalação (normalmente, é C: \ Program
Files \ PostgresPro \ 10 \ data \ log). O registro é regularmente
mudou para um novo arquivo. Você pode encontrar o arquivo necessário ei-
outro pela data da última modificação, ou pelo nome do arquivo que
inclui a data e hora da transição para este arquivo.
Existem vários arquivos de configuração importantes que definem
configurações do servidor. Eles estão localizados na direção do banco de dados
história. Não há necessidade de modificá-los para começar
PostgreSQL, mas você definitivamente precisará deles no trabalho real:
21

Página 23
• postgresql.conf é o principal arquivo de configuração que
contém parâmetros de servidor.
• pg_hba.conf define a configuração de acesso. Para
razões de segurança, o acesso deve ser confirmado por um
senha e só é permitido no sistema local
por padrão.
Dê uma olhada nesses arquivos, eles estão totalmente documentados.
Agora estamos prontos para nos conectar ao banco de dados e experimentar
alguns comandos e consultas SQL. Vá para o capítulo “Experimente-
ing SQL ”na p. 27
Debian e Ubuntu
Instalação
Se você estiver usando Linux, você precisa adicionar nossa empresa
repositório primeiro:
Para o sistema operacional Debian (as versões atualmente suportadas são 7 “Wheezy,”
8 “Jessie” e 9 “Stretch”), execute os seguintes comandos em
a janela do console:
$ sudo apt-get install lsb-release
$ sudo sh -c 'echo "deb \
http://repo.postgrespro.ru/pgpro-10/debian \
$ (lsb_release -cs) main "> \
/etc/apt/sources.list.d/postgrespro.list '
22

Página 24
Para Ubuntu OS (atualmente as versões suportadas são 14.04
“Trusty”, 16.04 “Xenial”, 17.10 “Artful” e 18.04 “Bionic”),
você deve usar comandos um pouco diferentes:
$ sudo sh -c 'echo "deb \
http://repo.postgrespro.ru/pgpro-10/ubuntu \
$ (lsb_release -cs) main "> \
/etc/apt/sources.list.d/postgrespro.list '
As etapas seguintes são iguais em ambos os sistemas:
$ wget --quiet -O - http://repo.postgrespro.ru/pgpro-
10 / chaves / GPG-KEY-POSTGRESPRO | sudo apt-key add -
$ sudo apt-get update
Antes de iniciar a instalação, verifique o conjunto de localização
coisas:
$ locale
Se você planeja armazenar dados em um idioma diferente de En-
glish, as variáveis LC_CTYPE e LC_COLLATE devem ser
definir apropriadamente. Por exemplo, para o idioma francês,
certifique-se de definir essas variáveis para “fr_FR.UTF8”:
$ export LC_CTYPE = fr_FR.UTF8
$ export LC_COLLATE = fr_FR.UTF8
Você também deve se certificar de que o sistema operacional
a localidade necessária instalada:
23

Página 25
$ locale -a | grep fr_FR
fr_FR.utf8
Se não for o caso, gere a localidade, da seguinte maneira:
$ sudo locale-gen fr_FR.utf8
Agora você pode iniciar a instalação. As ofertas de distribuição
suas duas opções de instalação: instalação rápida e configuração
de forma totalmente automatizada, ou instalação personalizada que al-
permite pegar e escolher os pacotes necessários, mas
requer uma configuração manual do sistema. Para simplificar, vamos
para a primeira opção fornecida pelo postgrespro-std-10
pacote:
$ sudo apt-get install postgrespro-std-10
Para evitar possíveis conflitos, não use esta opção se você
já tem uma instância PostgreSQL instalada em seu sistema
tem. Para saber como instalar o Postgres Pro junto com
PostgreSQL, consulte as instruções detalhadas de instalação
em postgrespro.com/docs/postgrespro/10/binary-
instalação no linux.
Assim que o comando de instalação for concluído, Postgres Pro
O DBMS será instalado e iniciado. Para verificar se o
servidor está pronto para uso, execute:
$ sudo -u postgres psql -c 'select now ()'
Se tudo correr bem, a hora atual é retornada.
24
Página 26
Gerenciando o serviço e os arquivos principais
Quando o Postgres Pro é instalado, um usuário especial do postgres é
criado automaticamente em seu sistema. Todos os servidores
cessa o trabalho em nome deste usuário. Todos os arquivos DBMS pertencem
para este usuário também. Postgres Pro será iniciado automaticamente
na inicialização do sistema operacional. Não é um problema
limpe com as configurações padrão: se você não estiver trabalhando com
o servidor de banco de dados, consome muito pouco do sistema de recuperação
fontes. Se você decidir desligar a inicialização automática, execute:
Desativar serviço $ sudo pg-setup
Para interromper temporariamente o serviço do servidor de banco de dados, digite:
$ sudo service postgrespro-std-10 stop
Você pode iniciar o serviço do servidor da seguinte maneira:
$ sudo service postgrespro-std-10 start
Para obter a lista completa de comandos disponíveis, digite:
$ sudo service postgrespro-std-10
Se ocorrer um erro na inicialização do serviço, você pode encontrar o
detalhes no log do servidor. Como regra, você pode obter as últimas
registre mensagens executando o seguinte comando:
$ sudo journalctl -xeu postgrespro-std-10
25

Página 27
Em algumas versões mais antigas dos sistemas operacionais, você
pode ser necessário visualizar o arquivo de log / var / lib / pgpro / std-10 /
pgstartup.log.
Todas as informações a serem armazenadas no banco de dados estão localizadas em
o diretório / var / lib / pgpro / std-10 / data / no arquivo
sistema. Se você for armazenar muitos dados, certifique-se
que você tem espaço em disco suficiente.
Existem vários arquivos de configuração que definem o servidor
definições. Não há necessidade de configurá-los para começar,
mas vale a pena conferi-los, pois você definitivamente
preciso deles no futuro:
• /var/lib/pgpro/std-10/data/postgresql.conf
é o arquivo de configuração principal que contém o servidor
parâmetros.
• /var/lib/pgpro/std-10/data/pg_hba.conf de-
multas configurações de acesso. Por razões de segurança, o ac-
cesso só é permitido no sistema local em nome
do usuário do sistema operacional postgres por padrão.
Agora é hora de se conectar ao banco de dados e experimentar o SQL.
26

Página 28
Tentando SQL
Conexão via psql
Para se conectar ao servidor DBMS e começar a executar comp
mands, você precisa ter um aplicativo cliente. No “Post-
greSQL for Applications ”, falaremos sobre como
para enviar consultas de aplicativos escritos em diferentes pro-
linguagens de gramática. E aqui vamos explicar como trabalhar
com o cliente psql a partir da linha de comando entre
modo ativo.
Infelizmente, muitas pessoas não gostam muito de
linha de mando hoje em dia. Por que faz sentido aprender
como trabalhar nele?
Em primeiro lugar, o psql é um aplicativo cliente padrão incluído
em todos os pacotes PostgreSQL, por isso está sempre disponível. Não
dúvida, é bom ter um ambiente customizado, mas
não há necessidade de se perder em um sistema desconhecido.
Em segundo lugar, o psql é realmente conveniente para as tarefas diárias de DBA,
escrever pequenas consultas e automatizar processos. Para ex-
amplo, você pode usá-lo para implantar aplicativos periodicamente
atualizações de código em seu servidor DBMS. O cliente psql pro
vides seus próprios comandos que podem ajudá-lo a encontrar seu caminho
27

Página 29
em torno dos objetos de banco de dados e exibir os dados armazenados
em tabelas em um formato conveniente.
No entanto, se você está acostumado a trabalhar com usuários gráficos
interfaces, experimente o pgAdmin (falaremos sobre isso a seguir) ou
outros produtos semelhantes : wiki.postgresql.org/wiki/
Community_Guide_to_PostgreSQL_GUI_Tools.
Para iniciar o psql em um sistema Linux, execute este comando:
$ sudo -u postgres psql
No Windows, abra o menu Iniciar e inicie o “SQL
Programa Shell (psql) ”da instalação do PostgreSQL
pasta:
Quando solicitado, digite a senha do postgres
usuário que você definiu ao instalar o PostgreSQL.
Os usuários do Windows podem ter problemas de codificação com
Caracteres ingleses no terminal. Se você ver truncado
28

Página 30
símbolos em vez de letras, certifique-se de que uma fonte TrueType
é selecionado nas propriedades da janela do terminal (tipi-
denominado “Lucida Console” ou “Consolas”).
Como resultado, você deve ver o mesmo prompt em ambos os op-
sistemas erativos: postgres = #. Neste prompt, “postgres”
é o nome do banco de dados ao qual você está conectado
agora mesmo. Um único servidor PostgreSQL pode hospedar vários
bancos de dados, mas você só pode trabalhar com um deles em um
Tempo.
Nas seções abaixo, iremos fornecer algumas linhas de comando
exemplos. Insira apenas a parte impressa em negrito; o prompt
e a resposta do sistema é fornecida apenas para sua con
veniência.
Base de dados
Vamos criar um novo banco de dados chamado test:
postgres = # CREATE DATABASE test;
CRIAR BASE DE DADOS
Não se esqueça de usar ponto-e-vírgula no final do comp
mand: PostgreSQL espera que você continue digitando até
você insere este símbolo, então você pode dividir o comando
várias linhas.
Agora vamos conectar ao banco de dados criado:
postgres = # \ c teste
29

Página 31
Você agora está conectado ao banco de dados "teste" como usuário
"postgres".
teste = #
Como você pode ver, o prompt de comando mudou para
teste = #.
O comando que acabamos de inserir não parece
SQL, pois começa com uma barra invertida. Esta é uma convenção para
comandos especiais que só podem ser usados no psql (portanto, se
você está usando o pgAdmin ou outra ferramenta GUI, pule todos os com-
mandos começando com uma barra invertida, ou tente encontrar um equivalente
lent).
Existem alguns comandos psql, e vamos usar
alguns deles um pouco mais tarde. Para obter a lista completa do psql .com
mandos agora, você pode executar:
test = # \?
Uma vez que as informações de referência são bastante volumosas, será
exibido em um programa de pager de seu sistema operacional,
que geralmente é mais ou menos.
Mesas
Os sistemas de gerenciamento de banco de dados relacional apresentam dados
como tabelas. O título da tabela define suas colunas;
os próprios dados são armazenados nas linhas da tabela . Os dados não são ou-
dered. Em particular, você não pode extrair linhas de dados no
ordem em que foram adicionados à mesa.
30

Página 32
Para cada coluna, um tipo de dados é definido. Todos os valores em
os campos de linha correspondentes devem estar em conformidade com este tipo.
Você pode usar vários tipos de dados integrados fornecidos por Post-
greSQL (postgrespro.com/doc/datatype.html) ou adicione
seus próprios tipos personalizados. Aqui, cobriremos apenas alguns
uns:
• inteiro
• texto
• booleano, que é um tipo lógico assumindo verdadeiro ou
valores falsos
Além dos valores regulares definidos pelo tipo de dados, um campo
pode ter um marcador indefinido NULL. Pode ser interpretado
como “o valor é desconhecido” ou “o valor não está definido.”
Vamos criar uma tabela de cursos universitários:
teste = # CREATE TABLE cursos (
teste(#
c_ sem texto PRIMARY KEY,
teste(#
texto do título,
teste(#
horas inteiras
teste (# );
CRIAR A TABELA
Observe que o prompt de comando psql mudou: é
uma dica de que o comando continua na nova linha. (Para
conveniência, não vamos repetir o prompt em cada linha
nos exemplos a seguir.)
O comando acima cria a tabela de cursos com três
colunas:
31

Página 33
• c_no define o número do curso representado como um
string de texto.
• title fornece o título do curso.
• horas lista um número inteiro de horas de aula.
Além de colunas e tipos de dados, podemos definir
restrições de integridade que serão verificadas automaticamente:
O PostgreSQL não permite dados inválidos no banco de dados. Dentro
neste exemplo, adicionamos a restrição PRIMARY KEY
para a coluna c_no. Isso significa que todos os valores nesta coluna
umn deve ser exclusivo e NULLs não são permitidos. Tal
uma coluna pode ser usada para distinguir uma linha da tabela de
outro. Para a lista completa de restrições, consulte
postgrespro.com/doc/ddl-constraints.html.
Você pode encontrar a sintaxe exata do comando CREATE TABLE
mande na documentação ou veja a ajuda da linha de comando à direita
no psql:
test = # \ help CRIAR TABELA
Essas informações de referência estão disponíveis para cada comp SQL
mand. Para obter a lista completa de comandos SQL, execute \ help
sem argumentos.
Preenchendo tabelas com dados
Vamos inserir algumas linhas na tabela criada:
32

Página 34
teste = # INSERT INTO cursos (c_no, título, horas)
VALUES ('CS301', 'Bancos de dados', 30),
('CS305', 'Redes', 60);
INSERT 0 2
Se você precisar realizar um upload de dados em massa de um exter-
fonte final, o comando INSERT não é a melhor escolha.
Em vez disso, você pode usar o comando COPY, que é específico
icamente projetado para esse fim : postgrespro.com/doc/
sql-copy.html.
Precisaremos de mais duas tabelas para exemplos adicionais: stu-
dentes e exames. Para cada aluno, vamos armazenar
o seu nome e o ano de admissão (ano de início). o
o número da carteira de identidade do aluno servirá como a identificação do aluno
fier.
teste = # CRIAR TABELA alunos (
s_id integer PRIMARY KEY,
texto do nome,
start_year inteiro
);
CRIAR A TABELA
teste = # INSERT INTO alunos (s_id, nome, start_year)
VALUES (1451, 'Anna', 2014),
(1432, 'Victor', 2014),
(1556, 'Nina', 2015);
INSERIR 0 3
Cada exame deve ter a pontuação recebida pelos alunos
no curso correspondente. Assim, alunos e cursos
estão conectados pela relação muitos para muitos: cada
33

Página 35
o aluno pode fazer exames em vários cursos, e cada
o exame pode ser feito por vários alunos.
Cada linha da tabela é identificada exclusivamente pela combinação
de um nome de aluno e um número de curso. Tal integridade
restrição pertencente a várias colunas de uma vez é de-
multado pela cláusula CONSTRAINT:
test = # CREATE TABLE exames (
s_id integer REFERÊNCIAS alunos (s_id),
c_no text REFERENCES cursos (c_no),
score integer,
CONSTRAINT pk PRIMARY KEY (s_id, c_no)
);
CRIAR A TABELA
Além disso, usando a cláusula REFERENCES, definimos
duas verificações de integridade referencial, chamadas de chaves estrangeiras . Tal
chaves mostram que os valores de uma tabela de referência de linhas de
outra mesa. Quando qualquer ação é executada nos dados-
base, o DBMS irá agora verificar se todos os identificadores s_id no
mesa de exames corresponde a alunos reais (ou seja, entradas
na tabela de alunos), enquanto os números dos cursos em c_no cor-
responder a cursos reais. Assim, é impossível atribuir
uma pontuação em um assunto não existente ou em um não existente
aluno, independentemente das ações do usuário ou possível aplicação
erros de cátion.
Vamos atribuir várias notas aos nossos alunos:
teste = # INSERT INTO exames (s_id, c_no, pontuação)
VALUES (1451, 'CS301', 5),
(1556, 'CS301', 5),
(1451, 'CS305', 5),
(1432, 'CS305', 4);
INSERIR 0 4
34

Página 36
Recuperação de dados
Consultas Simples
Para ler os dados das tabelas, use o operador SELECT. Para
exemplo, vamos exibir duas colunas da tabela de cursos:
test = # SELECT title AS course_title, hours
FROM cursos;
course_title | horas
-------------- + -------
Bancos de dados
|
30
Redes
|
60
(2 linhas)
A cláusula AS permite renomear a coluna, se necessário.
Para exibir todas as colunas, basta usar o símbolo *:
teste = # SELECT * FROM cursos;
c_no
|
título
| horas
------- + ------------- + -------
CS301 | Bancos de dados
|
30
CS305 | Redes
|
60
(2 linhas)
O resultado pode conter várias linhas com os mesmos dados.
Mesmo que todas as linhas da tabela original sejam diferentes, o
os dados podem aparecer duplicados se nem todas as colunas forem distribuídas
reproduziu:
35

Página 37
teste = # SELECT start_year FROM students;
start_year
------------
2014
2014
2015
(3 linhas)
Para selecionar todos os anos iniciais diferentes , especifique o DISTINCT
palavra-chave após SELECT:
teste = # SELECT DISTINCT start_year FROM students;
start_year
------------
2014
2015
(2 linhas)
Para obter detalhes, consulte a documentação : postgrespro.com/doc/
sql-select.html # SQL-DISTINCT
Em geral, você pode usar qualquer expressão após o SELECT
operador. Se você omitir a cláusula FROM, a tabela resultante
conterá uma única linha. Por exemplo:
teste = # SELECIONE 2 + 2 resultado AS;
resultado
--------
4
(1 linha)
Quando você seleciona alguns dados de uma tabela, geralmente é
exigido para retornar apenas as linhas que satisfaçam um certo
doença. Esta condição de filtragem é escrita no WHERE
cláusula:
36

Página 38
teste = # SELECIONE * DOS cursos ONDE horas> 45;
c_no
|
título
| horas
------- + ---------- + -------
CS305 | Redes |
60
(1 linha)
A condição deve ser de tipo lógico. Por exemplo,
pode conter relações =, <> (ou! =),>,> =, <, <=, bem como
combinar condições simples usando operações lógicas E,
OU, NÃO e parênteses (como na linguagem de programação regular
medidores).
Lidar com NULLs é um pouco mais sutil. A tabela resultante
pode conter apenas as linhas para as quais as condições de filtragem
ção é verdadeira; se a condição for falsa ou indefinida , a linha
é excluído.
Lembrar:
• O resultado da comparação de algo com NULL é indefinido
multado.
• O resultado das operações lógicas em NULL é geralmente
ally undefined (exceções: true OR NULL = true,
falso AND NULL = falso).
• As seguintes condições especiais são usadas para verificar
se o valor é indefinido: IS NULL (IS NOT
NULLl) e É DISTINTO DE (NÃO É DISTINTO
A PARTIR DE).
Também pode ser conveniente usar o coalescer
função.
Você pode encontrar mais detalhes na documentação:
postgrespro.com/doc/functions-comparison.html
37

Página 39
Junta-se
Um banco de dados bem projetado não deve conter redundantes
dados. Por exemplo, a mesa de exames não deve conter
nomes de dentes, pois esta informação pode ser encontrada em outro
tabela pelo número da carteira de estudante.
Por esse motivo, para obter todos os valores necessários em uma consulta,
muitas vezes é necessário juntar os dados de várias tabelas,
especificando todos os nomes de tabela na cláusula FROM:
teste = # SELECIONE * DE cursos, exames;
c_no
|
título
| horas | s_id | c_no
| Ponto
------- + ------------- + ------- + ------ + ------- + ----- -
CS301 | Bancos de dados
|
30 1451 | CS301 |
5
CS305 | Redes
|
60 1451 | CS301 |
5
CS301 | Bancos de dados
|
30 1556 | CS301 |
5
CS305 | Redes
|
60 1556 | CS301 |
5
CS301 | Bancos de dados
|
30 1451 | CS305 |
5
CS305 | Redes
|
60 1451 | CS305 |
5
CS301 | Bancos de dados
|
30 1432 | CS305 |
4
CS305 | Redes
|
60 1432 | CS305 |
4
(8 linhas)
Este resultado é chamado de produto direto ou cartesiano de ta-
bles: cada linha de uma tabela é anexada a cada linha de
a outra mesa.
Como regra, você pode obter uma resposta mais útil e informativa
resultado se você especificar a condição de junção na cláusula WHERE.
Vamos obter todas as pontuações de todos os cursos, combinando cursos para
exames neste curso:
38

Página 40
test = # SELECTourses.title, exams.s_id, exams.score
FROM cursos, exames
ONDE cursos.c_no = exams.c_no;
título
| s_id | Ponto
------------- + ------ + -------
Bancos de dados
| 1451 |
5
Bancos de dados
| 1556 |
5
Redes
| 1451 |
5
Redes
| 1432 |
4
(4 linhas)
Outra maneira de unir tabelas é usar explicitamente o
Palavra-chave JOIN. Vamos mostrar todos os alunos e suas pontuações
para o curso “Redes”:
test = # SELECT students.name, exams.score
DE alunos
PARTICIPAR de exames
ON students.s_id = exams.s_id
AND exams.c_no = 'CS305';
nome
| Ponto
-------- + -------
Anna
|
5
Victor |
4
(2 linhas)
Do ponto de vista do DBMS, ambas as consultas são equivalentes,
então você pode usar qualquer abordagem que pareça mais natural.
Neste exemplo, o resultado não inclui as linhas de
a mesa original que não tem um par na outra
tabela: embora a condição seja aplicada às disciplinas,
os alunos que não fizeram um exame nesta disciplina
também são excluídos. Para incluir todos os alunos no resultado,
independentemente de terem feito este exame, use o externo
Junte-se:
39

Página 41
test = # SELECT students.name, exams.score
DE alunos
Exames LEFT JOIN
ON students.s_id = exams.s_id
AND exams.c_no = 'CS305';
nome
| Ponto
-------- + -------
Anna
|
5
Victor |
4
Nina
|
(3 linhas)
Observe que as linhas da tabela à esquerda que não têm
uma contraparte na tabela certa é adicionada ao resultado
(é por isso que a operação é chamada LEFT JOIN). A correspondência
os valores correspondentes na tabela certa são indefinidos neste
caso.
A condição WHERE é aplicada ao resultado da junção
Operação. Assim, se você especificar a restrição de assunto
lado da condição de junção, Nina será excluída da
resultado porque o exams.c_no correspondente é unde-
multado:
test = # SELECT students.name, exams.score
DE alunos
LEFT JOIN exames ON students.s_id = exams.s_id
ONDE exams.c_no = 'CS305';
nome
| Ponto
-------- + -------
Anna
|
5
Victor |
4
(2 linhas)
40

Página 42
Não tenha medo de junções. É uma operação comum para
sistemas de gerenciamento de banco de dados, e PostgreSQL tem um
toda a gama de mecanismos eficazes para realizá-lo. Faz
não juntar dados no nível do aplicativo, deixe o banco de dados
servidor fazer o trabalho. O servidor pode lidar com esta tarefa muito
bem.
Você pode encontrar mais detalhes na documentação:
postgrespro.com/doc/sql-select.html#SQL-FROM
Subconsultas
A operação SELECT retorna uma tabela, que pode ser dis-
reproduzido como o resultado da consulta (como já vimos) ou
usado em outra consulta SQL. Um SELECT com aninhado
o mando entre parênteses é chamado de subconsulta.
Se uma subconsulta retornar uma única linha e uma única coluna,
você pode usá-lo como uma expressão escalar regular:
test = # SELECT nome,
(SELECT pontuação
DE exames
WHERE exams.s_id = students.s_id
AND exams.c_no = 'CS305')
DE alunos;
nome
| Ponto
-------- + -------
Anna
|
5
Victor |
4
Nina
|
(3 linhas)
41

Página 43
Se uma subconsulta usada na lista de expressões SELECT
não contém nenhuma linha, NULL é retornado (como na última linha
do resultado da amostra acima).
Essas subconsultas escalares também podem ser usadas na filtragem de con
dições. Vamos pegar todos os exames feitos pelos alunos que
estão inscritos desde 2014:
test = # SELECT *
DE exames
ONDE (SELECIONE ano_início
DE alunos
ONDE students.s_id = exams.s_id)> 2014;
s_id | c_no
| Ponto
------ + ------- + -------
1556 | CS301 |
5
(1 linha)
Você também pode adicionar condições de filtragem às subconsultas.
girando um número arbitrário de linhas. SQL oferece vários
predicados para esse fim. Por exemplo, IN verifica se
a tabela retornada pela subconsulta contém o especificado
valor.
Vamos exibir todos os alunos que têm alguma pontuação na especificação
curso criado:
test = # SELECT nome, start_year
DE alunos
ONDE s_id IN (SELECT s_id
DE exames
ONDE c_no = 'CS305');
nome
| start_year
-------- + ------------
Anna
|
2014
Victor |
2014
(2 linhas)
42

Página 44
Há também a forma NOT IN deste predicado que re-
transforma o resultado oposto. Por exemplo, o seguinte
consulta retorna a lista de alunos que obtiveram apenas excelentes
pontuações (isto é, quem não obteve pontuações mais baixas):
test = # SELECT nome, start_year
DE alunos
ONDE s_id NÃO ESTÁ (SELECT s_id
DE exames
ONDE pontuação <5);
nome | start_year
------ + ------------
Anna |
2014
Nina |
2015
(2 linhas)
Outra opção é usar o predicado EXISTS, que
verifica se a subconsulta retorna pelo menos uma linha. Com
com a ajuda deste predicado, você pode reescrever o anterior
consulta da seguinte forma:
test = # SELECT nome, start_year
DE alunos
ONDE NÃO EXISTE (SELECT s_id
DE exames
WHERE exams.s_id = students.s_id
E pontuação <5);
nome | start_year
------ + ------------
Anna |
2014
Nina |
2015
(2 linhas)
Você pode encontrar mais detalhes na documentação:
postgrespro.com/doc/functions-subquery.html
43

Página 45
Nos exemplos acima, acrescentamos nomes de tabelas a col-
nomes umn para evitar ambigüidade. No entanto, pode ser insuportável
ficiente. Por exemplo, a mesma tabela pode ser usada no
consulta duas vezes, ou podemos usar uma subconsulta sem nome ao invés
da tabela na cláusula FROM. Nesses casos, você pode
especifique um nome arbitrário após a consulta, que é chamado
um alias. Você também pode usar aliases para tabelas regulares.
Vamos exibir os nomes dos alunos e suas pontuações para o “Data-
bases ”curso:
test = # SELECT s.name, ce.score
DE alunos s
PARTICIPE (SELECIONE exames. *
FROM cursos, exames
ONDE cursos.c_no = exams.c_no
ANDourses.title = 'Bancos de dados') ce
ON s.s_id = ce.s_id;
nome | Ponto
------ + -------
Anna |
5
Nina |
5
(2 linhas)
Aqui, “s” é um alias de tabela, enquanto “ce” é um alias de subconsulta.
Os aliases geralmente são escolhidos para serem curtos, mas abrangentes
sive.
A mesma consulta pode ser escrita sem subconsultas. Para
exemplo:
test = # SELECT s.name, e.score
DE alunos s, cursos c, exames e
ONDE c.c_no = e.c_no
AND c.title = 'Bancos de dados'
AND s.s_id = e.s_id;
44

Página 46
Ordenação
Como já mencionamos, os dados da tabela não são classificados.
No entanto, muitas vezes é importante obter as linhas no re-
sult em uma ordem particular. Isso pode ser alcançado usando o
Cláusula ORDER BY com a lista de expressões de classificação. Depois de
cada expressão (chave de classificação), você pode especificar a classificação
ordem crescente: ASC para ascendente (usado por padrão), DESC para
descendente.
test = # SELECT * FROM exames
Pontuação ORDER BY, s_id, c_no DESC;
s_id | c_no
| Ponto
------ + ------- + -------
1432 | CS305 |
4
1451 | CS305 |
5
1451 | CS301 |
5
1556 | CS301 |
5
(4 linhas)
Aqui, as linhas são classificadas primeiro por pontuação, de forma crescente
ordem. Para as mesmas pontuações, as linhas são classificadas por estu-
número do cartão de identificação dentado, em ordem crescente. Se o primeiro
duas chaves são iguais, as linhas são classificadas pelo curso
número, em ordem decrescente.
Faz sentido fazer a classificação no final da consulta,
logo antes de obter o resultado; esta operação é geralmente
inútil em subconsultas.
Para obter mais detalhes, consulte a documentação:
postgrespro.com/doc/sql-select.html#SQL-ORDERBY.
45

Página 47
Operações de Agrupamento
Quando o agrupamento é usado, a consulta retorna uma única linha
com o valor calculado a partir dos dados armazenados em sete
várias linhas das tabelas originais. Junto com o agrupamento,
funções agregadas são usadas. Por exemplo, vamos mostrar
o número total de exames feitos, o número de alunos
que passou nos exames e a pontuação média:
teste = # SELECT contagem (*), contagem (DISTINCT s_id),
média (pontuação)
FROM exames;
contagem | contagem |
média
------- + ------- + --------------------
4
3 | 4,7500000000000000
(1 linha)
Você pode obter informações semelhantes pelo número do curso
usando a cláusula GROUP BY que fornece chaves de agrupamento:
teste = # SELECT c_no, contagem (*),
contagem (DISTINCT s_id), vg (pontuação)
DE exames
GROUP BY c_no;
c_no
| contagem | contagem |
média
------- + ------- + ------- + --------------------
CS301 |
2|
2 | 5,00000000000000
CS305 |
2|
2 | 4.5000000000000000
(2 linhas)
Para a lista completa de funções agregadas, consulte
postgrespro.com/doc/functions-aggregate.html.
Em consultas que usam agrupamento, pode ser necessário filtrar o
linhas com base nos resultados de agregação. Você pode definir
46

Página 48
tais condições na cláusula HAVING. Enquanto o ONDE
condições são aplicadas antes do agrupamento (e pode usar o
colunas das tabelas originais), as condições HAVING
entram em vigor após o agrupamento (então eles também podem usar as colunas
da tabela resultante).
Vamos selecionar os nomes dos alunos que receberam mais de
uma pontuação excelente (5), em qualquer curso:
test = # SELECT students.name
DE alunos, exames
ONDE students.s_id = exams.s_id AND exams.score = 5
GROUP BY students.name
TENDO contagem (*)> 1;
nome
------
Anna
(1 linha)
Você pode encontrar mais detalhes na documentação:
postgrespro.ru/doc/sql-select.html#SQL-GROUPBY.
Alteração e exclusão de dados
Os dados da tabela são alterados usando o operador UPDATE,
que especifica novos valores de campo para linhas definidas pelo
Cláusula WHERE (como para o operador SELECT).
Por exemplo, vamos aumentar o número de horas de aula
para o curso “Bancos de dados” duas vezes:
teste = # ATUALIZAR cursos
SET horas = horas * 2
WHERE c_no = 'CS301';
47

Página 49
ATUALIZAÇÃO 1
Você pode encontrar mais detalhes na documentação:
postgrespro.com/doc/sql-update.html.
Da mesma forma, o operador DELETE exclui as linhas definidas por
a cláusula WHERE:
teste = # DELETE FROM exames WHERE pontuação <5;
APAGAR 1
Você pode encontrar mais detalhes na documentação:
postgrespro.com/doc/sql-delete.html.
Transações
Vamos estender nosso esquema de banco de dados um pouco e distribuir
homenagear nossos alunos entre os grupos. Cada grupo deve
ter um monitor: um aluno do mesmo grupo responsável
para as atividades dos alunos. Para completar esta tarefa, vamos
crie uma tabela para estes grupos:
test = # CREATE TABLE groups (
g_no text CHAVE PRIMÁRIA,
monitorar alunos inteiros NOT NULL REFERÊNCIAS (s_id)
);
CRIAR A TABELA
48

Página 50
Aqui aplicamos a restrição NOT NULL, que para-
lances usando valores indefinidos.
Agora precisamos de outro campo na tabela de alunos, do qual
não pensamos com antecedência: o número do grupo. Felizmente, nós
pode adicionar uma nova coluna à tabela já existente:
teste = # ALTER TABLE alunos
ADICIONE grupos de REFERÊNCIAS de texto g_no (g_no);
ALTERAR A TABELA
Usando o comando psql, você sempre pode ver quais
os campos são definidos na tabela:
teste = # \ d alunos
Tabela "public.students"
Coluna
|
Tipo
| Modificadores
------------ + --------- + ----------
s_id
| inteiro | não nulo
nome
| texto
|
start_year | inteiro |
g_no
| texto
|
...
Você também pode obter a lista de todas as tabelas disponíveis no
base de dados:
teste = # \ d
Lista de relações
Schema |
Nome
| Tipo
| Proprietário
-------- + ---------- + ------- + ----------
público | cursos
| mesa | postgres
público | exames
| mesa | postgres
público | grupos
| mesa | postgres
público | alunos | mesa | postgres
(4 linhas)
49

Página 51
Agora vamos criar um grupo “A-101” e mover todos os alunos
neste grupo, fazendo de Anna seu monitor.
Aqui encontramos um problema. Por um lado, não podemos
crie um grupo sem monitor. Por outro lado, como
podemos nomear Anna monitor se ela não for membro
do grupo ainda? Isso levaria a logicamente incorreto,
dados consistentes sendo armazenados no banco de dados, mesmo que por um
curto período de tempo.
Nós nos deparamos com uma situação em que duas operações
deve ser realizado simultaneamente, pois nenhum deles faz
qualquer sentido sem o outro. Tais operações constituem
uma unidade lógica indivisível de trabalho é chamada de transação.
Então, vamos começar nossa transação:
teste = # BEGIN;
INÍCIO
Em seguida, precisamos adicionar um novo grupo, junto com seu
itor. Já que não nos lembramos da carteira de estudante de Anna, usaremos
uma consulta dentro do comando que adiciona novas linhas:
teste = # INSERT INTO grupos (g_no, monitor)
SELECIONE 'A-101', s_id
DE alunos
ONDE nome = 'Anna';
INSERIR 0 1
Agora vamos abrir uma nova janela de terminal e lançar um
outro processo psql: esta sessão será executada em paralelo
lel com o primeiro.
50

Página 52
Para não ficar confuso, vamos indentar os comandos de
a segunda sessão para maior clareza. Esta sessão verá nosso
alterar?
postgres = # \ c teste
Você agora está conectado ao banco de dados "teste" como usuário
"postgres".
teste = # SELECIONE * DOS grupos;
g_no | monitor
------ + ---------
(0 linhas)
Não, não vai, porque a transação ainda não foi concluída.
Para continuar com nossa transação, vamos mover todos os alunos
para o grupo recém-criado:
teste = # ATUALIZAR alunos SET g_no = 'A-101';
ATUALIZAÇÃO 3
A segunda sessão ainda obtém dados consistentes, que foram
já presente no banco de dados quando o não comprometido
transação iniciada.
teste = # SELECIONE * DOS alunos;
s_id |
nome
| start_year | g_no
------ + -------- + ------------ + ------
1451 | Anna
|
2014 |
1432 | Victor |
2014 |
1556 | Nina
|
2015 |
(3 linhas)
Vamos comprometer todas as nossas alterações para concluir a transação:
51

Página 53
test = # COMMIT;
COMPROMETE
Por fim, a segunda sessão recebe todas as alterações feitas
por esta transação, como se eles aparecessem todos de uma vez:
teste = # SELECIONE * DOS grupos;
g_no | monitor
------- + ---------
A-101 |
1451
(1 linha)
teste = # SELECIONE * DOS alunos;
s_id |
nome
| start_year | g_no
------ + -------- + ------------ + -------
1451 | Anna
|
2014 | A-101
1432 | Victor |
2014 | A-101
1556 | Nina
|
2015 | A-101
(3 linhas)
É garantido que várias propriedades importantes do DBMS
são sempre observados.
Em primeiro lugar, uma transação é executada completamente
(como no exemplo acima), ou não. Se pelo menos um
dos comandos retorna um erro, ou abortamos o
transação com o comando ROLLBACK, o banco de dados
permanece no mesmo estado de antes do comando BEGIN.
Essa propriedade é chamada de atomicidade .
Em segundo lugar, quando a transação é confirmada, toda integridade
restrições devem ser verdadeiras, caso contrário, a transação é
revertido. Assim, os dados são consistentes antes e depois
a transação. Ele dá a essa propriedade o seu nome - consis-
tência .
52

Página 54
Terceiro, como o exemplo mostrou, outros usuários nunca
ver dados inconsistentes ainda não confirmados pelo trans-
açao. Essa propriedade é chamada de isolamento . Graças a isto
propriedade, o DBMS pode servir várias sessões em paralelo,
sem sacrificar a consistência dos dados. PostgreSQL é conhecido
para uma implementação de isolamento muito eficaz: várias sessões
sions podem executar consultas de leitura e gravação em paralelo, sem
travando um ao outro. O bloqueio ocorre apenas dois pro- diferentes
cesses tentam alterar a mesma linha simultaneamente.
E por fim, a durabilidade é garantida: todos os comprometidos
os dados não serão perdidos, mesmo em caso de falha (se os dados
base está configurada corretamente e tem backup regular, de
curso).
Estas são propriedades extremamente importantes, que devem ser
presente em qualquer sistema de gerenciamento de banco de dados relacional.
Para saber mais sobre as transações, consulte:
postgrespro.com/doc/tutorial-transactions.html
(Você pode encontrar ainda mais detalhes aqui:
postgrespro.com/doc/mvcc.html) .
53

Página 55
Comandos úteis do psql
\?
Referência de linha de comando para psql.
\h
Referência SQL: lista de comandos disponíveis ou
a sintaxe exata do comando.
\x
Alterna entre a exibição regular da tabela
(linhas e colunas) e um dis-
jogar (com cada coluna impressa em uma
linha). Isso é útil para visualizar vários "amplos"
linhas.
\eu
Lista de bancos de dados.
\ du
Lista de usuários.
\ dt
Lista de mesas.
\ di
Lista de índices.
\ dv
Lista de visualizações.
\ df
Lista de funções.
\ dn
Lista de esquemas.
\ dx
Lista de extensões instaladas.
\ dp
Lista de privilégios.
\ d nome
Informações detalhadas sobre o ob- especificado
ject.
\ d + nome
Informações detalhadas estendidas sobre o
objeto especificado.
\ timing on
Exibe o tempo de execução do operador.
54

Página 56
Conclusão
Só conseguimos cobrir uma pequena parte do que você
precisa saber sobre o DBMS, mas esperamos que você tenha
viu por si mesmo que não é nada difícil começar a usar
PostgreSQL. A linguagem SQL permite que você construa
consultas de várias complexidades, enquanto o PostgreSQL fornece
uma implementação eficaz e suporte de alta qualidade de
o padrão. Tente você mesmo e experimente!
E mais um comando psql importante. Para sair, en-
ter:
teste = # \ q
55

Página 57
Banco de dados de demonstração
Descrição
Informações gerais
Para seguir em frente e aprender consultas mais complexas, precisamos
para criar um banco de dados mais sério (não apenas três,
mas oito tabelas) e preencha-o com dados. Você pode ver
o diagrama entidade-relacionamento para o esquema de tal
um banco de dados na p. 57
Como campo de assunto, selecionamos voos de companhias aéreas: vamos
suponha que estamos falando sobre nossa companhia aérea ainda não existente
companhia. Esta área deve ser familiar para qualquer pessoa que tenha
já viajou de avião; em qualquer caso, vamos explicar tudo
coisa aqui. Ao desenvolver este banco de dados de demonstração, nós
tentou tornar o esquema do banco de dados o mais simples possível,
sem sobrecarregá-lo com detalhes desnecessários, mas não
muito simples para permitir a construção interessante e significativa
consultas.
56

Página 58
B
o
o
parente
g
s
# livro
_
ref
*
livro
_encontro
*
para
tal_am
ount
T
ickets
# Carraça
et_no
*
livro
_ref
*
pas
sen
ger_id
*
pas
sen
ger_nam
e
°
conta
ct_data
UMA
ir
cr
ré
# aeronave_
código
*
m
odel
*
alcance
S
come
# aeronave_
código
#s
e
at_no
*
fare_c
condições
T
icket_flig
h
ts
# tic
ket_no
# flight_id
*
fare_c
condições
*
uma
m
ount
B
o
ar
d
dentro
g
_p
uma
sses
# tic
ket_no
# flight_id
*
b
oarding
_não
*
seat_no
F
lig
h
ts
# flight_id
*
flight_n
o
*
schedu
led_departure
*
schedu
led_arrival
*
aeroporto de partida
*
chegada
uma
l_airport
*
status
*
airc
ra
ft_code
° ac
tua
l_departure
° ac
tua
l_arriv
al
UMA
ir
p
o
rts
# airport_c
tributo
*
airport_nam
e
*
cidade
*
coord
inates
*
tim
ez
1
57
Página 59
Então, a principal entidade é uma reserva .
Uma reserva pode incluir vários passageiros, com um
bilhete de tarifa emitido para cada passageiro. O passageiro faz
não constituem uma entidade separada. Para simplificar, podemos
presuma que todos os passageiros são únicos.
Cada bilhete contém um ou mais segmentos de voo (tick-
et_flights). Vários segmentos de voo podem ser incluídos em
um único tíquete nos seguintes casos:
1. Não há voos diretos entre os pontos de
partida e destino, portanto, um voo de várias etapas é
requeridos.
2. É uma passagem de ida e volta.
Embora não haja nenhuma restrição no esquema, é como-
concluiu que todos os bilhetes da reserva têm o mesmo voo
segmentos.
Cada vôo vai de um aeroporto para outro. Voos com
o mesmo número de voo tem os mesmos pontos de partida
tura e destino, mas diferem na data de partida.
No check-in do voo, o passageiro recebe um cartão de embarque ,
onde o número do assento é especificado. O passageiro pode
check-in para o voo apenas se este voo estiver incluído no
o bilhete. A combinação vôo / assento deve ser exclusiva para
evite emitir dois cartões de embarque para o mesmo assento.
O número de assentos na aeronave e sua distribuição
entre diferentes classes de viagens dependem do específico
modelo da aeronave realizando o vôo. É assumido
58

Página 60
que cada modelo de aeronave tem apenas uma configuração de cabine
ção. O esquema do banco de dados não verifica os números de assento
nos cartões de embarque têm os assentos correspondentes no
cabine da aeronave.
Nas seções a seguir, descreveremos cada um dos
bles, bem como visualizações e funções adicionais. Você pode
use o comando \ d + para obter a definição exata de qualquer
tabela, incluindo tipos de dados e descrições de colunas.
Reservas
Para voar com nossa companhia aérea, os passageiros reservam a passagem necessária
ets antecipadamente (book_date, que não deve ser anterior
mais de um mês antes do voo). A reserva é identificada
tificada por seu número (book_ref, uma combinação de seis posições
de letras e dígitos).
O campo total_amount armazena o preço total de todos os tick-
ets incluídos na reserva, para todos os passageiros.
Ingressos
Um bilhete tem um número único (ticket_no), que consiste
de 13 dígitos.
O bilhete inclui o documento de identidade do passageiro
número (passageiro_id), bem como seu primeiro e último
nomes (passageiro_nome) e informações de contato (con
tact_data).
59

Página 61
Observe que nem o ID do passageiro, nem o nome é per-
manent (por exemplo, pode-se mudar o sobrenome ou
passaporte), por isso é impossível identificar exclusivamente todos os carrapatos
ets de um determinado passageiro. Para simplificar, vamos supor
que todos os passageiros são únicos.
Segmentos de voo
Um segmento de voo conecta um bilhete a um voo e é
identificados por seus números.
Cada segmento de voo tem seu preço (valor) e classe de viagem
(fare_conditions).
Voos
A chave natural da tabela de voos consiste em dois
campos: o número do voo flight_no e a partida
data agendada_departura. Para fazer chaves estrangeiras para este
tabela um pouco mais curta, uma chave substituta flight_id é usada como
a chave primária.
Um voo sempre conecta dois pontos: departure_airport
e chegada_airport.
60

Página 62
61

Página 63
Não existe tal entidade como um "vôo de conexão": se houver
não há voos diretos de um aeroporto para outro, a passagem
simplesmente inclui vários segmentos de voo necessários.
Cada voo tem uma data e hora de partida programada
e chegada (agendada_ partida e agendada_ chegada
val). Os horários reais de partida e chegada (actual_de-
parture e actual_arrival) podem ser diferentes: a diferença
geralmente não é muito grande, mas às vezes pode ser até sete
2 horas se o voo atrasar.
O status do voo pode assumir um dos seguintes valores:
• Programado
O vôo está disponível para reserva. Acontece um
mês antes da data de partida planejada; antes
dessa vez, não há entrada para este voo no
base de dados.
• Na hora
O voo está aberto para check-in (vinte e quatro horas
antes da partida programada) e não está atrasado.
• Atrasado
O voo está aberto para check-in (vinte e quatro horas
antes da partida programada), mas está atrasado.
• Partiu
A aeronave já decolou e está no ar.
• Chegou
A aeronave atingiu o ponto de destino.
• Cancelado
O vôo foi cancelado.
62

Página 64
Aeroportos
Um aeroporto é identificado por um airport_code de três letras
e tem um airport_name.
O atributo de cidade da tabela de aeroportos identifica o
aeroportos da mesma cidade. A tabela também inclui coordi-
nates (longitude e latitude) e o fuso horário. Há sim
nenhuma entidade separada para a cidade.
Cartões de embarque
No momento do check-in, que abre vinte e quatro horas
antes da partida programada, o passageiro recebe um
cartão de embarque. Como o segmento de voo, o cartão de embarque
é identificado pelo número do bilhete e o número do voo.
Os cartões de embarque são atribuídos a números sequenciais (placa-
ing_no), na ordem de check-ins para o voo (este número
(ber é único apenas no contexto de um voo específico).
O cartão de embarque especifica o número do assento (seat_no).
Aeronave
Cada modelo de aeronave é identificado por seu ar de três dígitos
craft_code. A tabela também inclui o nome do ar-
modelo de embarcação e a distância máxima de voo, em quilômetros
(alcance).
63

Página 65
Assentos
Os assentos definem a configuração da cabine de cada modelo de aeronave.
Cada assento é definido por seu número (seat_no) e tem um
classe de viagem atribuída (fare_conditions): Economy, Com-
forte ou negócios.
Visualização de voos
Há uma visualização flight_v sobre a tabela de voos para pro
vide informações adicionais:
• detalhes sobre o aeroporto de partida
departure_airport, departure_airport_name,
Cidade de origem,
• detalhes sobre o aeroporto de chegada
chegada_airport, chegada_airport_name, ar-
rival_city,
• hora local de partida
schedule_departure_local, actual_departure_local,
• hora local de chegada
schedule_arrival_local, actual_arrival_local,
• duração do voo
duração_agendada, duração_real.
64

Página 66
Visualização de Rotas
A tabela de voos contém algumas redundâncias, que
você pode usar para destacar as informações da rota (número do voo
ber, aeroportos de partida e destino, modelo de aeronave)
isso não depende das datas de voo exatas.
Essas informações constituem a visualização das rotas. Além disso,
esta visualização mostra a matriz days_of_week representando
dias da semana em que os voos são realizados, e o
duração planejada do vôo.
A função “agora”
O banco de dados de demonstração contém um instantâneo de dados, semelhante
para uma cópia de backup de um sistema real capturado em algum ponto
em tempo. Por exemplo, se um voo tiver o status Partiu,
significa que a aeronave já havia decolado e estava
no ar no momento da cópia de segurança.
O tempo do instantâneo é salvo na função bookings.now
ção. Você pode usar esta função em consultas de demonstração para casos
isso exigiria a função now em um banco de dados real.
Além disso, o valor de retorno desta função determina o
versão do banco de dados de demonstração. A última versão disponível
disponível no momento desta publicação é de 15 de agosto de 2017.
65

Página 67
Instalação
Instalação a partir do site
O banco de dados de demonstração está disponível em três opções, que
diferem apenas no tamanho dos dados:
• edu.postgrespro.com/demo-small-en.zip
Um pequeno banco de dados com dados de voos de um mês
(21 MB, o tamanho do banco de dados é 280 MB).
• edu.postgrespro.com/demo-medium-en.zip
Um banco de dados médio com dados de voo por três meses
(62 MB, o tamanho do banco de dados é 702 MB).
• edu.postgrespro.com/demo-big-en.zip
Um grande banco de dados com dados de voos de um ano
(232 MB, o tamanho do banco de dados é 2638 MB).
O pequeno banco de dados é bom para escrever consultas e
não ocupam muito espaço em disco. Se você gostaria de con-
sider query optimization specifics, escolha a grande data-
base para ver o comportamento da consulta em grandes volumes de dados.
Os arquivos contêm uma cópia de backup lógica dos dados de demonstração
base criada com o utilitário pg_dump. Observe que se o
banco de dados de demonstração já existe, ele será excluído e recre-
atado à medida que é restaurado da cópia de backup. O dono
do banco de dados de demonstração será o usuário DBMS que executa o
roteiro.
Para instalar o banco de dados de demonstração no Linux, mude para o
usuário postgres e baixe o arquivo correspondente. Para
exemplo, para instalar o pequeno banco de dados, faça o seguinte:
66

Página 68
$ sudo su - postgres
$ wget https://edu.postgrespro.com/demo-small-en.zip
$ zcat demo-small-en.zip | psql
No Windows, baixe edu.postgrespro.com/demo-
arquivo small-en.zip , clique duas vezes nele para abrir o arquivo,
e copie o arquivo demo-small-en-20170815.sql para o
Diretório C: \ Arquivos de programas \ PostgresPro10.
Em seguida, inicie o psql (usando o atalho “SQL Shell (psql)”)
e execute o seguinte comando:
postgres # \ i demo-small-en-20170815.sql
Se o arquivo não for encontrado, verifique a propriedade “Iniciar em” de
o atalho; o arquivo deve estar localizado neste diretório.
Consultas de amostra
Algumas palavras sobre o esquema
Assim que a instalação for concluída, inicie o psql e conecte
para o banco de dados de demonstração:
postgres = # \ c demo
Você agora está conectado ao banco de dados "demo" como usuário
"postgres".
demo = #
67

Página 69
Todas as entidades nas quais estamos interessados estão armazenadas no
esquema de reservas. Conforme você se conecta ao banco de dados, este
esquema será usado automaticamente, então não há necessidade de
especifique explicitamente:
demo = # SELECT * FROM aircrafts;
aeronave_code |
modelo
| alcance
--------------- + --------------------- + -------
773
| Boeing 777-300
| 11100
763
| Boeing 767-300
|
7900
SU9
| Sukhoi Superjet-100 |
3000
320
| Airbus A320-200
|
5700
321
| Airbus A321-200
|
5600
319
| Airbus A319-100
|
6700
733
| Boeing 737-300
|
4200
CN1
| Caravana Cessna 208
|
1200
CR2
| Bombardier CRJ-200
|
2700
(9 linhas)
No entanto, para a função bookings.now, você ainda precisa
especificar o esquema, para diferenciá-lo do padrão
agora função:
demo = # SELECT bookings.now ();
agora
------------------------
15/08/2017 18: 00: 00 + 03
(1 linha)
Cidades e aeroportos podem ser selecionados com o seguinte
inquerir:
demo = # SELECT airport_code, city
DOS aeroportos LIMITE 5;
68

Página 70
airport_code |
cidade
-------------- + --------------------------
YKS
| Yakutsk
MJZ
| Mirnyj
KHV
| Khabarovsk
PKC
| Petropavlovsk
UUS
| Yuzhno-Sakhalinsk
(5 linhas)
O conteúdo do banco de dados é fornecido em inglês e
em russo. Você pode alternar entre esses idiomas
definir o parâmetro bookings.lang para “en” ou “ru,” re-
espectivamente. Por padrão, o idioma inglês é selecionado.
No nível da sessão, o parâmetro bookings.lang pode
ser definido da seguinte forma:
demo = # SET bookings.lang = ru;
Se você gostaria de definir esta configuração globalmente, execute o
seguinte comando:
demo = # ALTER DATABASE demo SET bookings.lang = ru;
ALTER DATABASE
Não se esqueça de se reconectar ao banco de dados para habilitar o
nova configuração global para sua sessão:
demo = # \ c
Você agora está conectado ao banco de dados "demo" como usuário
"postgres".
69

Página 71
Se você alterar a configuração de idioma para russo, a cidade
os nomes serão traduzidos para o russo:
demo = # SELECT airport_code, city
DOS aeroportos LIMITE 5;
airport_code |
cidade
-------------- + --------------------------
YKS
| Якутск
MJZ
| Мирный
KHV
| Хабаровск
PKC
| Петропавловск-Камчатский
UUS
| Южно-Сахалинск
(5 linhas)
Para entender como isso funciona, você pode dar uma olhada no
definição de aeronaves ou aeroportos usando o \ d + psql
comando.
Para obter mais informações sobre gerenciamento de esquema, consulte
postgrespro.com/doc/ddl-schemas.html.
Para obter detalhes sobre como definir os parâmetros de configuração, consulte
postgrespro.com/doc/config-setting.html.
Consultas Simples
A seguir, forneceremos alguns exemplos de problemas com base no
esquema de banco de dados de demonstração. A maioria deles é seguida por um
solução, enquanto o resto você pode resolver sozinho.
Problema. Quem viajou de Moscou (SVO) para Novosi-
birsk (OVB) no assento 1A ontem, e quando foi o bilhete
reservado?
70

Página 72
Solução. “Anteontem” é contado a partir do
valor booking.now, não da data atual.
SELECT t.passenger_name,
b.book_date
A PARTIR DE
reservas b
PARTICIPAR de ingressos t
ON t.book_ref = b.book_ref
JOIN boarding_passes bp
ON bp.ticket_no = t.ticket_no
JOIN voos f
ON f.flight_id = bp.flight_id
ONDE
f.departure_airport = 'SVO'
E
f.arrival_airport = 'OVB'
E
f.scheduled_departure :: date =
bookings.now () :: data - INTERVAL '2 dias'
E
bp.seat_no = '1A';
Problema. Quantos assentos permaneceram livres no voo PG0404
ontem?
Solução. Existem várias abordagens para resolver este
problema. O primeiro usa a cláusula NOT EXISTS para encontrar
os assentos sem os cartões de embarque correspondentes:
SELECT contagem (*)
A PARTIR DE
voos f
PARTICIPAR dos assentos
ON s.aircraft_code = f.aircraft_code
ONDE
f.flight_no = 'PG0404'
E
f.scheduled_departure :: date =
bookings.now () :: data - INTERVAL '1 dia'
E
NÃO EXISTE (
SELECT NULL
A PARTIR DE
boarding_passes bp
ONDE
bp.flight_id = f.flight_id
E
bp.seat_no = s.seat_no
);
71
Página 73
A segunda abordagem usa a operação de set subtrac-
ção:
SELECT contagem (*)
A PARTIR DE
(
SELECT s.seat_no
A PARTIR DE
assentos s
ONDE
s.aircraft_code = (
SELECT aeronave_code
A PARTIR DE
voos
ONDE
flight_no = 'PG0404'
E
schedule_departure :: date =
bookings.now () :: data - INTERVAL '1 dia'
)
EXCETO
SELECT bp.seat_no
A PARTIR DE
boarding_passes bp
ONDE
bp.flight_id = (
SELECT flight_id
A PARTIR DE
voos
ONDE
flight_no = 'PG0404'
E
schedule_departure :: date =
bookings.now () :: data - INTERVAL '1 dia'
)
) t;
A escolha depende muito de suas preferências pessoais.
Você só precisa levar em consideração que a execução da consulta
será diferente, então, se o desempenho for importante, faz sentido
para tentar ambas as abordagens.
72

Página 74
Problema. Quais voos tiveram os maiores atrasos? Imprima o
lista de dez “líderes”.
Solução. A consulta só precisa incluir o já de-
voos separados:
SELECIONE
f.flight_no,
f.scheduled_departure,
f.actual_departure,
f.actual_departure - f.scheduled_departure
Atraso AS
A PARTIR DE
voos f
ONDE
f.actual_departure NÃO É NULO
ORDER BY f.actual_departure - f.scheduled_departure
DESC
LIMIT 10;
A mesma condição pode ser baseada na coluna de status.
Funções de agregação
Problema. Qual é a duração de voo mais curta para cada
possível voo de Moscou para São Petersburgo, e como
muitas vezes o voo atrasou mais de uma hora?
Solução. Para resolver este problema, é conveniente usar
a visualização flight_v disponível em vez de lidar com ta-
ble junta. Você precisa levar em consideração apenas esses voos
que já chegaram.
73

Página 75
SELECIONE
f.flight_no,
f.scheduled_duration,
min (f.actual_duration),
max (f.actual_duration),
soma (CASE
WHEN f.actual_departure>
f.scheduled_departure +
INTERVAL '1 hora'
ENTÃO 1 MAIS 0
END) atrasos
A PARTIR DE
voos_v f
ONDE
f.departure_city = 'Moscou'
E
f.arrival_city = 'St. Petersburgo '
E
f.status = 'Chegou'
GROUP BY f.flight_no,
f.scheduled_duration;
Problema. Encontre os passageiros mais disciplinados que verificaram
em primeiro lugar para todos os seus voos. Leve em consideração apenas aqueles
passageiros que fizeram pelo menos dois voos.
Solução. Use o fato de que os números dos cartões de embarque são
emitido no pedido de check-in.
SELECIONE
t.passenger_name,
t.ticket_no
A PARTIR DE
bilhetes t
JOIN boarding_passes bp
ON bp.ticket_no = t.ticket_no
GROUP BY t.passenger_name,
t.ticket_no
TENDO
max (bp.boarding_no) = 1
E
contagem (*)> 1;
74

Página 76
Problema. Quantas pessoas podem ser incluídas em um único
reserva de acordo com os dados disponíveis?
Solução. Primeiro, vamos contar o número de passageiros em
cada reserva e, em seguida, o número de reservas para cada
Número de passageiros.
SELECIONE
tt.cnt,
contagem(*)
A PARTIR DE
(
SELECIONE
t.book_ref,
contagem (*) cnt
A PARTIR DE
bilhetes t
GROUP BY t.book_ref
) tt
GRUPO POR tt.cnt
ORDER BY tt.cnt;
Funções de janela
Problema. Para cada passagem, exiba todos os voos incluídos
segmentos, junto com o tempo de conexão. Limite o resultado
aos ingressos reservados há uma semana.
Solução. Use as funções da janela para evitar o acesso ao
mesmos dados duas vezes.
Nos resultados da consulta fornecidos abaixo, podemos ver que o
o amortecimento de tempo entre os voos é de vários dias em alguns
casos. Via de regra, são passagens de ida e volta, ou seja, nós
veja o tempo de permanência no ponto de destino, não
o tempo entre voos de conexão. Usando a solução
para um dos problemas na seção "Arrays", você pode
leve esse fato em consideração ao construir a consulta.
75
Página 77
SELECT tf.ticket_no,
f.departure_airport,
f.arrival_airport,
f.scheduled_arrival,
chumbo (f.scheduled_departure) OVER w
AS next_departure,
chumbo (f.scheduled_departure) OVER w -
f.scheduled_arrival AS gap
A PARTIR DE
reservas b
PARTICIPAR de ingressos t
ON t.book_ref = b.book_ref
JOIN ticket_flights tf
ON tf.ticket_no = t.ticket_no
JOIN voos f
ON tf.flight_id = f.flight_id
ONDE
b.book_date =
bookings.now () :: data - INTERVAL '7 dias'
WINDOW w AS (PARTIÇÃO POR tf.ticket_no
ORDER BY f.scheduled_departure);
Problema. Quais combinações de nomes e sobrenomes ocorrem
cur na maioria das vezes? Qual é a proporção dos passageiros com
tais nomes para o número total de passageiros?
Solução. Uma função de janela é usada para calcular o total
Número de passageiros.
SELECIONE
nome do passageiro,
rodada (100,0 * cnt / soma (cnt) OVER (), 2)
AS por cento
A PARTIR DE
(
SELECIONE
nome do passageiro,
contagem (*) cnt
A PARTIR DE
ingressos
GROUP BY passage_name
)t
ORDER BY por cento DESC;
76

Página 78
Problema. Resolva o problema anterior para primeiros nomes e
sobrenomes separadamente.
Solução. Considere uma consulta para primeiros nomes:
COM p AS (
SELECT à esquerda (passageiro_nome,
posição ('' IN passage_name))
AS passageiro_nome
A PARTIR DE
ingressos
)
SELECIONE
nome do passageiro,
rodada (100,0 * cnt / soma (cnt) OVER (), 2)
AS por cento
A PARTIR DE
(
SELECIONE
nome do passageiro,
contagem (*) cnt
A PARTIR DE
p
GROUP BY passage_name
)t
ORDER BY por cento DESC;
Conclusão: não use um único campo de texto para diferentes
valores se você for usá-los separadamente; na ciência
termos específicos, é chamado de "primeira forma normal".
Arrays
Problema. Não há indicação se o bilhete é um
caminho ou ida e volta. No entanto, você pode descobrir por com-
parear o primeiro ponto de partida com o último ponto de
destino. Exibir aeroportos de partida e destino
para cada tíquete, ignorando as conexões e decida se
é uma passagem de ida e volta.
77

Página 79
Solução. Uma das soluções mais fáceis é trabalhar com um
matriz de aeroportos convertidos da lista de aeroportos no
itinerário usando a função agregada array_agg. Nós
selecione o elemento do meio da matriz como o aeroporto de
destino, assumindo que a saída e a entrada
caminhos têm o mesmo número de paradas.
COM t AS (
SELECT ticket_no,
uma,
a [1]
saída,
a [cardinalidade (a)]
last_arrival,
a [cardinalidade (a) / 2 + 1] meio
A PARTIR DE (
SELECIONE
t.ticket_no,
array_agg (f.departure_airport
ORDER BY f.scheduled_departure) ||
(array_agg (f.arrival_airport
ORDER BY f.scheduled_departure DESC)
) [1] AS a
A PARTIR DE
bilhetes t
JOIN ticket_flights tf
ON tf.ticket_no = t.ticket_no
JOIN voos f
ON f.flight_id = tf.flight_id
GROUP BY t.ticket_no
)t
)
SELECT t.ticket_no,
ta,
t.departure,
CASO
QUANDO t.departure = t.last_arrival
ENTÃO t.médio
ELSE t.last_arrival
END chegada,
(t.departure = t.last_arrival) return_ticket
A PARTIR DE
t;
78

Página 80
Neste exemplo, a tabela de tickets é verificada apenas uma vez.
A variedade de aeroportos é exibida apenas para fins de clareza; para grande
volumes de dados, faz sentido removê-los do
inquerir.
Problema. Encontre os bilhetes de ida e volta em que o
a rota ligada difere da de entrada.
Problema. Encontre os pares de aeroportos com entrada e saída
voos com destino a partir em dias diferentes da semana.
Solução. A parte do problema que envolve a construção
vários dias da semana é virtualmente resolvido no
visualização de rotas. Você só precisa encontrar o cruzamento usando
o operador:
SELECT r1.departure_airport,
r1.arrival_airport,
r1.days_of_week dow,
r2.days_of_week dow_back
A PARTIR DE
rotas r1
JOIN rotas r2
ON r1.arrival_airport = r2.departure_airport
AND r1.departure_airport = r2.arrival_airport
ONDE
NOT (r1.days_of_week && r2.days_of_week);
Consultas Recursivas
Problema. Como você pode ir de Ust-Kut (UKX) para Neryun-
gri (CNN) com o número mínimo de conexões, e
qual será o tempo de vôo?
79

Página 81
Solução. Aqui você tem que encontrar o caminho mais curto no
gráfico. Isso pode ser feito com a seguinte consulta recursiva:
COM RECURSIVO p (
last_arrival,
destino,
lúpulo,
voos,
hora do voo,
encontrado
) COMO (
SELECT a_from.airport_code,
a_to.airport_code,
array [a_from.airport_code],
array [] :: char (6) [],
intervalo '0',
a_from.airport_code = a_to.airport_code
A PARTIR DE
aeroportos a_from,
aeroportos a_to
ONDE
a_from.airport_code = 'UKX'
E
a_to.airport_code = 'CNN'
UNION ALL
SELECT r.arrival_airport,
p.destination,
(p.hops || r.arrival_airport) :: char (3) [],
(p.flights || r.flight_no) :: char (6) [],
p.flight_time + r.duration,
bool_or (r.arrival_airport = p.destination)
SOBRE ()
A PARTIR DE
p
JOIN rotas r
ON r.departure_airport = p.last_arrival
ONDE
NÃO r.arrival_airport = QUALQUER (p.hops)
E
NÃO p.found
)
SELECT lúpulo,
voos,
hora do voo
A PARTIR DE
p
ONDE
p.last_arrival = p.destination;
80

Página 82
O loop infinito é evitado verificando a matriz de saltos.
Observe que a pesquisa em largura é realizada, então o
o primeiro caminho encontrado será o mais curto de uma conexão -
sensato. Para evitar o loop em outros caminhos (que podem ser nu-
merous), o atributo encontrado é usado, que é calculado
usando a função de janela bool_or.
É útil comparar esta consulta com sua variante mais simples
sem o truque encontrado.
Para saber mais sobre consultas recursivas, consulte a documentação
ção : postgrespro.com/doc/queries-with.html
Problema. Qual é o número máximo de conexões
que pode ser necessário para ir de qualquer aeroporto a qualquer outro
aeroporto?
Solução. Podemos tomar a consulta anterior como base
para a solução. No entanto, a primeira iteração deve agora
contêm todos os pares de aeroportos possíveis, não um único par: cada
o aeroporto deve estar conectado a outro aeroporto. Para todos
esses pares, primeiro encontramos o caminho mais curto e, em seguida, selecionamos
o mais longo deles.
Obviamente, isso só é possível se o gráfico de rotas estiver conectado.
Esta consulta também usa o atributo found, mas aqui deve
ser calculado separadamente para cada par de aeroportos.
81

Página 83
COM RECURSIVO p (
saída,
last_arrival,
destino,
lúpulo,
encontrado
) COMO (
SELECT a_from.airport_code,
a_from.airport_code,
a_to.airport_code,
array [a_from.airport_code],
a_from.airport_code = a_to.airport_code
A PARTIR DE
aeroportos a_from,
aeroportos a_to
UNION ALL
SELECT p.departure,
r.arrival_airport,
p.destination,
(p.hops || r.arrival_airport) :: char (3) [],
bool_or (r.arrival_airport = p.destination)
OVER (PARTIÇÃO POR p. Partida,
p.destination)
A PARTIR DE
p
JOIN rotas r
ON r.departure_airport = p.last_arrival
ONDE
NÃO r.arrival_airport = QUALQUER (p.hops)
E
NÃO p.found
)
SELECT max (cardinalidade (saltos) -1)
A PARTIR DE
p
ONDE
p.last_arrival = p.destination;
Problema. Encontre a rota mais curta de Ust-Kut (UKX) para
Negungri (CNN) do ponto de vista do tempo de vôo (ignor-
tempo de conexão).
Dica: a rota pode não ser a ideal em relação ao
número de conexões.
82

Página 84
Solução.
COM RECURSIVO p (
last_arrival,
destino,
lúpulo,
voos,
hora do voo,
min_time
) COMO (
SELECT a_from.airport_code,
a_to.airport_code,
array [a_from.airport_code],
array [] :: char (6) [],
intervalo '0',
NULL :: intervalo
A PARTIR DE
aeroportos a_from,
aeroportos a_to
ONDE
a_from.airport_code = 'UKX'
E
a_to.airport_code = 'CNN'
UNION ALL
SELECT r.arrival_airport,
p.destination,
(p.hops || r.arrival_airport) :: char (3) [],
(p.flights || r.flight_no) :: char (6) [],
p.flight_time + r.duration,
menos (
p.min_time, min (p.flight_time + r.duration)
FILTRO (
ONDE r.arrival_airport = p.destination
) SOBRE ()
)
A PARTIR DE
p
JOIN rotas r
ON r.departure_airport = p.last_arrival
ONDE
NÃO r.arrival_airport = QUALQUER (p.hops)
E
p.flight_time + r.duration <
coalescer (p.min_time, INTERVAL '1 ano')
)
83

Página 85
SELECT lúpulo,
voos,
hora do voo
A PARTIR DE
(
SELECT lúpulo,
voos,
hora do voo,
min (min_time) OVER () min_time
A PARTIR DE
p
ONDE
p.last_arrival = p.destination
)t
ONDE
flight_time = min_time;
Funções e extensões
Problema. Encontre a distância entre Kaliningrado (KGD) e
Petropavlovsk-Kamchatsky (PKV).
Solução. Conhecemos as coordenadas do aeroporto. Para calcular o
distância, podemos usar a extensão de distância terrestre (e
em seguida, converta milhas em quilômetros).
CRIAR EXTENSÃO SE NÃO EXISTIR cubo;
CRIAR EXTENSÃO SE NÃO EXISTIR distância da terra;
SELECT round (
(a_from.coordinates <@> a_to.coordinates) *
1.609344
)
A PARTIR DE
aeroportos a_from,
aeroportos a_to
ONDE
a_from.airport_code = 'KGD'
E
a_to.airport_code = 'PKC';
Problema. Desenhe o gráfico de voos entre todos os aeroportos.
84

Página 86
Características adicionais
Pesquisa de Texto Completo
Apesar de toda a força da linguagem de consulta SQL, é
recursos nem sempre são suficientes para o gerenciamento de dados eficaz
dling. Tornou-se especialmente evidente recentemente, quando
avalanches de dados, geralmente mal estruturados, preenchidos com dados
armazenamentos. Uma boa parte do Big Data é construída por textos, que
são difíceis de analisar em campos de banco de dados.
Pesquisando documentos escritos em linguagens naturais,
com os resultados geralmente classificados por relevância para a pesquisa
consulta, é chamada de pesquisa de texto completo. Na forma mais simples e mais
caso típico, a consulta consiste em uma ou mais palavras, e
a relevância é definida pela frequência dessas palavras
no documento. Isso é mais ou menos o que fazemos quando
digitando uma frase nos motores de busca Google ou Yandex.
Há um grande número de mecanismos de pesquisa, gratuitos e pagos,
que permitem que você indexe toda a coleção de seus
documentos e configurar a pesquisa de uma qualidade bastante decente.
Nesse caso, o índice, a ferramenta mais importante de pesquisa
speedup, não faz parte do banco de dados. Significa que
muitos recursos valiosos do DBMS ficam indisponíveis: dados-
sincronização de base, isolamento de transação, acesso e
85

Página 87
usando metadados para limitar o intervalo de pesquisa, configurando
cura o acesso a documentos e muito mais.
As deficiências do homem de banco de dados orientado a documentos
sistemas de gestão, que ganham cada vez mais
geralmente estão no mesmo campo: eles têm texto completo rico
funcionalidade de pesquisa, mas segurança de dados e sincronização
recursos são de baixa prioridade. Além disso, eles geralmente pertencem
para a classe NoSQL DBMS (por exemplo, MongoDB), então por
design, eles não têm todo o poder de SQL acumulado sobre
anos.
Por outro lado, os sistemas de banco de dados SQL tradicionais têm
motores de pesquisa de texto completo integrados. O operador LIKE está dentro
incluído na sintaxe SQL padrão, mas sua flexibilidade é
obviamente insuficiente. Como resultado, os desenvolvedores de DBMS tiveram
para adicionar suas próprias extensões ao padrão SQL.
No PostgreSQL, esses são operadores de comparação ILIKE, ~,
~ *, mas também não resolvem todos os problemas, pois
não levam em consideração a variação gramatical, não são
adequado para classificação e trabalho bastante lento.
Ao falar sobre as ferramentas de pesquisa de texto completo em si,
é importante entender que eles estão longe de ser
padronizado; cada implementação de DBMS usa seu próprio
sintaxe e suas próprias abordagens. Aqui nós apenas forneceremos
alguns exemplos simples.
Para aprender sobre os recursos de pesquisa de texto completo, criamos
outra tabela em nosso banco de dados de demonstração. Que seja um palestrante
rascunho de notas divididas em capítulos por tópicos de aula:
86

Página 88
test = # CREATE TABLE course_chapters (
c_no text REFERENCES cursos (c_no),
ch_no text,
texto ch_title,
texto txt,
CONSTRAINT pkt_ch CHAVE PRIMÁRIA (ch_no, c_no)
);
CRIAR A TABELA
Agora entramos no texto das primeiras palestras de nossos cursos
CS301 e CS305:
test = # INSERT INTO course_chapters (
c_no, ch_no, ch_title, txt)
VALORES
('CS301', 'I', 'Bancos de dados',
'Começamos nosso conhecimento com' ||
'o fascinante mundo dos bancos de dados'),
('CS301', 'II', 'Primeiras etapas',
'Ficando mais fascinado com' ||
'o mundo dos bancos de dados'),
('CS305', 'I', 'Redes locais',
'Aqui começamos nossa jornada de aventuras' ||
'através do intrigante mundo das redes');
INSERIR 0 3
Vamos verificar o resultado:
test = # SELECT ch_no AS no, ch_title, txt
FROM course_chapters \ gx
- [REGISTRO 1] -----------------------------------------
não
| Eu
ch_title | Bancos de dados
TXT
| Neste capítulo, começamos a nos familiarizar
com o fascinante mundo do banco de dados
87

Página 89
- [REGISTRO 2] -----------------------------------------
não
| II
ch_title | Primeiros passos
TXT
| Ficando mais fascinado com o mundo de
bases de dados
- [REGISTRO 3] -----------------------------------------
não
| Eu
ch_title | Redes Locais
TXT
| Aqui começamos nossa jornada de aventuras
através do intrigante mundo das redes
Para encontrar as informações sobre bancos de dados usando o tradicional
SQL significa, use o operador LIKE:
test = # SELECT txt
FROM course_chapters
ONDE txt LIKE '% fascination%'
\ gx
Obteremos um resultado previsível: 0 linhas. Isso é porque LIKE
não sabe que também deve procurar outras palavras
com a mesma raiz. A pergunta
test = # SELECT txt
FROM course_chapters
ONDE txt LIKE% fascinado% '\ gx
retornará a linha do capítulo II (mas não do capítulo
ter I, onde o adjetivo “fascinante” é usado):
- [REGISTRO 1] -----------------------------------------
TXT
| Ficando mais fascinado com o mundo de
bases de dados
88

Página 90
PostgreSQL fornece o operador ILIKE, que não permite
preocupar-se com caixas de cartas; caso contrário, você também
tem que aceitar letras maiúsculas e minúsculas em ac-
contagem. Naturalmente, um especialista em SQL sempre pode usar
expressões (padrões de pesquisa). Compondo expressões regulares
missões é uma tarefa envolvente, quase como arte. Mas quando
não há tempo para arte, vale a pena ter uma ferramenta que pode
simplesmente faça o trabalho.
Então, vamos adicionar mais uma coluna ao curso_chapters ta-
ble. Ele terá um tsvector de tipo de dados especial:
test = # ALTER TABLE course_chapters
ADD txtvector tsvector;
test = # UPDATE course_chapters
SET txtvector = to_tsvector ('inglês', txt);
test = # SELECT txtvector FROM course_chapters \ gx
- [REGISTRO 1] -----------------------------------------
txtvector | 'conhecido': 4 'bases de dados': 8 'fascin': 7
'start': 2 'world': 9
- [REGISTRO 2] -----------------------------------------
txtvector | 'databas': 8 'fascin': 3 'get': 1 'mundo': 6
- [REGISTRO 3] -----------------------------------------
txtvector | 'intrigu': 8 'jornada': 5 'rede': 11
'início': 3 'mundo': 9
Como podemos ver, as linhas mudaram:
1. As palavras são reduzidas a suas partes imutáveis (lex-
emes).
2. Números apareceram. Eles indicam a palavra
posição em nosso texto.
89
Página 91
3. Não há preposições, e nem haveria
ser quaisquer conjunções ou outras partes da frase
que não são importantes para a pesquisa (o chamado stop-
palavras).
Para configurar uma pesquisa mais avançada, gostaríamos de in-
inclua os títulos dos capítulos na área de pesquisa. Além disso, para enfatizar
seu significado, vamos atribuir peso (importância) para
usando a função setweight. Vamos modificar o ta-
ble:
test = # UPDATE course_chapters
SET txtvector =
setweight (to_tsvector ('english', ch_title), 'B')
|| '' ||
setweight (to_tsvector ('inglês', txt), 'D');
ATUALIZAÇÃO 3
test = # SELECT txtvector FROM course_chapters \ gx
- [REGISTRO 1] -----------------------------------------
txtvector | 'conhecimento': 5 'bases de dados': 1B, 9 'fascin': 8
'início': 3 'mundo': 10
- [REGISTRO 2] -----------------------------------------
txtvector | 'bases de dados': 10 'fascin': 5 'primeiro': 1B 'obter': 3
'etapa': 2B 'mundo': 8
- [REGISTRO 3] -----------------------------------------
txtvector | 'intrigu': 10 'jornada': 7 'local': 1B
'rede': 2B, 13 'início': 5 'mundo': 11
Lexemes receberam marcadores de peso relativo: B e D
(as opções possíveis são A, B, C, D). Vamos atribuir peso real
ao construir consultas, o que os tornará mais flexíveis
ble.
Totalmente armado, vamos voltar a pesquisar. A função to_tsquery-
ção é semelhante à função to_tsvector que vimos acima:
90

Página 92
ele converte uma string para o tipo de dados tsquery usado em
consultas.
test = # SELECT ch_title
FROM course_chapters
ONDE txtvector @@
to_tsquery ('inglês', 'fascinação & banco de dados');
ch_title
-------------
Bancos de dados
Primeiros passos
(2 linhas)
Você pode verificar que 'fascinado e banco de dados' e seus
as variantes gramaticais darão o mesmo resultado. Nós temos
usou o operador de comparação @@, que funciona de maneira semelhante a
GOSTAR. A sintaxe deste operador não permite natural
expressões de linguagem com espaços, como “fascinante
mundo ”, é por isso que as palavras são conectadas pelo“ e ”logi-
operador de cal.
O argumento 'inglês' indica a configuração usada
por DBMS. Ele define dicionários plugáveis e o analisador
programa, que divide a frase em lexemas separados.
Apesar do nome, os dicionários permitem todos os tipos de lex-
transformações eme.
Por exemplo, um dicionário de lematizador simples como bola de neve
(que é usado por padrão) reduz a palavra a seu
parte mutável; é por isso que a pesquisa ignora terminações de palavras
em consultas. Você também pode conectar outros dicionários, como
como hunspell (que pode lidar melhor com a morfologia das palavras)
ou sem acento (remove os diacríticos das letras).
91

Página 93
Os pesos atribuídos permitem exibir os resultados da pesquisa
por sua classificação:
test = # SELECT ch_title,
ts_rank_cd ('{0.1, 0.0, 1.0, 0.0}', txtvector, q)
FROM course_chapters,
to_tsquery ('inglês', 'Bancos de dados') q
ONDE txtvector @@ q
ORDER BY ts_rank_cd DESC;
ch_title
| ts_rank_cd
------------- + ------------
Bancos de dados
|
1,1
Primeiros passos |
0,1
(2 linhas)
A matriz {0.1, 0.0, 1.0, 0.0} define o peso. É uma op-
argumento internacional da função ts_rank_cd. Por padrão,
matriz {0,1, 0,2, 0,4, 1,0} corresponde a D, C, B, A. A palavra
o peso aumenta a importância da linha retornada,
o que ajuda a classificar os resultados.
No experimento final, vamos modificar o formato de exibição.
Suponha que gostaríamos de exibir as palavras encontradas em
negrito na página html. A função ts_headline de-
multa os símbolos para enquadrar a palavra, bem como os min-
imum / número máximo de palavras a serem exibidas em uma única
linha:
test = # SELECT ts_headline (
'Inglês',
TXT,
to_tsquery ('inglês', 'mundo'),
'StartSel = <b>, StopSel = </b>, MaxWords = 50, MinWords = 5'
)
FROM course_chapters
ONDE to_tsvector ('inglês', txt) @@
to_tsquery ('inglês', 'mundo');
92

Página 94
- [REGISTRO 1] -----------------------------------------
ts_headline | com o banco de dados fascinante
<b> mundo </b>.
- [REGISTRO 2] -----------------------------------------
ts_headline | com o <b> mundo </b> dos bancos de dados.
- [REGISTRO 3] -----------------------------------------
ts_headline | através do intrigante <b> mundo </b> de
redes
Para acelerar a pesquisa de texto completo, índices especiais são usados:
GiST, GIN e RUM. Esses índices diferem do normal
índices de banco de dados. Como muitas outras pesquisas de texto completo úteis
recursos, eles estão fora do escopo deste guia rápido.
Para saber mais sobre pesquisa de texto completo, consulte PostgreSQL doc-
umentation: www.postgrespro.com/doc/textsearch.
Usando JSON e JSONB
Desde o início, a principal prioridade do baseado em SQL
bancos de dados relacionais eram consistência e segurança de dados,
enquanto os volumes de informação eram incomparáveis para
os modernos. Quando uma nova geração de DBMS NoSQL
apareceu, levantou uma bandeira na comunidade: um muito sim-
estrutura de dados mais ampla (no início, havia principalmente ta-
bles com apenas duas colunas para pares de valores-chave) permitidos
para acelerar a pesquisa muitas vezes. Usando ativamente paralelo
cálculos, eles poderiam processar volumes sem precedentes
de informações e eram fáceis de dimensionar. Bancos de dados NoSQL
não precisava armazenar informações em linhas e colunas
armazenamento de dados orientado permitido para acelerar e paralelizar
cálculos para muitos tipos de tarefas.
93

Página 95
Assim que o choque inicial passou, ficou claro que
para a maioria das tarefas reais, uma estrutura tão simples não era suficiente.
Chaves compostas foram introduzidas e, em seguida, grupos de chaves
apareceu. O DBMS relacional não queria ficar para trás e
começou a adicionar novos recursos típicos do NoSQL.
Desde a mudança do esquema do banco de dados no DBMS relacional
incorrem em alto custo computacional, um novo tipo de dados JSON
veio a calhar. No início, era direcionado a desenvolvedores JS,
incluindo aqueles que escrevem aplicativos AJAX, portanto, JS no
título. É uma espécie de lidar com toda a complexidade do
dados, permitindo criar complexos lineares e hierárquicos
objetos-estrutura; sua adição não exigiu a conversão
todo o banco de dados.
Os desenvolvedores de aplicativos não tiveram que modificar o banco de dados
esquema mais. Assim como XML, a sintaxe JSON estritamente ob-
atende a hierarquia de dados. JSON é flexível o suficiente para funcionar
com dados não uniformes e às vezes imprevisíveis
estrutura.
Suponha que nosso banco de dados de demonstração de alunos agora permite entrar
dados pessoais: realizamos uma pesquisa e coletamos os
informações dos professores. Algumas perguntas na pergunta
questionário são opcionais, enquanto outras questões incluem o
“Adicione mais informações sobre você” e “outros” campos.
Se adicionarmos novos dados ao banco de dados da maneira usual
ner, haveria muitos campos vazios em vários novos
colunas ou tabelas adicionais. O que é ainda pior é que
novas colunas podem aparecer no futuro, e então iremos
tem que refatorar um pouco todo o banco de dados.
94

Página 96
Podemos resolver esse problema usando o tipo json ou o
tipo jsonb, que apareceu mais tarde. As lojas do tipo jsonb
dados em uma forma binária compacta e, ao contrário do json, suporta
índices, que podem acelerar a pesquisa por vezes.
test = # CREATE TABLE student_details (
de_id int,
s_id int REFERÊNCIAS alunos (s_id),
detalhes json,
CONSTRAINT pk_d CHAVE PRIMÁRIA (s_id, de_id)
);
test = # INSERT INTO student_details (de_id, s_id, detalhes)
VALORES
(1, 1451,
'{"méritos": "nenhum",
"falhas":
"consumo imoderado de sorvete"
} '),
(2, 1432,
'{ "hobbies":
{"guitarrista":
{"banda": "Postgressores",
"guitarras": ["Strat", "Telec"]
}
}
} '),
(3, 1556,
'{"hobbies": "cosplay",
"méritos":
{"mãe de cinco filhos":
{
"Basil": "m", "Simon": "m", "Lucie": "f",
"Mark": "m",
"Alex": "desconhecido"
}
}
} '),
(4, 1451,
'{"status": "expulso"
} ');
95

Página 97
Vamos verificar se todos os dados estão disponíveis. Por conveniência,
vamos juntar as tabelas student_details e students with
a ajuda da cláusula WHERE, uma vez que a nova tabela faz
não contém nomes de alunos:
test = # SELECT s.name, sd.details
FROM student_details sd, students s
ONDE s.s_id = sd.s_id \ gx
- [REGISTRO 1] --------------------------------------
nome
| Anna
detalhes | {"méritos": "nenhum",
+
|
"falhas":
+
|
"consumo imoderado de sorvete"
+
|}
- [REGISTRO 2] --------------------------------------
nome
| Vencedor
detalhes | { "hobbies":
+
|
{"guitarrista":
+
|
{"banda": "Postgressores",
+
|
"guitarras": ["Strat", "Telec"]
+
|
}
+
|
}
+
|}
- [REGISTRO 3] --------------------------------------
nome
| Nina
detalhes | {"hobbies": "cosplay",
+
|
"méritos":
+
|
{"mãe de cinco filhos":
+
|
{"Basil": "m",
+
|
"Simon": "m",
+
|
"Lucie": "f",
+
|
"Mark": "m",
+
|
"Alex": "desconhecido"
+
|
}
+
|
}
+
|}
- [REGISTRO 4] --------------------------------------
nome
| Anna
detalhes | {"status": "expulso"
+
|}
96

Página 98
Suponha que estejamos interessados em entradas que contenham informações
sobre os méritos dos alunos. Podemos acessar os valores de
a chave “méritos” usando um operador especial - >>:
test = # SELECT s.name, sd.details
A PARTIR DE
student_details sd, students s
ONDE s.s_id = sd.s_id
E
sd.details - >> 'méritos' NÃO É NULO \ gx
- [REGISTRO 1] --------------------------------------
nome
| Anna
detalhes | {"méritos": "nenhum",
+
|
"falhas":
+
|
"consumo imoderado de sorvete"
+
|}
- [REGISTRO 2] --------------------------------------
nome
| Nina
detalhes | {"hobbies": "cosplay",
+
|
"méritos":
+
|
{"mãe de cinco filhos":
+
|
{"Basil": "m",
+
|
"Simon": "m",
+
|
"Lucie": "f",
+
|
"Mark": "m",
+
|
"Alex": "desconhecido"
+
|
}
+
|
}
+
|}
Certificamo-nos de que as duas entradas estão relacionadas aos méritos
de Anna e Nina, mas é improvável que tal resultado satisfaça
nós, já que os méritos de Anna são na verdade “nenhum”. Vamos modificar o
inquerir:
test = # SELECT s.name, sd.details
A PARTIR DE
student_details sd, students s
ONDE s.s_id = sd.s_id
E
sd.details - >> 'méritos' NÃO É NULO
E
sd.details - >> 'merits'! = 'none';
97

Página 99
Certifique-se de que esta consulta retorne apenas Nina, cujos méritos
são reais.
Este método nem sempre funciona. Vamos tentar descobrir
quais guitarras nosso músico Victor está tocando:
test = # SELECT sd.de_id, s.name, sd.details
A PARTIR DE
student_details sd, students s
ONDE s.s_id = sd.s_id
E
sd.details - >> 'guitars' NÃO É NULO \ gx
Esta consulta não retornará nada. É porque a correspondência
o par chave-valor esponjoso está localizado dentro da hierarquia JSON
chy, aninhado nos pares de um nível superior:
nome
| Vencedor
detalhes | { "hobbies":
+
|
{"guitarrista":
+
|
{"banda": "Postgressores",
+
|
"guitarras": ["Strat", "Telec"]
+
|
}
+
|
}
+
|}
Para chegar às guitarras, vamos usar o operador #> e descer
a hierarquia começando com "hobbies":
test = # SELECT sd.de_id, s.name,
sd.details #> 'hobbies, guitarist, guitars'
A PARTIR DE
student_details sd, students s
ONDE s.s_id = sd.s_id
E
sd.details #> 'hobbies, guitarist, guitars'
NÃO É NULO \ gx
Podemos ver que Victor é fã da Fender:
98

Página 100
de_id |
nome
|
?coluna?
------- + -------- + -------------------
2 | Victor | ["Strat", "Telec"]
O tipo json tem um irmão mais novo: jsonb. A carta
“B” implica o formato binário (e não de texto) de armazenamento de dados
era. Esses dados podem ser compactados, o que permite
pesquisa. Hoje em dia, jsonb é usado com muito mais frequência do que
json.
test = # ALTER TABLE student_details
ADD details_b jsonb;
test = # UPDATE student_details
SET details_b = to_jsonb (detalhes);
test = # SELECT de_id, details_b
FROM student_details \ gx
- [REGISTRO 1] --------------------------------------
de_id
|1
details_b | {"falhas": "sorvete imoderado
consumo "," méritos ":" nenhum "}
- [REGISTRO 2] --------------------------------------
de_id
|2
details_b | {"hobbies": {"guitarrista": {"guitarras":
["Strat", "Telec"], "banda":
"Postgressores"}}}
- [REGISTRO 3] --------------------------------------
de_id
|3
details_b | {"hobbies": "cosplay", "méritos":
{"mãe de cinco filhos": {"Basil": "m",
"Lucie": "f", "Alex": "desconhecido",
"Mark": "m", "Simon": "m"}}}
- [REGISTRO 4] --------------------------------------
de_id
|4
details_b | {"status": "expulso"}
99

Página 101
Podemos notar que, além de uma notação diferente, o
a ordem dos valores nos pares mudou: Alex agora está dis-
tocou antes de Mark. Não é uma desvantagem do jsonb as
em comparação com json, são simplesmente suas especificações de armazenamento de dados.
O tipo jsonb é suportado por um grande número de oper-
atores. Um dos mais úteis é o operador “contém” @>. isto
funciona de forma semelhante ao operador #> para json.
Vamos encontrar a entrada que menciona Lucie, uma mãe de cinco filhos
filha:
test = # SELECT s.name,
jsonb_pretty (sd.details_b) json
A PARTIR DE
student_details sd, students s
ONDE s.s_id = sd.s_id
E
sd.details_b @>
'{"méritos": {"mãe de cinco filhos": {}}}' \ gx
- [REGISTRO 1] -------------------------------------
nome | Nina
json | {
+
|
"méritos": {
+
|
"mãe de cinco filhos": {
+
|
"Alex": "desconhecido",
+
|
"Mark": "m",
+
|
"Manjericão": "m",
+
|
"Lucie": "f",
+
|
"Simon": "m"
+
|
}
+
|
},
+
|
"hobbies": "cosplay"
+
|}
Usamos a função jsonb_pretty (), que para-
ajusta a saída do tipo jsonb.
Alternativamente, você pode usar a função jsonb_each (),
que expande pares de valor-chave:
100

Página 102
test = # SELECT s.name,
jsonb_each (sd.details_b)
A PARTIR DE
student_details sd, students s
ONDE s.s_id = sd.s_id
E
sd.details_b @>
'{"méritos": {"mãe de cinco filhos": {}}}' \ gx
- [REGISTRO 1] -------------------------------------
nome
| Nina
jsonb_each | (hobbies, "" "cosplay" "")
- [REGISTRO 2] -------------------------------------
nome
| Nina
jsonb_each | (mérito, "{" "mãe de cinco filhos" ":
{"" Alex "": "" desconhecido "", "" Mark "":
"" m "", "" Manjericão "": "" m "", "" Lucie "":
"" f "", "" Simon "": "" m ""}} ")
A propósito, o nome do filho de Nina foi substituído por um
espaço vazio {} nesta consulta. Esta sintaxe adiciona flexibilidade
para o processo de desenvolvimento de aplicativos.
O que é mais importante, jsonb permite que você crie
dexes que suportam o operador @>, seu inverso <@, e
muito mais. Entre os índices que suportam jsonb, GIN
normalmente é o mais útil. O tipo json não
índices de suporte, portanto, para aplicativos de alta carga, geralmente é
recomendado o uso de jsonb, não json.
Para saber mais sobre os tipos json e jsonb e a função
que podem ser usados com eles, consulte a documentação do PostgreSQL
mentação em postgrespro.com/doc/datatype-json e
postgrespro.com/doc/functions-json.
101

Página 103
PostgreSQL
para aplicativos
Um usuário separado
No capítulo anterior, mostramos como se conectar a
o servidor de banco de dados em nome do usuário postgres. este
é o único usuário DBMS disponível logo após o PostgreSQL in-
instalação. No entanto, o usuário postgres tem privilégios de superusuário
ileges, portanto, o aplicativo não deve usá-lo para banco de dados
conexões. É melhor criar um novo usuário e fazer
é o proprietário de um banco de dados separado, de modo que seus direitos são
limitado a este banco de dados apenas.
postgres = # CRIAR SENHA do app DE USUÁRIO 'p @ ssw0rd';
CRIAR PAPEL
postgres = # CREATE DATABASE appdb OWNER app;
CRIAR BASE DE DADOS
Para saber mais sobre usuários e privilégios, consulte:
postgrespro.com/doc/user-manag.html
e postgrespro.com/doc/ddl-priv.html.
Para se conectar a um novo banco de dados e começar a trabalhar com ele
em nome do usuário recém-criado, execute:
102

Página 104
postgres = # \ c appdb app localhost 5432
Senha para o aplicativo do usuário: ***
Agora você está conectado ao banco de dados "appdb" como usuário
"app" no host "127.0.0.1" na porta "5432".
appdb =>
Este comando leva os seguintes parâmetros: data-
nome de base (appdb), nome de usuário (app), nó (localhost ou
127.0.0.1) e número da porta (5432). Observe que o prompt
mudou: em vez do símbolo hash (#), o maior
então o sinal é exibido (>). O símbolo de hash indica o
direitos de superusuário, semelhantes aos do usuário root no Unix.
O usuário do aplicativo pode trabalhar com seu banco de dados sem qualquer
limitações. Por exemplo, este usuário pode criar uma tabela:
appdb => CREATE TABLE saudação (s texto);
CRIAR A TABELA
appdb => INSERT INTO greeting VALUES ('Hello, world!');
INSERIR 0 1
Conexões Remotas
Em nosso exemplo, o cliente e o servidor DBMS estão localizados
no mesmo sistema. Claramente, você pode instalar o PostgreSQL
em um servidor separado e conecte-se a ele de um outro
sistema (por exemplo, de um servidor de aplicativos). Nisso
caso, você deve especificar o endereço do servidor DBMS em vez disso
de localhost. Mas não é suficiente: por razões de segurança,
O PostgreSQL só permite conexões locais por padrão.
103

Página 105
Para se conectar ao banco de dados de fora, você deve
edite dois arquivos.
Em primeiro lugar, modifique o arquivo postgresql.conf, que con
contém as principais definições de configuração . Geralmente está localizado
no diretório de dados. Encontre a linha que define a inter-
faces para o PostgreSQL ouvir:
#listen_addresses = 'localhost'
e substitua por:
listen_addresses = '*'
Em seguida, edite o arquivo ph_hba.conf com autenticação definida-
tings . Quando o cliente tenta se conectar ao servidor, o Post-
greSQL procura neste arquivo a primeira linha que corresponde
a conexão por quatro parâmetros: local ou rede (host)
conexão, nome do banco de dados, nome de usuário e IP do cliente
endereço. Esta linha também especifica como o usuário deve con
firmar sua identidade.
Por exemplo, no Debian e no Ubuntu, este arquivo inclui o
seguinte linha entre outras:
local
todos
todos
par
Isso significa que as conexões locais (locais) para qualquer banco de dados
(todos) em nome de qualquer usuário (todos) deve ser validado por
o método de autorização de pares (para conexões locais, IP-
endereço obviamente não é necessário).
104

Página 106
O método peer significa que o PostgreSQL solicita o
nome de usuário atual do sistema operacional e assume
que o sistema operacional já realizou a autenticação necessária
verificação de cação (solicitada a senha). É por isso que em
Os usuários de sistemas operacionais semelhantes ao Linux geralmente não precisam
insira a senha ao se conectar ao servidor no
computador local: basta digitar a senha quando
logando no sistema.
Mas o Windows não suporta conexões locais, então este
linha tem a seguinte aparência:
hospedeiro
todos
todos
127.0.0.1/32
md5
Isso significa que as conexões de rede (host) para qualquer banco de dados
(todos) em nome de qualquer usuário (todos) do endereço local
(127.0.0.1) deve ser verificado pelo método md5. este
método requer que o usuário insira a senha.
Portanto, para nossos propósitos, adicione a seguinte linha ao final de
o arquivo pg_hba.conf:
hospedeiro
appdb
aplicativo
todos
md5
Esta configuração permite que o usuário do aplicativo acesse os dados do appdb-
base de qualquer endereço se a senha correta for inserida.
Depois de alterar os arquivos de configuração, não se esqueça de
faça o servidor reler as configurações:
postgres = # SELECT pg_reload_conf ();
Para saber mais sobre as configurações de autenticação, consulte
postgrespro.com/doc/client-authentication.html
105

Página 107
Ping no servidor
Para acessar o PostgreSQL de um aplicativo em qualquer programa-
linguagem ming, você tem que usar uma biblioteca apropriada
e instale o driver DBMS correspondente.
Abaixo, fornecemos exemplos simples para vários populares
línguas. Esses exemplos podem ajudá-lo a verificar rapidamente
a conexão do banco de dados. Os programas fornecidos contêm
apenas o código mínimo viável para a consulta do banco de dados; dentro
particular, não há tratamento de erros. Não leve estes
trechos de código como um exemplo a seguir.
Uma observação sobre o suporte ao idioma russo no Microsoft Win-
dows: se você estiver trabalhando em um sistema Windows, não for-
pode mudar para uma fonte TrueType no prompt de comando
janela (por exemplo, “Lucida Console” ou “Consolas”), e
execute os seguintes comandos para habilitar a exibição correta
de caracteres cirílicos:
C: \> chcp 1251
Página de código ativa: 1251
C: \> definir PGCLIENTENCODING = WIN1251
PHP
O PHP interage com o PostgreSQL por meio de uma extensão especial. Em
Linux, além do próprio PHP, você também deve instalar
o pacote com esta extensão:
$ sudo apt-get install php5-cli php5-pgsql
106

Página 108
Você pode instalar o PHP para Windows a partir do site PHP:
windows.php.net/download. A extensão para Post-
greSQL já está incluído na distribuição binária,
mas você deve encontrar e descomentar (removendo o semi-
dois pontos) a seguinte linha no arquivo php.ini:
; extension = php_pgsql.dll
Um programa de amostra (test.php):
<? php
$ conn = pg_connect ('host = localhost port = 5432'.
'dbname = appdb user = app'.
'senha = p @ ssw0rd') ou morrer;
$ query = pg_query ('SELECIONE * DA saudação') ou morrer;
while ($ row = pg_fetch_array ($ query)) {
echo $ row [0] .PHP_EOL;
}
pg_free_result ($ query);
pg_close ($ conn);
?>
Vamos executar este comando:
$ php test.php
Olá Mundo!
Você pode ler sobre esta extensão PostgreSQL no documento PHP
umentation : php.net/manual/en/book.pgsql.php.
107

Página 109
Perl
Na linguagem Perl, as operações de banco de dados são imple-
mentado por meio da interface DBI. No Debian e Ubuntu,
O próprio Perl está pré-instalado, então você só precisa instalar o
motorista:
$ sudo apt-get install libdbd-pg-perl
Existem várias compilações Perl para Windows, que estão listadas
em www.perl.org/get.html. ActiveState Perl e Straw-
berry Perl já inclui o driver necessário para o Post-
greSQL.
Um programa de amostra (test.pl):
use DBI;
meu $ conn = DBI-> conectar (
'dbi: Pg: dbname = appdb; host = localhost; port = 5432',
'app', 'p @ ssw0rd') ou morrer;
minha $ query = $ conn-> prepare ('SELECT * FROM greeting');
$ query-> execute () ou morra;
while (my @row = $ query-> fetchrow_array ()) {
print @row [0]. "\ n";
}
$ consulta-> terminar ();
$ conn-> disconnect ();
Vamos executar este comando:
$ perl test.pl
Olá Mundo!
A interface é descrita na documentação:
metacpan.org/pod/DBD::Pg.
108

Página 110
Pitão
A linguagem Python geralmente usa a biblioteca psycopg
(pronunciado como “psycho-pee-gee”) para trabalhar com PostgreSQL.
No Debian e no Ubuntu, Python 2 é pré-instalado, então você
só precisa do driver correspondente:
$ sudo apt-get install python-psycopg2
Se você estiver usando Python 3, instale o python3-psycopg2
pacote.
Você pode baixar Python para Windows em www.
site python.org . A biblioteca psycopg está disponível em
initd.org/psycopg ( escolha a versão correspondente a
a versão do Python instalada). Você também pode encontrar todos os
documentação necessária lá.
Um programa de amostra (test.py):
import psycopg2
conn = psycopg2.connect (
host = 'localhost', porta = '5432', banco de dados = 'appdb',
usuário = 'app', senha = 'p @ ssw0rd')
cur = conn.cursor ()
cur.execute ('SELECIONE * DA saudação')
row = cur.fetchall ()
para linha em linhas:
imprimir linha [0]
conn.close ()
Vamos executar este comando:
$ python test.py
Olá Mundo!
109

Página 111
Java
Em Java, a operação do banco de dados é implementada por meio do JDBC
interface. Instale o JDK 1.7; um pacote com o driver JDBC
também é necessário:
$ sudo apt-get install openjdk-7-jdk
$ sudo apt-get install libpostgresql-jdbc-java
Você pode baixar o JDK para Windows em www.oracle.
com / technetwork / java / javase / downloads. O JDBC
driver está disponível em jdbc.postgresql.org (escolha o
versão que corresponde ao JDK instalado em seu sistema
tem). Você também pode encontrar toda a documentação necessária
lá.
Vamos considerar um programa de amostra (Test.java):
import java.sql. *;
public class Test {
public static void main (String [] args)
throws SQLException {
Connection conn = DriverManager.getConnection (
"jdbc: postgresql: // localhost: 5432 / appdb",
"app", "p @ ssw0rd");
Instrução st = conn.createStatement ();
ResultSet rs = st.executeQuery (
"SELECIONE * DA saudação");
while (rs.next ()) {
System.out.println (rs.getString (1));
}
rs.close ();
st.close ();
conn.close ();
}
}
110

Página 112
Compilamos e executamos o programa especificando o caminho
para o driver de classe JDBC (no Windows, os caminhos são separados
por ponto e vírgula, não dois pontos):
$ javac Test.java
$ java -cp.: / usr / share / java / postgresql-jdbc4.jar \
Teste
Olá Mundo!
Cópia de segurança
Embora nosso banco de dados appdb contenha apenas uma tabela, é
vale a pena pensar na persistência dos dados. Enquanto seu aplicativo
contém poucos dados, a maneira mais fácil de criar um backup é
para usar o utilitário pg_dump:
$ pg_dump appdb> appdb.dump
Se você abrir o arquivo appdb.dump resultante em um editor de texto,
você verá comandos SQL regulares que criam todos os
objetos appdb e preencha-os com dados. Você pode passar isso
arquivo para psql para restaurar o conteúdo do banco de dados. Para
exemplo, você pode criar um novo banco de dados e importar todos
os dados nele:
$ createdb appdb2
$ psql -d appdb2 -f appdb.dump
111

Página 113
pg_dump oferece muitos recursos que valem a pena conferir : postgrespro .
com / doc / app-pgdump. Alguns deles estão disponíveis apenas se
os dados são despejados em um formato personalizado interno. Nisso
caso, você deve usar o utilitário pg_restore em vez de
psql para restaurar os dados.
Em qualquer caso, o pg_dump pode extrair o conteúdo de um único
banco de dados apenas. Para fazer um backup de todo o cluster, em
incluindo todos os bancos de dados, usuários e espaços de tabela, você deve
use um comando um pouco diferente: pg_dumpall.
Grandes projetos sérios requerem uma estratégia elaborada de pe-
backups periódicos. A melhor opção aqui é um físico “bi
nary ”cópia do cluster, que pode ser feita com o
utilitário pg_basebackup. Para saber mais sobre os disponíveis
ferramentas de backup, consulte a documentação : postgrespro.com/doc/
cópia de segurança.
Os recursos integrados do PostgreSQL permitem que você implemente todos
quase tudo necessário, mas você deve completar vários
etapas de fluxos de trabalho que precisam de automação. Por isso muitos
as empresas costumam criar suas próprias ferramentas de backup para sim-
plify esta tarefa. Essa ferramenta é desenvolvida no Postgres Pro-
profissional também. É denominado pg_probackup. Esta ferramenta é dis-
tributado gratuitamente e permite realizar
backups no nível da página, garante a integridade dos dados, funciona
com grandes volumes de informações usando execução paralela
e compressão, e implementa várias estratégias de backup
gies. Sua documentação completa está disponível no postgrespro.
com / doc / app-pgprobackup.
112

Página 114
Qual é o próximo?
Agora você está pronto para desenvolver seu aplicativo. Com re-
para o banco de dados, o aplicativo sempre consistirá
de duas partes: servidor e cliente. A parte do servidor compreende
tudo o que se relaciona com DBMS: tabelas, índices, visualizações,
gatilhos, funções armazenadas. A parte do cliente contém tudo
que funciona fora do SGBD e se conecta a ele; de
ponto de vista do banco de dados, não importa se é um
Cliente “fat” ou um servidor de aplicação.
Uma questão importante que não tem uma resposta clara: onde
devemos colocar a lógica de negócios?
Uma das abordagens populares é implementar todas as
lógica no cliente, fora do banco de dados. Muitas vezes acontece
canetas quando os desenvolvedores não estão muito familiarizados com o DBMS
capacidades e preferem confiar no que sabem bem,
esse é o código do aplicativo. Neste caso, o DBMS se torna um
elemento um tanto secundário do aplicativo e apenas
garante a “persistência” dos dados, seu armazenamento confiável. Além disso,
SGBD pode ser isolado por um nível de abstração adicional,
como uma ferramenta ORM que gera dados automaticamente
consultas de base das construções da linguagem de programação
linguagem familiar aos desenvolvedores. Essas soluções são algumas
tempos justificados pela intenção de desenvolver um aplicativo
que é portátil para qualquer DBMS.
Esta abordagem tem o direito de existir: se tal sistema
funciona e aborda todos os objetivos de negócios, por que não?
113

Página 115
No entanto, esta solução também tem algumas desvantagens óbvias
tagens:
• A consistência dos dados é garantida pelo aplicativo.
Em vez de permitir que o DBMS verifique a consistência dos dados (e
isso é exatamente o que os sistemas de banco de dados relacionais são
especialmente bom em), todas as verificações necessárias são realizadas
formada pelo aplicativo. Tenha certeza de que mais cedo
ou mais tarde, seu banco de dados conterá dados sujos. Você
tem que consertar esses erros ou ensinar o aplicativo
cação como lidar com eles. Se o mesmo banco de dados
é usado por vários aplicativos diferentes, é simplesmente
impossível fazer sem a ajuda do DBMS.
• O desempenho deixa muito a desejar.
Os sistemas ORM permitem criar um nível de abstração
sobre DBMS, mas a qualidade das consultas SQL que geram
erate é bastante questionável. Como regra, múltiplos
pequenas consultas são executadas, e cada uma delas é
bastante rápido por conta própria. Mas tal modelo pode lidar
apenas com baixa carga em pequenos volumes de dados e é
virtualmente impossível de otimizar no lado do DBMS.
• O código do aplicativo fica mais complicado.
Usando linguagens de programação orientadas a aplicativos,
é impossível escrever uma consulta realmente complexa que
poderia ser traduzido corretamente para SQL em um
caminho acasalado. É por isso que o processamento de dados complexo
(se for necessário, é claro) deve ser implementado em
o nível do aplicativo, com todos os dados necessários
extraído do banco de dados com antecedência. Nesse caso,
uma transferência extra de dados pela rede é executada.
Além disso, algoritmos de manipulação de dados DBMS (varreduras,
114
Página 116
junções, classificação, agregação) são garantidos para per-
formulário melhor do que o código do aplicativo, uma vez que eles
foram aprimorados e otimizados por anos.
Obviamente, para usar todos os recursos do DBMS, incluindo
restrições de tegridade e lógica de manipulação de dados em funções armazenadas
, uma análise cuidadosa de suas especificidades e capacidades é
requeridos. Você tem que dominar a linguagem SQL para escrever
consultas e aprender uma das linguagens de programação do servidor
indicadores (normalmente, PL / pgSQL) para criar funções e trig-
gers. Em troca, você receberá uma ferramenta confiável, uma das
blocos de construção mais importantes para qualquer sistema de informação
arquitetura.
Em qualquer caso, você deve decidir por si mesmo onde
implementar a lógica de negócios: no lado do servidor ou no
lado do cliente. Vamos apenas observar que não há necessidade de ir para
extremos, pois a verdade muitas vezes está em algum lugar no meio
dle.
115

Página 117
pgAdmin
pgAdmin é uma ferramenta GUI popular para administrar Post-
greSQL. Esta aplicação facilita a administração principal
tarefas de instalação, mostra objetos de banco de dados e permite executar SQL
consultas.
Por muito tempo, o pgAdmin 3 costumava ser um padrão de fato
dard, mas os desenvolvedores do EnterpriseDB encerraram seu suporte e
lançou uma nova versão em 2016, tendo reescrito totalmente o
produto usando Python e tecnologias de desenvolvimento web
em vez de C ++. Por causa da interface completamente retrabalhada
cara, o pgAdmin 4 teve uma recepção legal no começo, mas ainda é
sendo desenvolvido e melhorado.
No entanto, a terceira versão ainda não foi esquecida e está
agora desenvolvido pela equipe BigSQL: www.openscg.com/
bigsql / pgadmin3.
Aqui, daremos uma olhada nos principais recursos do novo
pgAdmin 4.
Instalação
Para iniciar o pgAdmin 4 no Windows, use o instalador disponível
disponível em www.pgadmin.org/download/. A instalação
116

Página 118
procedimento é simples e direto, não há necessidade
para alterar as opções padrão.
Infelizmente, não há pacotes disponíveis para Debian
e sistemas Ubuntu ainda, então vamos descrever a
em mais detalhes. Primeiro, vamos instalar os pacotes para o
Linguagem Python:
$ sudo apt-get install virtualenv python-pip \
libpq-dev python-dev
Então vamos inicializar o ambiente virtual no pgad-
diretório min4 (você pode escolher um diretório diferente se você
gostar):
$ cd ~
$ virtualenv pgadmin4
$ cd pgadmin4
$ source bin / activate
Agora vamos instalar o próprio pgAdmin. Você pode encontrar o mais recente
versão disponível aqui : www.pgadmin.org/download/
pgadmin-4-python-wheel /.
$ pip install https://ftp.postgresql.org/pub/pgadmin/
pgadmin4 / v2.0 / pip / pgadmin4-2.0-py2.py3-none-any.whl
$ rm -rf ~ / .pgadmin /
Finalmente, temos que configurar o pgAdmin para rodar na mesa
modo superior (não vamos abordar o modo de servidor
Aqui).
117

Página 119
$ cat << EOF \
> lib / python2.7 / site-packages / pgadmin4 / config_local.py
importar os
DATA_DIR = os.path.realpath (
os.path.expanduser (u '~ / .pgadmin /'))
LOG_FILE = os.path.join (DATA_DIR, 'pgadmin4.log')
SQLITE_PATH = os.path.join (DATA_DIR, 'pgadmin4.db')
SESSION_DB_PATH = os.path.join (DATA_DIR, 'sessões')
STORAGE_DIR = os.path.join (DATA_DIR, 'armazenamento')
SERVER_MODE = False
EOF
Felizmente, você precisa concluir essas etapas apenas uma vez.
Para iniciar o pgAdmin 4, execute:
$ cd ~ / pgadmin4
$ source bin / activate
$ python \
lib / python2.7 / site-packages / pgadmin4 / pgAdmin4.py
A interface do usuário agora está disponível em seu navegador da web
no localhost: endereço 5050 .
Recursos
Conectando a um servidor
Em primeiro lugar, vamos configurar uma conexão com o servidor. Clique
o botão Adicionar novo servidor . Na janela aberta, no
Na guia Geral , insira um nome de conexão arbitrário Nome .
118

Página 120
Na guia Conexão , digite o nome / endereço do Host, Porta,
Nome de usuário e senha . Se você não quiser entrar no
senha todas as vezes, marque a caixa de seleção Salvar senha .
Quando você clica no botão Salvar , o aplicativo verifica
que o servidor com os parâmetros especificados está disponível,
e registra uma nova conexão.
119

Página 121
Navegador
No painel esquerdo, você pode ver a árvore do navegador. Como você ex-
pand seus objetos, você pode chegar ao servidor, que temos
chamado LOCAL. Você pode ver todos os bancos de dados que ele contém:
• appdb foi criado para verificar a conexão com
PostgreSQL usando diferentes linguagens de programação.
• demo é nosso banco de dados de demonstração.
• postgres é criado automaticamente quando o DBMS é
instalado.
• test foi usado no capítulo “Tentando SQL”.
Se você expandir o item Schemas para o banco de dados appdb,
você pode encontrar a tabela de saudações que criamos,
120

Página 122
visualizar suas colunas, restrições de integridade, índices, gatilhos,
etc.
Para cada tipo de objeto, o menu de contexto (clique com o botão direito) lista
todas as ações possíveis. Por exemplo, exporte para um arquivo ou
carregar de um arquivo, atribuir privilégios, excluir.
O painel direito inclui várias guias que exibem
informações de referência:
• O painel fornece gráficos de atividades do sistema.
• Propriedades exibe as propriedades do objeto se-
selecionados no navegador (por exemplo, tipo de dados do
colunas, etc.)
• SQL mostra o comando SQL usado para criar o
objeto selecionado.
• Estatísticas lista as informações usadas pela consulta opti-
mizer para construir planos de consulta; pode ser usado por DBMS
administrador para análise de caso.
• Dependências, Dependentes ilustra dependências
entre o objeto selecionado e outros objetos em
o banco de dados.
Executando consultas
Para executar uma consulta, abra uma nova guia com a janela SQL
escolhendo Ferramentas - Ferramenta de consulta no menu.
121

Página 123
Insira sua consulta na parte superior da janela e
pressione F5. A guia Data Output na parte inferior do
janela exibirá o resultado da consulta.
Você pode digitar a próxima consulta começando em uma nova linha,
sem excluir a consulta anterior: basta selecionar o re-
fragmento de código desejado antes de pressionar F5. Assim, o todo
a história de suas ações estará sempre à sua frente. Isto é
geralmente mais conveniente do que procurar o necessário
consulta no log da guia Histórico de consultas .
122

Página 124
De outros
pgAdmin fornece uma interface gráfica de usuário para
Utilitários PostgreSQL, tabelas de catálogo do sistema, administra-
funções de configuração e comandos SQL. O PL / pgSQL integrado
depurador merece uma menção separada. Você pode aprender
sobre todos os recursos do pgAdmin no site do produto www.
pgadmin.org ou no sistema de ajuda integrado pgAdmin.
123

Página 125
Documentação
e treinamentos
Ler a documentação é indispensável para profissionais
uso do PostgreSQL. Ele descreve todos os recursos do DBMS e
fornece uma referência exaustiva que sempre deve ser
à mão. Lendo a documentação, você pode obter informações completas e
informações precisas em primeira mão: é escrito por desenvolver-
eles próprios e são cuidadosamente mantidos atualizados em tudo
vezes. A documentação do PostgreSQL está disponível em www.
postgresql.org/docs ou www.postgrespro.com/docs.
Nós do Postgres Professional traduzimos o todo
documentação definida em russo. Está disponível em nosso
site: www.postgrespro.ru/docs.
Enquanto trabalhamos nesta tradução, também compilamos um
Glossário inglês-russo, publicado em postgrespro.com/
educação / glossário. Recomendamos consultar este
glossário ao traduzir artigos em inglês para russo para
use terminologia consistente e familiar a um grande público.
Também há francês (docs.postgresql.fr) e japonês
(www.postgresql.jp/document) traduções fornecidas por
comunidades nacionais.
124

Página 126
Cursos de Treinamento
Além da documentação, também desenvolvemos cursos de treinamento
es para DBAs e desenvolvedores de aplicativos (entregue em Rus-
sian):
• DBA1. Administração básica do PostgreSQL.
• DBA2. Administração avançada de PostgreSQL.
• DEV1. Desenvolvimento básico de aplicativos do lado do servidor.
• DEV2. Desenvolvimento de aplicativos avançados do lado do servidor
ment.
Esses cursos são divididos em básicos e avançados antes de
causa do grande volume de informações, o que é difícil
para apresentar e levar dentro de alguns dias. Não pense
que os cursos básicos são apenas para iniciantes, enquanto os cursos avançados
alguns são apenas para DBAs e desenvolvedores experientes. Al-
embora alguns tópicos sejam incluídos tanto no básico quanto no anúncio
cursos avançados, não há muitas sobreposições.
Por exemplo, nosso curso básico DBA1 de três dias apresenta
PostgreSQL e fornece explicações detalhadas sobre o
principais conceitos de administração de banco de dados, enquanto os cinco
o curso DBA2 de um dia cobre detalhes internos de DBMS e
configuração, otimização de consulta e vários outros tópicos.
O curso avançado não volta aos tópicos cobertos
ered no curso básico. Os cursos para desenvolvedores são estruturados
de forma semelhante.
A documentação contém todos os detalhes sobre o PostgreSQL.
No entanto, as informações estão espalhadas por diferentes
125
Página 127
capítulos e requer repetidas leituras cuidadosas. Ao contrário
documentação, cada curso consiste em módulos separados
que oferecem vários tópicos relacionados, explicando gradualmente o
assunto. Em vez de fornecer todos os detalhes possíveis,
eles se concentram em informações práticas importantes. Assim, nosso
os cursos destinam-se a complementar a documentação, não
para substituí-lo.
Cada tópico do curso inclui teoria e prática. Teoria é
não apenas uma apresentação: na maioria dos casos, uma demonstração ao vivo também é
forneceu. Na parte prática, os alunos são convidados a com-
completar uma série de tarefas para revisar o apresentado
tópicos.
Os tópicos são divididos de tal forma que a teoria não leva
mais de uma hora. O tempo mais longo pode prejudicar significativamente
compreensão do curso. Tarefas práticas geralmente levam
até 30 minutos.
Os materiais do curso incluem apresentações detalhadas
comentários para cada slide, a saída de scripts de demonstração, então
lições para tarefas práticas e referência adicional
materiais sobre alguns tópicos.
Para uso não comercial, todos os materiais do curso estão disponíveis
em nosso site gratuitamente.
126

Página 128
Cursos para administradores de banco de dados
DBA1. Administração básica do PostgreSQL
Duração: 3 dias
Conhecimento prévio:
Conhecimentos básicos de banco de dados e SQL.
Familiaridade com Unix.
Conhecimento e habilidades adquiridas:
Compreensão geral da arquitetura PostgreSQL.
Instalação, configuração inicial, gerenciamento de servidor.
Estrutura de dados lógica e física.
Tarefas básicas de administração.
Gerenciamento de usuários e acessos.
Compreensão dos conceitos de backup e replicação.
Tópicos:
Kit de ferramentas básico
1. Instalação e gerenciamento
2. Usando psql
3. Configuração
127

Página 129
Arquitetura
4. Visão geral do PostgreSQL
5. Isolamento e controle de simultaneidade de várias versões
6. Cache de buffer e registro de write-ahead
Gestão de dados
7. Bancos de dados e esquemas
8. Catálogo do sistema
9. Tablespaces
10. Detalhes de baixo nível
Tarefas de administração
11. Monitoramento
12. Manutenção
Controle de acesso
13. Funções e atributos
14. Privilégios
15. Segurança em nível de linha
16. Conexão e autenticação
Backups
17. Visão geral
Replicação
18. Visão geral
Materiais do curso DBA1 (apresentações, demonstrações, práticas
tarefas, vídeos de palestras) estão disponíveis para auto-estudo em
www.postgrespro.ru/education/courses/DBA1.
128
Página 130
DBA2. Administração avançada de PostgreSQL
Duração: 5 dias
Conhecimento prévio:
Uma boa compreensão do Unix.
Conhecimentos básicos de arquitetura SGBD, instalação,
configuração e manutenção.
Conhecimento e habilidades adquiridas:
Noções básicas sobre arquitetura PostgreSQL.
Monitoramento e configuração de banco de dados, otimização de desempenho
tarefas de instalação.
Tarefas de manutenção de banco de dados.
Backup e replicação.
Tópicos:
Introdução
1. Arquitetura PostgreSQL
Isolamento e controle de simultaneidade de várias versões
2. Isolamento da transação
3. Páginas e versões de tupla
4. Instantâneos e bloqueios
5. Vácuo
6. Autovacuum e congelamento
129

Página 131
Exploração madeireira
7. Cache de buffer
8. Registro de escrita antecipada
9. Pontos de verificação
Replicação
10. Replicação de arquivos
11. Replicação de fluxo
12. Mudança para uma réplica
13. Opções de replicação
Noções básicas de otimização
14. Tratamento de consultas
15. Caminhos de acesso
16. Métodos de junção
17. Estatísticas
18. Uso de memória
19. Perfil
20. Otimizando consultas
Diversos
21. Particionamento
22. Localização
23. Atualizações do servidor
24. Gerenciando extensões
25. Dados estrangeiros
Materiais do curso DBA2 (apresentações, demonstrações, práticas
tarefas, vídeos de palestras) estão disponíveis para auto-estudo em
www.postgrespro.ru/education/courses/DBA2.
130

Página 132
Cursos para desenvolvedores de aplicativos
DEV1. Um curso básico para desenvolvedores do lado do servidor
Duração: 4 dias
Conhecimento prévio:
Fundamentos de SQL.
Experiência com qualquer linguagem de programação procedural
calibre.
Conhecimentos básicos de Unix.
Conhecimento e habilidades adquiridas:
Informações gerais sobre a arquitetura PostgreSQL.
Usando os principais objetos do banco de dados:
tabelas, índices, visualizações.
Programação em SQL e PL / pgSQL no lado do servidor.
Usando os principais tipos de dados,
incluindo registros e matrizes.
Estabelecer a comunicação com o lado do cliente do
inscrição.
Tópicos:
Kit de ferramentas básico
1. Instalação e gerenciamento, psql
131

Página 133
Arquitetura
2. Visão geral do PostgreSQL
3. Isolamento e controle de simultaneidade de várias versões
4. Cache de buffer e registro de write-ahead
Gestão de dados
5. Estrutura lógica
6. Estrutura física
Aplicativo “Livraria”
7. Modelo de dados do aplicativo
8. Interação do cliente com DBMS
SQL
9. Funções
10. Tipos compostos
PL / pgSQL
11. Visão geral da linguagem e estruturas de programação
12. Execução de consultas
13. Cursores
14. Comandos dinâmicos
15. Arrays
16. Tratamento de erros
17. Gatilhos
18. Depuração
Controle de acesso
19. Visão geral
Materiais do curso DEV1 (apresentações, demonstrações, práticas
tarefas, vídeos de palestras) estão disponíveis para auto-estudo em
www.postgrespro.ru/education/courses/DEV1.
132

Página 134
DEV2. Um curso avançado para servidor
desenvolvedores
Este curso está em desenvolvimento agora, é ex-
esperado em um futuro próximo.
Cursos para desenvolvedores de DBMS
Além dos cursos regulares em centros de treinamento, pós-
desenvolvedores de núcleo greSQL que trabalham em nossa empresa também
conduza treinamentos de vez em quando.
Hacking PostgreSQL
O curso “Hacking PostgreSQL” é baseado no pessoal
experiência de desenvolvedores Postgres Professional, também
como materiais de conferências, artigos e análise cuidadosa de
documentação e código-fonte. Este curso é primário
voltado para desenvolvedores que estão começando com
Desenvolvimento central do PostgreSQL, mas também pode ser interessante
aos administradores que às vezes precisam recorrer ao
código, e para qualquer pessoa interessada na arquitetura de um
sistema em grande escala, querendo saber “como tudo funciona”.
Conhecimento prévio:
Conhecimento básico de SQL, transações, índices, etc.
Conhecimento da linguagem de programação С, pelo menos no
nível de leitura do código-fonte (experiência prática
é preferível).
133

Página 135
Familiaridade com estruturas e algoritmos básicos.
Tópicos:
1. Visão geral da arquitetura
2. Comunidade PostgreSQL e ferramentas de desenvolvedor
3. Extensibilidade
4. Visão geral do código-fonte
5. Modelo de dados físicos
6. Memória compartilhada e bloqueios
7. Memória de processo local
8. Noções básicas de planejador e executor de consultas
Materiais do curso Hacking PostgreSQL estão disponíveis para
autoaprendizado em www.postgrespro.ru/education/courses/
hacking.
134
Página 136
The Hacker's
Guia para a Galáxia
Notícias e discussões
Se você vai trabalhar com PostgreSQL, você precisa
mantenha-se atualizado e aprenda sobre os novos recursos do upcom-
lançamentos e outras notícias. Muitas pessoas escrevem seus próprios
blogs, onde publicam conteúdo interessante e útil.
Para obter todos os artigos em inglês em um só lugar, você
pode verificar o site planet.postgresql.org .
Não se esqueça de wiki.postgresql.org, que contém
uma coleção de artigos apoiados e expandidos pela
comunidade. Aqui você pode encontrar FAQ, materiais de treinamento, ar-
informações sobre configuração e otimização do sistema, migração
específicos de diferentes DBMS, etc.
Mais de 5000 usuários do PostgreSQL são membros do
Grupo do Facebook “PostgreSQL Server” (www.facebook.com/
grupos / postgres) .
Você também pode fazer suas perguntas em stackoverflow.com.
O blog corporativo Postgres Professional está disponível em
postgrespro.com/blog.
135

Página 137
Listas de mala direta
Para obter todas as notícias em primeira mão, sem esperar por algum-
um para escrever uma postagem no blog, se inscrever em listas de discussão. Tradi-
opcionalmente, os desenvolvedores PostgreSQL discutem todas as questões ex-
clusivamente por e-mail, na lista de discussão pgsql-hackers (frequentemente
chamados simplesmente de “hackers”).
Você pode encontrar todas as listas de discussão em www.postgresql.org/
Lista. Por exemplo:
• pgsql-general para discutir questões gerais
• pgsql-bugs para relatar bugs encontrados
• pgsql-announce para obter novos anúncios de lançamento
e muitos mais.
Qualquer pessoa pode se inscrever em qualquer lista de mala direta para receber o regulamento
lares e-mails e participe de discussões.
Outra opção é ler o arquivo de mensagens de vez
ao tempo. Você pode encontrá-lo em www.postgresql.org/list,
ou veja todos os tópicos em ordem cronológica em www.
postgresql-archive.org. O arquivo de mensagens pode ser
também visualizado e pesquisado em postgrespro.com/list.
Commitfest
Outra forma de acompanhar as notícias é verificar o
página commitfest.postgresql.org . Neste site, o
136

Página 138
comunidade abre “commitfests” para os desenvolvedores sub-
mit seus patches. Por exemplo, commitfest 01.03.2017–
31.03.2017 foi aberto para a versão 10, enquanto o próximo com
mitfest 01.09.2017–30.09.2017 está relacionado com o próximo
de concessão. Permite parar de aceitar novos recursos, pelo menos
cerca de meio ano antes do lançamento e ter tempo para
estabilizar o código.
Os patches passam por vários estágios. Primeiro, eles são revisados
e corrigido. Em seguida, eles são aceitos, movidos para o
próximo commitfest, ou rejeitado (se você estiver completamente fora de
sorte).
Assim, você pode se manter informado sobre os novos recursos já
incluído no PostgreSQL ou planejado para o próximo lançamento.
Conferências
As conferências PostgreSQL são realizadas em todo o mundo:
Fevereiro ou março: PGConf.Russia (pgconf.ru)
Maio: PGCon em Ottava, Canadá (pgcon.org)
Julho ou setembro: PGDay na Rússia (pgday.ru)
Novembro: PGConf.Europe (pgconf.eu)
Dezembro: PGConf.Asia (www.pgconf.asia)
137

Página 139
Postgres Professional
A empresa Postgres Professional foi fundada em 2015
pelos principais desenvolvedores de PostgreSQL russos. Ele oferece um completo
espectro de serviços relacionados ao PostgreSQL e desenvolvimentos
Postgres Pro, uma bifurcação avançada do PostgreSQL.
A empresa tem um foco especial na educação. Hospeda
PgConf.Russia, o maior PostgreSQL con internacional
ference em Moscou, e participa de outras conferências
No mundo todo.
Nosso endereço:
7A Dmitry Ulyanov str., Moscou, Rússia, 117036
Tel:
+7 495 150-06-91
Site corporativo e e-mail:
postgrespro.com
info@postgrespro.com
138

Página 140
Serviços
Soluções comerciais baseadas em PostgreSQL
• Projetar e implementar alto desempenho de missão crítica
sistemas usando PostgreSQL DBMS. Projetando cus-
tomou arquiteturas de cluster confiáveis.
• Otimizando a configuração e as consultas do DBMS.
• Consultoria na utilização de SGBD em sistemas industriais.
• Auditoria técnica de banco de dados de clientes.
• DBA remoto.
• Implantação de DBMS PostgreSQL.
Suporte Técnico do Fornecedor
• Suporte técnico 24x7 L2 e L3 para PostgreSQL
DBMS.
• Suporte 24 horas por dia por DBAs especialistas: sistema
monitoramento, recuperação de desastres, análise de incidentes, por
gestão de desempenho.
• Correção de erros no núcleo do DBMS e suas extensões.
139
Página 141
Migração de sistemas de aplicativos
• Analisar os sistemas de aplicação disponíveis, estimar
a complexidade de sua migração de outro DBMS
para PostgreSQL.
• Projetar a arquitetura para novas soluções, definitivamente
as modificações necessárias no sistema de aplicação
tems.
• Migração de sistemas operacionais para PostgreSQL DBMS,
incluindo sistemas sob carga.
• Fornecer suporte aos desenvolvedores de aplicativos durante
Migração de DBMS.
Desenvolvimento personalizado no núcleo PostgreSQL e
níveis de extensão
• Adicionar recursos personalizados de nível central do PostgreSQL e
módulos de extensão.
• Desenvolvimento de novas extensões para atender ao cliente
tarefas do sistema e do aplicativo.
• Fornecimento de versões personalizadas de DBMS para o benefício de nossos clientes.
• Envio de patches para a versão upstream do código PostgreSQL.
Organização de treinamentos
• Treinamentos PostgreSQL para administradores de banco de dados.
• Treinamentos para arquitetos de sistemas de aplicativos e de-
Velopers: explicando as especificações do PostgreSQL e como
para usar efetivamente suas vantagens.
• Compartilhamento de informações sobre novos recursos e importantes
mudanças em novas versões.
• Realização de seminários para análise de projetos de clientes.
141