psql — terminal interativo do PostgreSQL
psql [opção...] [nome_do_banco_de_dados
[nome_do_usuário]]
O psql é uma interface no modo texto para o PostgreSQL. Ele permite que se digite consultas interativamente, envie-as para o PostgreSQL, e ver os resultados da consulta. Como alternativa, a entrada pode vir de um arquivo ou de argumentos da linha de comando. Além disso, o psql fornece vários meta-comandos e recursos semelhantes aos do interpretador de comandos (shell) para facilitar a escrita de scripts, e automatizar uma ampla variedade de tarefas.
-a--echo-all #
Mostra todas as linhas de entrada não vazias na saída padrão
à medida que são lidas.
(Não se aplica a linhas lidas interativamente.)
Equivale a definir a variável ECHO
como all.
-A--no-align #
Muda para o modo de saída não alinhada.
(O modo de saída padrão é aligned.)
Equivale a \pset format unaligned.
-b--echo-errors #
Mostra na saída de erro padrão os comandos SQL
com erro.
Equivale a definir a variável ECHO como
errors.
-c comando--command=comando #
Especifica que o psql deve executar
a sequência de comandos fornecida pelo
comando.
Esta opção pode ser repetida e combinada em qualquer ordem com
a opção -f.
Quando é especificado -c ou -f,
o psql não lê comandos na entrada padrão;
em vez disso, termina após processar todas as opções
-c e -f em sequência.
O comando deve ser
uma cadeia de caracteres de comando completamente analisável pelo
servidor (ou seja, não contendo recursos específicos do
psql), ou um único comando de
contrabarra.
Portanto, não se pode misturar comandos SQL
com meta-comandos psql em uma opção
-c.
Para fazer isto, podem ser usadas opções -c
repetidas, ou canalizar (pipe) a
cadeia de caracteres para o psql.
Por exemplo:
psql -c '\x' -c 'SELECT * FROM foo;'
ou
echo '\x \\ SELECT * FROM foo;' | psql
(onde \\ é o meta-comando do separador.)
Cada cadeia de caracteres de comando SQL
passada para -c é enviada ao servidor como uma
única solicitação.
Por causa disso, o servidor a executa como uma única transação,
mesmo que a cadeia de caracteres contenha vários comandos
SQL, a menos que haja comandos
BEGIN/COMMIT explícitos
incluído na cadeia de caracteres para dividi-la em várias
transações.
(Veja Seção 54.2.2.1 para
obter mais detalhes sobre como o servidor lida com cadeias de
caracteres com várias consultas.)
Caso não se deseje a execução de vários comandos em uma única
transação, devem ser usados comandos -c repetidos
ou submetidos vários comandos para a entrada padrão do
psql, seja usando
echo como mostrado acima, ou usando
um redirecionamento do tipo
Here Document
[186], como, por exemplo:
psql <<EOF \x SELECT * FROM foo; EOF
--csv #
Alterna para o modo de saída CSV
(Valores Separados por Vírgula).
Equivale a \pset format csv.
-d nome_do_banco_de_dados--dbname=nome_do_banco_de_dados #
Especifica o nome do banco de dados ao qual se conectar.
Equivale a especificar o
nome_do_banco_de_dados
como o primeiro argumento sem opção na linha de comando.
O nome_do_banco_de_dados pode ser uma
cadeia de caracteres de conexão.
Neste caso, os parâmetros da cadeia de caracteres de conexão
prevalecem sobre quaisquer opções de linha de comando conflitantes.
-e--echo-queries #
Copia também todos os comandos SQL enviados
ao servidor para a saída padrão.
Equivale a definir a variável ECHO como
queries.
-E--echo-hidden #
Mostra as consultas reais geradas por \d e
outros comandos de contrabarra.
Pode ser usado para estudar as operações internas do
psql.
Equivale a definir a variável ECHO_HIDDEN como
on.
-f nome_do_arquivo--file=nome_do_arquivo #
Lê os comandos no arquivo
nome_do_arquivo,
em vez da entrada padrão.
Esta opção pode ser repetida e combinada em qualquer ordem com
a opção -c.
Quando é especificado -c ou -f,
o psql não lê os comandos na entrada
padrão; em vez disso, termina após processar todas as opções
-c e -f em sequência.
Exceto por isto, esta opção é amplamente equivalente ao
meta-comando \i.
Se o nome_do_arquivo for
- (hífen), então a entrada padrão é lida até
uma indicação de EOF, ou o meta-comando \q.
Pode ser usado para intercalar entrada interativa com entrada
por arquivos.
Note, no entanto, que o
Readline não é usado neste caso
(como se tivesse sido especificado -n).
Usar esta opção é sutilmente diferente de escrever
psql < .
Em geral, as duas farão o que se espera, mas usar
nome_do_arquivo-f ativa alguns recursos interessantes, como
mensagens de erro com número de linha.
Há também uma pequena chance de que o uso dessa opção reduza
a sobrecarga de inicialização.
Por outro lado, a variante que usa o redirecionamento de entrada
do interpretador de comandos é (em teoria), garantida como
produzindo a mesma saída que se teria recebido caso
se tivesse inserido tudo manualmente.
-F separador--field-separator=separador #
O separador é usado
para separar os campos na saída não alinhada.
Equivale a
\pset fieldsep, ou \f.
-h nome_do_hospedeiro--host=nome_do_hospedeiro #Especifica o nome de hospedeiro da máquina na qual o servidor está sendo executado. Se o valor começar com uma barra, será usado como o diretório para o soquete de domínio Unix.
-H--html #
Muda para o modo de saída HTML.
Equivale a \pset format html, ou o comando
\H.
-l--list #
Mostra todos os bancos de dados disponíveis e termina.
As demais opções que não são de conexão são ignoradas.
Semelhante ao meta-comando \list.
Quando esta opção é usada, o psql se
conecta ao banco de dados postgres, a menos
que um banco de dados diferente seja especificado na linha de
comando (opção -d, ou argumento sem opção,
possivelmente por meio de uma entrada de serviço, mas não por
meio de uma variável de ambiente).
-L nome_do_arquivo--log-file=nome_do_arquivo #
Escreve toda a saída da consulta no arquivo
nome_do_arquivo,
além do destino de saída normal.
-n--no-readline #Não usa Readline para edição de linha, e não usa o histórico de comandos (veja Edição de linha de comando abaixo).
-o nome_do_arquivo--output=nome_do_arquivo #
Coloca toda a saída da consulta no arquivo
nome_do_arquivo.
Equivale ao comando \o.
-p porta--port=porta #
Especifica a porta TCP, ou a extensão do arquivo de
soquete de domínio Unix local, na qual o servidor está
aguardando conexões.
O padrão é o valor da variável de ambiente PGPORT ou,
se não estiver definida, a porta especificada no tempo de construção,
geralmente a 5432.
-P atribuição--pset=atribuição #
Especifica opções de exibição, no estilo de
\pset.
Note que aqui se deve separar o nome do valor com um sinal de
igual, em vez de um espaço.
Por exemplo, para definir o formato de saída para
LaTeX,
pode-se escrever -P format=latex.
-q--quiet #
Especifica que psql deve fazer seu
trabalho silenciosamente.
Por padrão, são mostradas mensagens de boas-vindas e várias saídas
informativas.
Se esta opção for usada, nada disso acontece.
É útil com a opção -c.
Equivale a definir a variável QUIET como
on.
-R separador--record-separator=separador #
Usa o separador como
separador de registro para a saída não alinhada.
Equivale a \pset recordsep.
-s--single-step #Executa no modo de etapa única. Significa que o usuário é avisado antes de cada comando ser enviado ao servidor, com a opção de cancelar a execução também. Usado para depurar scripts.
-S--single-line #Executa no modo de linha única, onde o caractere de nova linha termina o comando SQL, como faz o ponto e vírgula.
Este modo é fornecido para aqueles que insistem em usá-lo, mas não se encoraja o seu uso. Em particular, se forem misturados comandos SQL e meta-comandos em uma linha, a ordem de execução pode nem sempre ser clara para o usuário inexperiente.
-t--tuples-only #
Desativa a exibição de nomes de coluna e rodapés de contagem
de linha de resultado, etc.
Equivale a \t ou
\pset tuples_only.
-T opções_de_tabela--table-attr=opções_de_tabela #
Especifica as opções a serem colocadas no marcador
HTML table.
Veja \pset tableattr para obter mais detalhes.
-U nome_do_usuário--username=nome_do_usuário #
Conecta ao banco de dados como o usuário
nome_do_usuário,
em vez do padrão.
(É necessário ter permissão para fazê-lo, é claro.)
-v atribuição--set=atribuição--variable=atribuição #
Realiza uma atribuição de variável, como o meta-comando
\set.
Note que se deve separar o nome do valor, se houver, por um sinal
de igual na linha de comando.
Para remover a definição de uma variável, deve ser omitido
o sinal de igual.
Para definir uma variável com o valor vazio, deve ser usado
o sinal de igual, mas omitido o valor.
Estas atribuições são feitas durante o processamento da linha
de comando, portanto, as variáveis que refletem o estado da
conexão serão substituídas posteriormente.
-V--version #Mostra a versão do psql e termina.
-w--no-password #
Não mostra o pedido de senha.
Se o servidor exigir autenticação por senha, e a senha não
estiver disponível em outras fontes, como no arquivo
.pgpass, a tentativa de conexão falha.
Esta opção pode ser útil em trabalhos e scripts em lote, nos
quais nenhum usuário está presente para inserir uma senha.
Note que esta opção permanecerá definida para toda a sessão e,
portanto, afeta o uso do meta-comando \connect,
bem como a tentativa de conexão inicial.
-W--password #Força o psql a solicitar a senha antes de se conectar a um banco de dados, mesmo que a senha não seja usada.
Se o servidor exigir autenticação por senha, e a senha não
estiver disponível por outras fontes, como no arquivo
.pgpass, o psql
solicita a senha de qualquer maneira.
Entretanto, o psql desperdiça uma
tentativa de conexão para descobrir que o servidor requer uma senha.
Em alguns casos, vale a pena digitar -W para
evitar a tentativa extra de conexão.
Note que esta opção permanecerá definida para toda a sessão e,
portanto, afeta o uso do meta-comando \connect,
bem como a tentativa de conexão inicial.
-x--expanded #
Ativa o modo expandido de formatação de tabela.
Equivale a \x, ou
\pset expanded.
-X--no-psqlrc #
Não lê os arquivos de inicialização
(nem o arquivo psqlrc do sistema, nem o
arquivo ~/.psqlrc do usuário).
-z--field-separator-zero #
Define o separador de campos para a saída não alinhada como
o byte zero.
Equivale a \pset fieldsep_zero.
-0--record-separator-zero #
Define o separador de registros para saída não alinhada como
o byte zero.
É útil para interface, por exemplo, com xargs -0.
Equivale a \pset recordsep_zero.
-1--single-transaction #
Esta opção só pode ser usada em combinação com uma ou mais
opções -c e/ou -f.
Faz com que o psql gere o comando
BEGIN antes da primeira dessas opções,
e o comando COMMIT após a última,
circundando assim todos os comandos em uma única transação.
Se algum dos comandos falhar, e a variável
ON_ERROR_STOP estiver definida,
será enviado um comando ROLLBACK.
Isto garante que todos os comandos sejam concluídos com sucesso
ou que nenhuma alteração seja aplicada.
Se os próprios comandos contiverem BEGIN,
COMMIT, ou ROLLBACK,
esta opção não terá o efeito desejado.
Além disso, se algum comando individual não puder ser executado
em um bloco de transação, especificar esta opção fará
com que toda a transação falhe.
-?--help[=tópico] #
Mostra a ajuda sobre o psql e termina.
O parâmetro opcional
tópico
(padrão options) seleciona qual parte do
psql será explicada:
commands descreve os comandos de contrabarra
do psql;
options descreve as opções de linha de comando
que podem ser passadas para o psql; e
variables mostra a ajuda sobre as variáveis
de configuração do psql.
O psql retorna 0 para o interpretador
de comandos se terminar normalmente, 1 se ocorrer um erro fatal
próprio (por exemplo, falta de memória, arquivo não encontrado),
2 se a conexão com o servidor ficar ruim e a sessão não for
interativa, e 3 se ocorrer erro em um script e a variável
ON_ERROR_STOP estiver definida.
O psql é uma aplicação cliente do
PostgreSQL comum.
Para se conectar a um banco de dados, é necessário saber o nome do
banco de dados de destino, o nome do hospedeiro e o número da porta
do servidor, além do nome de usuário do banco de dados que se
deseja usar para se conectar.
O psql pode obter informações sobre estes
parâmetros por meio de opções de linha de comando, como
-d, -h, -p e
-U, respectivamente.
Se for encontrado um argumento que não pertença a nenhuma opção,
ele será interpretado como o nome do banco de dados (ou o nome do
usuário do banco de dados, se o nome do banco de dados já tiver
sido fornecido).
Nem todas estas opções são obrigatórias; existem valores padrão úteis.
Se for omitido o nome do hospedeiro, o psql
irá se conectar via um soquete de domínio Unix ao servidor
no hospedeiro local, ou via TCP/IP ao localhost
no Windows.
O número da porta padrão é determinado em tempo de compilação.
Como o servidor de banco de dados usa o mesmo padrão, geralmente
não é necessário especificar a porta.
O nome de usuário padrão do banco de dados é o mesmo nome de
usuário do sistema operacional.
Uma vez determinado o nome de usuário do banco de dados,
ele será usado como o nome padrão do banco de dados.
Note que não é possível simplesmente se conectar a qualquer banco
de dados com qualquer nome de usuário.
O administrador do banco de dados deve informar sobre
seus direitos de acesso.
Quando os padrões não estiverem corretos, pode-se economizar um
pouco de digitação definindo as variáveis de ambiente
PGDATABASE, PGHOST,
PGPORT e/ou PGUSER
com os valores apropriados.
(Para variáveis de ambiente adicionais, veja
Variáveis de ambiente.)
Também é conveniente existir o arquivo ~/.pgpass,
para evitar ter que digitar as senhas regularmente.
Consulte a O arquivo de senhas para obter mais informações.
Uma maneira alternativa de especificar parâmetros de conexão é em
uma cadeia de caracteres conninfo, ou um
URI, usado em vez do nome do banco de dados.
Este mecanismo fornece um controle muito amplo sobre a conexão.
Por exemplo:
$ psql "service=myservice sslmode=require" $ psql postgresql://dbmaster:5433/mydb?sslmode=require
Dessa forma, também se pode usar o LDAP para procura de parâmetros de conexão, conforme descrito em LDAP Lookup of Connection Parameters. Veja Palavras-chave de parâmetro para obter mais informações sobre todas as opções de conexão disponíveis.
Se a conexão não puder ser realizada por qualquer motivo (por exemplo, privilégios insuficientes, o servidor não está sendo executado no hospedeiro especificado, etc.), o psql irá retornar um erro e terminar.
Se a entrada padrão e a saída padrão forem um terminal, o
psql irá definir a codificação do cliente
como “auto”, que detecta a codificação apropriada
do cliente nas configurações de localidade
(a variável de ambiente LC_CTYPE nos sistemas
Unix).
Se isto não funcionar como esperado, a codificação do cliente
poderá ser definida usando a variável de ambiente
PGCLIENTENCODING.
Em operação normal, o psql mostra um
aviso de comando (prompt)
com o nome do banco de dados ao qual está conectado no momento,
seguido pela cadeia de caracteres =>.
Por exemplo:
$ psql testdb psql (18.1) Digite "help" para obter ajuda. testdb=>
No aviso de comando (prompt), o usuário pode digitar comandos SQL. Normalmente, as linhas de entrada são enviadas para o servidor quando o ponto e vírgula de final do comando é alcançado. O fim de linha não termina o comando. Assim, os comandos podem ser distribuídos por várias linhas para maior clareza. Se o comando for enviado e executado sem erro, os resultados do comando serão mostrados na tela.
Se usuários não confiáveis tiverem acesso a um banco de dados que
não adotou um
padrão de uso de esquema seguro,
deve-se começar a sessão removendo os esquemas publicamente
graváveis de search_path.
Pode-se adicionar options=-csearch_path=
à cadeia de caracteres de conexão, ou executar
SELECT pg_catalog.set_config('search_path', '', false)
antes dos outros comandos SQL.
Esta consideração não é específica para o
psql; aplica-se a todas as interfaces
para execução de comandos SQL arbitrários.
Sempre que um comando é executado, o psql também pesquisa eventos de notificação assíncronos gerados por LISTEN e NOTIFY.
Enquanto os comentários de bloco estilo C são passados para o servidor para processamento e remoção, os comentários padrão SQL são removidos pelo psql.
Qualquer coisa que se digite no psql que comece com uma contrabarra sem escape é um meta-comando do psql, sendo processado pelo próprio psql. Estes comandos tornam o psql mais útil para administração ou execução de scripts. Os meta-comandos são geralmente chamados de comandos de barra ou contrabarra.
O formato de um comando psql é a contrabarra, seguida imediatamente por um verbo de comando e, em seguida, quaisquer argumentos. Os argumentos são separados do verbo de comando, e uns dos outros, por qualquer número de caracteres de espaço em branco.
Para incluir o espaço em branco em um argumento, pode-se delimitá-lo
com apóstrofos.
Para incluir um apóstrofo em um argumento, devem ser escritos dois
apóstrofos no texto delimitado por apóstrofos.
Qualquer coisa contida entre apóstrofos está, além disso, sujeito
a substituições do tipo C para
\n (nova-linha), \t (tabulação),
\b (retrocesso), \r (retorno de carro),
\f (alimentação de formulário),
\dígitos (octal), e
\xdígitos (hexadecimal).
Uma contrabarra antes de qualquer outro caractere dentro do texto
entre apóstrofos reproduz este único caractere, seja ele qual for.
Se aparecer em um argumento o caractere de dois-pontos
(:), não delimitado, seguido por um nome de
variável do psql, ele será substituído
pelo valor da variável, conforme descrito em
Interpolação SQL abaixo.
As formas
:' e
nome_da_variável':"
descritas nesta seção também funcionam.
A sintaxe
nome_da_variável":{?
permite testar se uma variável está definida.
É substituída por nome_da_variável}TRUE ou FALSE.
Preceder os dois-pontos por uma contrabarra o protege da substituição.
Em um argumento, o texto que está entre acentos grave (`)
é considerado uma linha de comando
a ser passada para o interpretador de comandos
(shell).
A saída do comando (com qualquer caractere de nova linha à direita
removido) substitui o texto entre acentos grave.
Dentro do texto entre acentos grave, nenhuma delimitação especial
ou outro processamento ocorre, exceto que as ocorrências de
:,
onde nome_da_variávelnome_da_variável é um nome de
variável do psql, são substituídas pelo
valor da variável.
Além disso, as ocorrências de
:'
são substituídas pelo valor da variável devidamente delimitado para
se tornar um único argumento de comando do interpretador de comandos.
(A última forma é quase sempre preferível, a menos que se tenha
certeza do que está na variável.)
Como os caracteres de retorno de carro e alimentação de linha não
podem ser delimitados com segurança em todas as plataformas, a forma
nome_da_variável':'
mostra uma mensagem de erro, e não substitui o valor da variável,
quando estes caracteres aparecem no valor.
nome_da_variável'
Alguns comandos recebem um identificador SQL
(como um nome de tabela) como argumento.
Estes argumentos seguem as regras de sintaxe do SQL:
Letras não delimitadas são convertidas para minúsculas, enquanto as
aspas (") protegem as letras da conversão de
maiúsculas para minúsculas, e permitem a incorporação de espaços
em branco no identificador.
Entre aspas, os pares de aspas se reduzem a uma única aspas no nome
resultante.
Por exemplo, FOO"BAR"BAZ é interpretado como
fooBARbaz, e "Um nome"" esquisito"
se torna Um nome" esquisito.
A análise dos argumentos termina no final da linha, ou quando
é encontrada outra contrabarra não delimitada.
Uma contrabarra não delimitada é considerada o início de um novo
meta-comando.
A sequência especial \\ (duas contrabarras)
marca o fim dos argumentos, e continuação da análise dos comandos
SQL, se houver.
Dessa forma, os comandos SQL e meta-comandos do
psql podem ser misturados livremente em
uma linha.
Mas de qualquer maneira, os argumentos de um meta-comando não podem
prosseguir além do fim da linha.
Muitos dos meta-comandos atuam no buffer de consulta corrente. Esta é simplesmente uma área contendo qualquer texto de comando SQL que tenha sido digitado, mas ainda não enviado ao servidor para execução. Inclui as linhas de entrada anteriores, bem como qualquer texto que apareça antes do meta-comando na mesma linha.
Muitos dos meta-comandos também permitem que seja apensada
a letra x no nome do comando.
Isto faz com que os resultados sejam mostrados no modo expandido,
como se tivesse sido usado \x ou
\pset expanded.
Estão definidos os seguintes meta-comandos:
\a #
Se o formato de saída de tabela corrente for não alinhado, será
alterado para alinhado.
Se for alinhado, será alterado para não alinhado.
Este comando é mantido para manter a compatibilidade com as
versões anteriores.
Veja uma solução mais geral em \pset.
\bind [ parâmetro ] ... #
Define os parâmetros de consulta para a próxima execução da
consulta, com os parâmetros especificados passados para
quaisquer sinalizador de parâmetro
($1 etc.).
Exemplo:
INSERT INTO tbl1 VALUES ($1, $2) \bind 'primeiro valor' 'segundo valor' \g
Isto também funciona para comandos de execução de consultas
além de \g, tais como \gx
e \gset.
Este comando faz com que seja usado o protocolo de consulta estendido (veja Seção 54.1.2), diferentemente da operação normal do psql, que usa o protocolo de consulta simples. Portanto, este comando pode ser útil para testar o protocolo de consulta estendido do psql. (O protocolo de consulta estendido é utilizado mesmo que a consulta não tenha parâmetros e este comando especifique zero parâmetros.) Este comando afeta apenas a próxima consulta executada; todas as consultas subsequentes usarão o protocolo de consulta simples por padrão.
\bind_named nome_da_instrução [ parâmetro ] ... #
\bind_named é equivalente a \bind,
exceto por receber o nome de uma instrução preparada existente
como primeiro parâmetro.
Uma cadeia de caracteres vazia indica uma instrução preparada
sem nome.
Exemplo:
INSERT INTO tbls1 VALUES ($1, $2) \parse stmt1 \bind_named stmt1 'primeiro valor' 'segundo valor' \g
Este comando faz com que seja usado o protocolo de consulta estendido (veja Seção 54.1.2), diferentemente da operação normal do psql, que usa o protocolo de consulta simples. Portanto, este comando pode ser útil para testar o protocolo de consulta estendido do psql.
\c ou \connect [ -reuse-previous=on|off ] [ nome_do_banco_de_dados [ nome_do_usuário ] [ hospedeiro ] [ porta ] | informação_da_conexão ] #
Estabelece uma nova conexão com o servidor
PostgreSQL.
Os parâmetros de conexão a serem usados podem ser especificados
usando a sintaxe posicional (um ou mais de nome do banco de dados,
usuário, hospedeiro e porta), ou usando a cadeia de caracteres
de conexão informação_da_conexão,
conforme detalhado em Cadeias de caracteres de conexão.
Se não for fornecido nenhum argumento, a nova conexão será
feita usando os mesmos parâmetros da anterior.
Especificar
nome_do_banco_de_dados,
nome_do_usuário,
hospedeiro, ou
porta como
-, equivale a omitir este parâmetro.
A nova conexão pode reutilizar os parâmetros de conexão da
conexão anterior; não apenas o nome do banco de dados, usuário,
hospedeiro e porta, mas outras configurações, como
modo_ssl.
Por padrão, os parâmetros são reutilizados na sintaxe posicional,
mas não quando é fornecida a cadeia de caracteres de
informação_da_conexão.
Passar o primeiro argumento como
-reuse-previous=on, ou
-reuse-previous=off,
prevalece sobre este padrão.
Se os parâmetros forem reutilizados, então qualquer parâmetro
não explicitamente especificado como parâmetro posicional, ou na
cadeia de caracteres de
informação_da_conexão,
será trazido dos parâmetros da conexão existente.
Uma exceção é que, se a configuração de
hospedeiro for alterada de seu valor
anterior usando a sintaxe posicional, qualquer configuração de
endereço_do_hospedeiro presente nos
parâmetros da conexão existente é eliminada.
Além disso, qualquer senha usada para a conexão existente será
reutilizada apenas se as configurações de usuário, hospedeiro
e porta não forem alteradas.
Quando o comando não especifica nem reutiliza um determinado
parâmetro, é usado o padrão da libpq.
Se a nova conexão for estabelecida com sucesso, a conexão
anterior será fechada.
Se a tentativa de conexão falhar (nome de usuário errado, acesso
negado, etc.), a conexão anterior será mantida se o
psql estiver no modo interativo.
Mas ao executar um script não interativo, a conexão antiga
é fechada, e é relatado um erro.
Isto pode ou não encerrar o script; se não encerrar, todos os
comandos de acesso ao banco de dados vão falhar até que outro
comando \connect seja executado com sucesso.
Esta distinção foi escolhida como uma conveniência do usuário
contra erros de digitação, por um lado, e um mecanismo de
segurança para que os scripts não atuem acidentalmente no
banco de dados errado, por outro lado.
Note que sempre que o comando \connect
tenta reutilizar parâmetros, os valores reutilizados são aqueles
da última conexão bem-sucedida, não de quaisquer tentativas
malsucedidas feitas posteriormente.
Entretanto, no caso de falha de um \connect
não interativo, nenhum parâmetro poderá ser reutilizado
posteriormente, porque o script provavelmente estaria esperando
os valores do \connect falhado para serem
reutilizados.
Exemplos:
\c mydb myuser host.dom 6432 \c service=foo \c "host=localhost port=5432 dbname=mydb connect_timeout=10 sslmode=disable" \c -reuse-previous=on sslmode=require -- muda apenas sslmode \c postgresql://tom@localhost/mydb?application_name=myapp
\C [ título ] #
Define o título de quaisquer tabelas que estão sendo mostradas
como resultado de uma consulta, ou desativa o título.
Equivale a \pset title
.
(O nome desse comando vem de “caption”, porque
anteriormente era usado apenas para definir o título em uma
tabela HTML.)
título
\cd [ diretório ] #
Muda o diretório de trabalho corrente para
diretório.
Sem argumento, muda para o diretório raiz do usuário corrente.
Para obter detalhes sobre como encontrar diretórios raiz,
veja O arquivo de senhas.
Para mostrar seu diretório de trabalho corrente,
pode ser usado \! pwd.
\close_prepared nome_da_instrução_preparada #Fecha a instrução preparada especificada. Uma cadeia de caracteres vazia representa uma instrução preparada sem nome. Se não existir nenhuma instrução preparada com este nome, a operação não terá efeito.
Exemplo:
SELECT $1 \parse stmt1 \close_prepared stmt1
Este comando faz com que seja usado o protocolo de consulta estendido (veja Seção 54.1.2), diferentemente da operação normal do psql, que usa o protocolo de consulta simples. Portanto, este comando pode ser útil para testar o protocolo de consulta estendido do psql.
\conninfo #Mostra informações sobre a conexão corrente com o banco de dados, incluindo informações relacionadas ao SSL, caso esteja em uso.
Note que o campo Client User
mostra o usuário no momento da conexão, enquanto o campo
Superuser indica se o usuário
corrente (no contexto de execução corrente) possui privilégios
de superusuário.
Estes usuários geralmente são os mesmos, mas podem ser
diferentes, por exemplo, se o usuário corrente foi alterado
com o comando SET ROLE.
\copy { tabela [ ( lista_de_colunas ) ] }
from
{ 'nome_do_arquivo' | program 'comando' | stdin | pstdin }
[ [ with ] ( opção [, ...] ) ]
[ where condição ]\copy { tabela [ ( lista_de_colunas ) ] | ( consulta ) }
to
{ 'nome_do_arquivo' | program 'comando' | stdout | pstdout }
[ [ with ] ( opção [, ...] ) ] #Executa uma operação de cópia no lado do cliente. Esta é uma operação que executa o comando COPY do SQL, mas em vez de o servidor ler ou escrever o arquivo especificado, o psql lê ou escreve o arquivo e roteia os dados entre o servidor e o sistema de arquivos local. Isto significa que o acesso e os privilégios dos arquivos são os do usuário local, não do servidor, e não são necessários privilégios de superusuário.
Quando é especificado program, o
comando é
executado pelo psql e os dados passados
pelo ou para o comando
são roteados entre o servidor e o cliente.
Novamente, os privilégios de execução são os do usuário local,
não do servidor, e não são necessários privilégios de
superusuário.
Para \copy ... from stdin, as linhas de dados
são lidas da mesma fonte que emitiu o comando, continuando até
que seja lida uma linha contendo apenas \.,
ou o fluxo atinge EOF.
Esta opção é útil para preencher tabelas diretamente em um
arquivo de script SQL.
Para \copy ... to stdout, a saída é enviada
para o mesmo local que a saída do comando
psql, e o estado de saída comando
COPY não
é mostrado (já que pode ser confundido com uma linha de dados).
Para ler/escrever a entrada ou saída padrão do
psql independentemente da fonte de
comando corrente ou da opção contador\o,
deve ser escrito from pstdin ou
to pstdout.
A sintaxe deste comando é semelhante à do comando
COPY do SQL.
Todas as opções, exceto a origem/destino dos dados, estão em
conformidade com as especificadas para comando
COPY.
Por este motivo, são aplicadas regras especiais de análise
no meta-comando \copy.
Ao contrário da maioria dos outros meta-comandos, o
restante da linha é sempre considerado como argumentos do
comando \copy, e nem a interpolação de
variáveis nem a expansão de acentos grave (`)
são realizadas nos argumentos.
Outra forma de obter o mesmo resultado que
\copy ... to é usar o comando
COPY .. TO STDOUT do SQL,
e terminá-lo com
\g
ou nome_do_arquivo\g |.
Diferentemente de programa\copy, este método permite
que o comando ocupe várias linhas; além disso, é possível usar
interpolação de variáveis e expansão de acentos grave (`).
Estas operações não são tão eficientes quanto o comando
COPY do SQL com uma fonte
ou destino de dados de arquivo ou programa, porque todos os
dados devem passar pela conexão cliente/servidor.
Para grandes quantidades de dados, o comando
SQL pode ser preferível.
\copyright #Mostra os termos de direitos autorais e de distribuição do PostgreSQL.
\crosstabview [
colV
[ colH
[ colD
[ sortcolH
] ] ] ] #
Executa o buffer de consulta
corrente (como \g), e mostra os resultados
em uma grade de tabulação cruzada
[187].
A consulta deve retornar ao menos três colunas.
A coluna de saída identificada por
colV torna-se
o cabeçalho vertical, e a coluna de saída identificada por
colH torna-se
o cabeçalho horizontal.
colD identifica
a coluna de saída a ser mostrada na grade.
sortcolH identifica
a coluna de classificação opcional para o cabeçalho horizontal.
Cada especificação de coluna pode ser um número de coluna
(começando em 1), ou um nome de coluna.
As regras usuais de conversão de maiúsculas em minúsculas
e de delimitação do SQL se aplicam aos nomes
das colunas.
Se omitido, colV
é tomado como a coluna 1, e
colH como a coluna 2.
colH
deve ser diferente de
colV.
Se colD não for
especificado, então deve haver exatamente três colunas no
resultado da consulta, e a coluna que não é
colV nem
colH é considerada
como colD .
O cabeçalho vertical, mostrado como a coluna mais à esquerda,
contém os valores encontrados na coluna
colV, na mesma ordem
dos resultados da consulta, mas com as duplicidades removidas.
O cabeçalho horizontal, mostrado como a primeira linha, contém
os valores encontrados na coluna
colH, com as
duplicidades removidas.
Por padrão, aparecem na mesma ordem dos resultados da consulta.
Mas se for fornecido o argumento opcional
sortcolH, será
identificada uma coluna onde os valores devem ser números inteiros,
e os valores de colH
aparecerão no cabeçalho horizontal classificados segundo os
valores de sortcolH
correspondentes.
Dentro da grade de tabulação cruzada, para cada valor distinto
x de
colH,
e cada valor distinto y
de colV,
a célula localizada na interseção (x,y)
conterá o valor da coluna colD na linha do
resultado da consulta, para a qual o valor de
colH é
x, e o valor de
colV é
y.
Se esta linha não existir, a célula ficará vazia.
Havendo várias dessas linhas, será relatado erro.
\d[Sx+] [ padrão ] #
Para cada relação (tabela, visão, visão materializada, índice,
sequência ou tabela estrangeira) ou tipo de dados composto
correspondendo ao padrão,
mostra todas as colunas, seus tipos de dados, o espaço de tabelas
(se não for o padrão), e quaisquer atributos especiais como
NOT NULL ou valor padrão.
Também são mostrados os índices, restrições, regras e gatilhos
associados.
Para tabelas estrangeiras, também é mostrado o servidor
estrangeiro associado.
(“Correspondendo ao padrão” é definido em
Padrões abaixo.)
Para alguns tipos de relação, \d mostra
informações adicionais para cada coluna: valores de coluna para
sequências, expressões indexadas para índices, e opções do
empacotador de dados estrangeiros para tabelas estrangeiras.
A forma do comando \d+ é idêntica, exceto
por serem mostradas mais informações: são mostrados quaisquer
comentários associados às colunas da tabela, assim como a
presença de OIDs na tabela, a definição da visão se a relação
for uma visão, uma configuração de
identidade da réplica diferente do padrão, e o nome do
método de acesso
se a relação tiver um método de acesso.
Por padrão, são mostrados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se \d for usado sem o argumento
padrão,
será equivalente a \dtvmsE, que mostra a
lista de todas as tabelas, visões, visões materializadas,
sequências e tabelas estrangeiras visíveis.
Esta é puramente uma medida de conveniência.
Assim como acontece com muitos outros comandos, se for apensado
x ao nome do comando, os resultados serão
mostrados no modo expandido., mas deve-se notar que isto só se
aplica quando \d é usado sem o argumento
padrão, e o
modificador x não pode aparecer imediatamente
após o \d (porque \dx
é um outro comando); o modificador x
só pode aparecer depois de um modificador S
ou +.
Por exemplo, \d+x é equivalente a
\dtvmsE+x, e irá mostrar uma lista de todas
as relações no modo expandido.
\da[Sx] [ padrão ] #
Lista as funções de agregação, com seus
tipos de dados retornado e os tipos de dados em que operam.
Se o padrão
for especificado, serão listadas apenas as agregações onde os
nomes correspondem ao padrão.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
\dA[x+] [ padrão ] #
Lista os métodos de acesso.
Se o padrão
for especificado, serão listados somente os métodos de acesso
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada método de acesso será mostrado com sua
função tratadora associada e sua descrição.
\dAc[x+]
[padrão-de-método-de-acesso
[padrão-de-tipo-de-entrada]]
#
Lista as classes de operador
(veja Métodos de índice e classes de operador).
Se o
padrão-de-método-de-acesso
for especificado, serão listadas somente as classes de operador
associadas a métodos de acesso onde os nomes correspondem a este padrão.
Se o
padrão-de-tipo-de-entrada
for especificado, serão listadas somente as classes de operador
associadas a tipos de dados de entrada onde os nomes correspondem
a este padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada classe de operador será mostrada com sua respectiva
família de operador e seu dono.
\dAf[x+]
[padrão-de-método-de-acesso
[padrão-de-tipo-de-entrada]]
#
Lista as famílias de operador
(veja Classes de operador e famílias de operador).
Se o
padrão-de-método-de-acesso
for especificado, serão listadas apenas as famílias de operador
associadas a métodos de acesso onde os nomes correspondem a este padrão.
Se o
padrão-de-tipo-de-entrada
for especificado, serão listadas apenas as famílias de operador
associadas a tipos de dados de entrada onde os nomes correspondem
a este padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada família de operador será mostrada com o seu dono.
\dAo[x+]
[padrão-de-método-de-acesso
[padrão-de-família-de-operador]]
#
Lista os operadores associados às famílias de operador
(veja Estratégias de método de índice).
Se o
padrão-de-método-de-acesso
for especificado, serão listados apenas os membros de famílias
de operador associados a métodos de acesso onde os nomes
correspondem a este padrão.
Se o
padrão-de-família-de-operador
for especificado, serão listados apenas os membros das famílias
de operador onde os nomes correspondem a este padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada operador será mostrado com sua família de operador
de ordenação (se for um operador de ordenação), e se sua
função subjacente é à prova de vazamentos
(leakproof).
\dAp[x+]
[padrão-de-método-de-acesso
[padrão-de-família-de-operador]]
#
Lista as funções de suporte associadas às famílias de operador
(veja Rotinas de suporte a método de índice).
Se o
padrão-de-método-de-acesso
for especificado, serão listadas apenas as funções de famílias
de operador associadas a métodos de acesso onde os nomes
correspondem a este padrão.
Se o
padrão-de-família-de-operador
for especificado, serão listadas apenas as funções das famílias
de operador onde os nomes correspondem a este padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, as funções serão mostradas na forma expandida,
com suas respectivas listas de parâmetros.
\db[x+] [ padrão ] #
Lista os espaços de tabelas.
Se o padrão
for especificado, serão listados somente os espaços de tabelas
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada espaço de tabelas será mostrado com suas opções
associadas, tamanho em disco, permissões e descrição.
\dc[Sx+] [ padrão ] #
Lista as conversões entre as codificações do conjunto de caracteres.
Se o padrão
for especificado, serão listadas apenas as conversões onde os
nomes correspondem ao padrão.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto será mostrado com sua respectiva descrição.
\dconfig[x+] [ padrão ] #
Lista os parâmetros de configuração do servidor
e seus respectivos valores.
Se o padrão
for especificado, serão listados apenas os parâmetros
onde os nomes correspondem ao padrão.
Sem o padrão,
somente serão listados os parâmetros que estão definidos com
valores diferentes do padrão.
(Deve ser usado \dconfig * para listar todos
os parâmetros.)
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada parâmetro será mostrado com seu tipo de dados,
contexto em que pode ser definido e privilégios de acesso
(se tiverem sido concedidos privilégios de acesso personalizados).
\dC[x+] [ padrão ] #
Lista as conversões de tipos de dados.
Se o padrão
for especificado, serão listadas apenas as conversões onde os
tipos de dados de origem ou de destino correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
conversão, incluindo se sua função subjacente é à prova de
vazamentos (leakproof)
e a descrição da conversão.
\dd[Sx] [ padrão ] #
Lista as descrições dos objetos do tipo constraint
(restrição),
operator class (classe de operador),
operator family (família de operador),
rule (regra) e
trigger (gatilho).
Todos os outros comentários podem ser vistos pelos respectivos
comandos de contrabarra para estes tipos de objeto.
\dd mostra as descrições dos objetos que
correspondem ao padrão,
ou dos objetos visíveis do tipo apropriado se não for fornecido
nenhum argumento.
Mas nos dois casos, apenas os objetos que possuem descrição
serão listados.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
As descrições para os objetos podem ser criadas pelo comando COMMENT do SQL.
\dD[Sx+] [ padrão ] #
Lista os domínios.
Se o padrão
for especificado, serão listados apenas os domínios onde os
nomes correspondem ao padrão.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto será mostrado com suas respectivas
permissões e descrição.
\ddp[x] [ padrão ] #
Lista as definições de privilégio de acesso padrão.
É mostrada uma entrada para cada função de banco de dados
(role) (e esquema, se aplicável)
para as quais as definições de privilégio padrão foram alteradas
em relação às definições padrão integradas.
Se o padrão
for especificado, serão listadas apenas as entradas onde o
nome da função de banco de dados, ou nome do esquema,
correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
É usado o comando ALTER DEFAULT PRIVILEGES para definir os privilégios de acesso padrão. O significado dos privilégios listados é explicado em Privilégios.
\dE[Sx+] [ padrão ]\di[Sx+] [ padrão ]\dm[Sx+] [ padrão ]\ds[Sx+] [ padrão ]\dt[Sx+] [ padrão ]\dv[Sx+] [ padrão ] #
Neste grupo de comandos, as letras E,
i, m, s,
t, e v,
representam tabela estrangeira, índice, visão materializada,
sequência, tabela e visão, respectivamente.
Pode-se especificar qualquer uma, ou todas estas letras,
em qualquer ordem, para obter uma lista de objetos desses tipos.
Por exemplo, \dti lista tabelas e índices.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto será mostrado com seu status de persistência
(permanente, temporário, ou não rastreado), tamanho físico no
disco, e descrição associada, se houver.
Se o padrão
for especificado, serão listados apenas os objetos onde os
nomes correspondem ao padrão.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
\des[x+] [ padrão ] #
Lista os servidores estrangeiros
(mnemônico: external servers).
Se o padrão
for especificado, serão listados apenas os servidores onde os
nomes corresponde ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, será mostrada uma descrição completa de cada servidor,
incluindo os privilégios de acesso, tipo, versão, opções
e descrição do servidor.
\det[x+] [ padrão ] #
Lista as tabelas estrangeiras
(mnemônico: external tables).
Se o padrão
for especificado, serão listadas apenas as entradas onde o
nome da tabela, ou nome do esquema, correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, também serão mostradas as opções genéricas e a
descrição da tabela estrangeira.
\deu[x+] [ padrão ] #
Lista os mapeamentos de usuários
(mnemônico: external users).
Se o padrão
for especificado, serão listados apenas os mapeamentos onde os
nomes de usuário correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
mapeamento.
\deu+ também pode mostrar o nome e a senha
do usuário externo, portanto, deve-se tomar cuidado para não
divulgá-los.
\dew[x+] [ padrão ] #
Lista os empacotadores de dados estrangeiros
(mnemônico: external wrappers).
Se o padrão
for especificado, serão listados apenas os empacotadores de
dados estrangeiros onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, também serão mostrados os privilégios de acesso,
as opções e a descrição do empacotador de dados estrangeiros.
\df[anptwSx+] [ padrão [ padrão_de_argumento ... ] ] #
Lista as funções, junto com seus
tipos de dados do resultado,
tipos de dados dos argumentos, e tipos de função, classificados
como “agg” (agregação), “normal”,
“procedure” (procedimento), “trigger”
(gatilho), ou “window” (janela).
Para mostrar apenas as funções de tipo(s) específico(s), devem
ser adicionadas as letras correspondentes a,
n, p, t,
ou w, ao comando.
Se o padrão
for especificado, serão listadas apenas as funções onde os
nomes correspondem ao padrão.
Quaisquer argumentos adicionais são padrões de nome de tipo de
dados, que correspondem aos nomes do tipo de dados do primeiro,
segundo, e assim por diante, argumentos da função.
(As funções correspondentes podem ter mais argumentos do que
o especificado. Para evitar isto, deve ser escrito um hífen
- como o último
padrão_de_argumento.)
Por padrão, são mostrados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
função, incluindo volatilidade, segurança quanto ao paralelismo,
dono, classificação de segurança, se é à prova de vazamentos
( leakproof), privilégios de
acesso, linguagem, nome interno
(para a linguagem C e funções internas apenas) e descrição.
O código-fonte de uma função específica pode ser visto usando
\sf.
\dF[x+] [ padrão ] #
Lista as configurações de procura de texto completo.
Se o padrão
for especificado, serão listadas apenas as configurações
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, será mostrada uma descrição completa de cada configuração,
incluindo o analisador de procura de texto subjacente e a
lista de dicionários para cada tipo de chave
(token) do analisador.
\dFd[x+] [ padrão ] #
Lista os dicionários de procura de texto completo.
Se o padrão
for especificado, serão listados apenas os dicionários
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
dicionário selecionado, incluindo o modelo de procura de texto
subjacente e os valores das opções.
\dFp[x+] [ padrão ] #
Lista os analisadores de procura de texto completo.
Se o padrão
for especificado, serão listados apenas os analisadores
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, será mostrada uma descrição completa de cada
analisador, incluindo as funções subjacentes e a lista de tipos
de chave (token) reconhecidos.
\dFt[x+] [ padrão ] #
Lista os modelos de procura de texto completo.
Se o padrão
for especificado, serão listados apenas os modelos onde os
nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
modelo, incluindo os nomes das funções subjacentes.
\dg[Sx+] [ padrão ] #
Lista as funções de banco de dados
(roles).
(Uma vez que os conceitos de “usuários” e
“grupos” foram unificados em
“funções de banco de dados”, este comando agora
equivale a \du.)
Por padrão, são listadas apenas as funções de banco de dados
criadas pelo usuário; deve ser fornecido um padrão, ou o
modificador S, para incluir as funções de
banco de dados do sistema.
Se o padrão
for especificado, serão mostradas apenas as funções de banco
de dados onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
função de banco de dados; no momento, isto adiciona um
comentário para cada função.
\dl[x+] #
Este é um alias para \lo_list, que mostra
a lista dos objetos grandes.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto grande será mostrado com suas respectivas
permissões, se houver.
\dL[Sx+] [ padrão ] #
Lista as linguagens procedurais.
Se o padrão
for especificado, serão listadas apenas as linguagens onde os
nomes correspondem ao padrão.
Por padrão, são listadas apenas as linguagens criadas pelo usuário;
deve ser fornecido o modificador S para
incluir as linguagens do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada linguagem será mostrada com seu tratador de chamadas,
validador, privilégios de acesso, e se é um objeto do sistema.
\dn[Sx+] [ padrão ] #
Lista os esquemas (espaços de nomes).
Se o padrão
for especificado, serão mostrados apenas os esquemas onde os
nomes correspondem ao padrão.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto será mostrado com suas respectivas permissões
e descrição, se houver.
\do[Sx+] [ padrão [ padrão_de_argumento [ padrão_de_argumento ] ] ] #
Lista os operadores com seus tipos de dados
de operandos e resultado.
Se o padrão
for especificado, serão listados apenas os operadores onde os
nomes correspondem ao padrão.
Se for especificado apenas o
padrão_de_argumento,
serão listados apenas os operadores de prefixo, onde o nome do
tipo de dados do argumento à direita corresponde a este padrão.
Se forem especificados dois
padrão_de_argumento,
serão listados apenas os operadores binários, onde os nomes dos
tipos de dados dos argumentos correspondem a estes padrões.
(Como alternativa, pode ser escrito um hífen
(-) para o argumento não utilizado de um
operador unário.)
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
operador, incluindo o nome da função subjacente e se ela é à
prova de vazamentos (leakproof).
\dO[Sx+] [ padrão ] #
Lista as ordenações
(collations).
Se o padrão
for especificado, serão listadas apenas as ordenações onde os
nomes correspondem ao padrão.
Por padrão, são listados apenas os objetos criados pelo usuário;
deve ser fornecido um padrão, ou o modificador S,
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada ordenação será mostrada com a sua descrição
associada, se houver.
Note que serão listadas apenas as ordenações utilizáveis
com a codificação do banco de dados corrente, portanto, os
resultados podem variar entre diferentes bancos de dados
da mesma instância.
\dp[Sx] [ padrão ] #
Lista as tabelas, visões e sequências,
com seus privilégios de acesso associados.
Se o padrão
for especificado, serão listadas apenas as tabelas, visões
e sequências onde os nomes correspondem ao padrão.
Por padrão, são mostrados apenas os objetos criados pelo usuário;
deve ser fornecido o padrão ou o modificador S
para incluir objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
São usados os comandos GRANT e REVOKE para definir os privilégios de acesso. O significado do privilégio mostrado é explicado em Privilégios.
\dP[itnx+] [ padrão ] #
Lista as relações particionadas.
Se o padrão
for especificado, serão listadas apenas as entradas onde os
nomes correspondem ao padrão.
Podem ser apensados ao comando os modificadores t
(tabelas) e i (índices), para filtrar o tipo
de relação a ser listada.
Por padrão, são listados tabelas e índices particionados.
Se for usado o modificador n
(“nested/aninhado”), ou for especificado um padrão,
então serão incluídas as relações particionadas não-raiz,
e será mostrada uma coluna contendo o ancestral de cada relação
particionada.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, também será mostrada a soma dos tamanhos das partições
de cada relação, com a descrição da relação.
Se n for combinado com +,
serão mostrados dois tamanhos: um incluindo o tamanho total das
partições folha diretamente conectadas, e o outro mostrando
o tamanho total de todas as partições, incluindo as
subpartições indiretamente conectadas.
\drds[x] [ role-pattern [ database-pattern ] ] #
Lista os parâmetros de configuração definidos.
Estas configurações podem ser específicas da função de banco
de dados (role), específicas do
banco de dados, ou ambas.
São usados padrão_de_função_bd e
padrão_de_banco_de_dados para
selecionar as funções de banco de dados e os bancos de dados
específicos a serem mostrados, respectivamente.
Se omitido, ou se for especificado *,
serão mostradas todas as configurações, incluindo aquelas não
específicas da função de banco de dados ou do banco de dados,
respectivamente.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
São usados os comandos ALTER ROLE e ALTER DATABASE para definir os parâmetros de configuração por função de banco de dados e por banco de dados.
\drg[Sx] [ padrão ] #
Lista informações sobre cada função de banco de dados concedida,
incluindo opções atribuídas (ADMIN,
INHERIT e/ou SET)
e o concedente.
Veja o comando GRANT para obter
informações sobre a participação em funções de banco de dados.
Por padrão, são listadas apenas as concessões para
funções de banco de dados criadas pelo usuário; deve ser
fornecido o modificador S para incluir as
funções de banco de dados do sistema.
Se o padrão
for especificado, serão listadas apenas as concessões para as
funções de banco de dados onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
\dRp[x+] [ padrão ] #
Lista as publicações de replicação.
Se o padrão
for especificado, serão listadas apenas as publicações onde os
nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, também serão mostradas as tabelas e os esquemas
associados a cada publicação.
\dRs[x+] [ padrão ] #
Lista as subscrições de replicação.
Se o padrão
for especificado, serão mostradas apenas as subscrições onde os
nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas propriedades adicionais das subscrições.
\dT[Sx+] [ padrão ] #
Lista os tipos de dados.
Se o padrão
for especificado, serão listados apenas os tipos de dados
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada tipo de dados será mostrado com seu nome interno
e tamanho, seus valores permitidos se for um tipo de dados
enum, e suas permissões associadas.
Por padrão, apenas os objetos criados pelo usuário são listados;
deve ser fornecido um padrão ou o modificador S
para incluir os objetos do sistema.
\du[Sx+] [ padrão ] #
Lista as funções do banco de dados
(roles).
(Uma vez que os conceitos de “usuários” e
“grupos” foram unificados em
“funções de banco de dados”, este comando agora
equivale a \dg.)
Por padrão, são listadas apenas as funções de banco de dados
criadas pelo usuário; deve ser fornecido o modificador
S, para incluir as funções de banco de dados
do sistema.
Se o padrão
for especificado, serão listadas apenas as funções de banco
de dados onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostradas informações adicionais sobre cada
função de banco de dados; no momento, isto adiciona um
comentário para cada função de banco de dados.
\dx[x+] [ padrão ] #
Lista as extensões instaladas.
Se o padrão
for especificado, serão listadas apenas as extensões onde os
nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, serão mostrados todos os objetos pertencentes a cada
extensão correspondente.
\dX[x] [ padrão ] #
Lista as estatísticas estendidas.
Se o padrão
for especificado, serão listadas apenas as estatísticas
estendidas onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
O status de cada tipo de estatística estendida é mostrado em
uma coluna com o nome de seu tipo de estatística
(por exemplo, Ndistinct).
defined significa que foi solicitado ao criar
as estatísticas, e NULL significa que não foi
solicitado.
Pode-se usar pg_stats_ext se for
desejado saber se o ANALYZE foi executado,
e se as estatísticas estão disponíveis para o planejador.
\dy[x+] [ padrão ] #
Lista os gatilhos de eventos.
Se o padrão
for especificado, serão listados apenas os gatilhos de evento
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto será mostrado com sua respectiva descrição.
\e ou \edit [ nome_do_arquivo ] [ número_da_linha ] #
Se o nome_do_arquivo
for especificado, o arquivo será editado; e depois que o editor
for fechado, o conteúdo do arquivo será copiado para o
buffer de consulta corrente.
Se o nome_do_arquivo
não for fornecido, o buffer de
consulta corrente será copiado para um arquivo temporário e
editado da mesma maneira.
Ou, se o buffer de consulta
corrente estiver vazio, será copiada a consulta executada
mais recentemente para um arquivo temporário, e editada
da mesma maneira.
Se for editado um arquivo ou consulta anterior, e fechado o
editor sem modificar o arquivo, o
buffer de consulta será limpo.
Caso contrário, o novo conteúdo do
buffer de consulta será analisado
novamente conforme as regras normais do
psql, tratando todo
o buffer como uma única linha.
Quaisquer consultas completas serão executadas imediatamente;
ou seja, se o buffer de consulta
contiver ou terminar com um ponto e vírgula, tudo até este ponto
será executado e removido do buffer
de consulta.
Tudo que restar no buffer de
consulta será mostrado novamente.
Deve ser digitado um ponto-e-vírgula ou \g
para executar, ou \r para cancelar limpando
o buffer de consulta.
Tratar o buffer como uma única
linha afeta principalmente os meta-comandos: tudo o que estiver
no buffer após o meta-comando
será considerado argumento(s) para o meta-comando,
mesmo que ocupe várias linhas.
(Portanto, não se pode fazer scripts usando meta-comandos dessa
maneira. Deve ser usado \i para isto.)
Se for especificado o número da linha, o psql irá posicionar o cursor na linha especificada do arquivo ou do buffer de consulta. Note que, se for fornecido um único argumento com somente dígitos, o psql assume que é um número de linha, e não um nome de arquivo.
Veja Variáveis de ambiente abaixo, para saber como configurar e personalizar o editor.
\echo texto [ ... ] #Envia os argumentos avaliados para a saída padrão, separados por espaços, e seguidos por uma nova linha. Pode servir para intercalar informações na saída de scripts. Por exemplo:
\echo `date`
sex 17 abr 2026 15:08:02 -03
Se o primeiro argumento for -n não
delimitado, o caractere de nova-linha à direita não será escrito
(nem o primeiro argumento).
Se for usado o meta-comando \o para
redirecionar a saída da consulta, talvez seja melhor usar
\qecho em vez desse comando.
Veja também \warn.
\ef [ descrição_da_função [ número_da_linha ] ] #
Este comando busca e edita a definição da função ou
procedimento especificado, na forma de um comando
CREATE OR REPLACE FUNCTION ou
CREATE OR REPLACE PROCEDURE.
A edição é feita da mesma forma que para \edit.
Se o editor for fechado sem salvar, a instrução será descartada.
Se salvar e sair do editor, o comando atualizado será executado
imediatamente se for adicionado um ponto e vírgula a ele.
Caso contrário, será mostrado novamente;
deve ser digitado um ponto e vírgula ou \g
para executar, ou \r para cancelar.
A função de destino pode ser especificada apenas pelo nome,
ou pelo nome e argumentos, por exemplo,
foo(integer, text).
Devem ser fornecidos os tipos dos argumentos, se houver mais
de uma função com o mesmo nome.
Se não for especificada nenhuma função, um modelo de
CREATE FUNCTION em branco será mostrado
para edição.
Se for especificado o número da linha, o psql irá posicionar o cursor na linha especificada do corpo da função. (Note que o corpo da função normalmente não começa na primeira linha do arquivo.)
Ao contrário da maioria dos outros meta-comandos, o
restante da linha é sempre considerado argumento(s) de
\ef, e nem a interpolação de variáveis
nem a expansão de acentos grave (`)
são executadas nos argumentos.
Veja Variáveis de ambiente abaixo, para saber como configurar e personalizar o editor.
\encoding [ encoding ] #Define a codificação do conjunto de caracteres do cliente. Sem um argumento, este comando mostra a codificação corrente.
\errverbose #
Repete a mensagem de erro mais recente do servidor com a
verbosidade máxima, como se VERBOSITY
estivesse definido como verbose, e
SHOW_CONTEXT estivesse definido como
always.
\ev [ nome_da_visão [ número_da_linha ] ] #
Este comando busca e edita a definição da visão especificada,
na forma do comando CREATE OR REPLACE VIEW.
A edição é feita da mesma forma que para \edit.
Se salvar e sair do editor, o comando atualizado será executado
imediatamente se for adicionado um ponto e vírgula a ele.
Caso contrário, será mostrado novamente;
deve ser digitado um ponto e vírgula ou \g
para executar, ou \r para cancelar.
Se não for especificada nenhuma visão, será mostrado um modelo
de CREATE VIEW em branco para edição.
Se for especificado o número da linha, o psql irá posicionar o cursor na linha especificada da definição da visão.
Ao contrário da maioria dos outros meta-comandos, o
restante da linha é sempre considerado argumento(s) de
\ev, e nem a interpolação de variáveis
nem a expansão de acentos grave (`)
são executadas nos argumentos.
\f [ string ] #
Define o separador de campos para a saída não alinhada da consulta.
O padrão é a barra vertical (|).
Equivale a \pset fieldsep.
\g [ (opção=valor [...]) ] [ nome_do_arquivo ]\g [ (opção=valor [...]) ] [ |comando ] #Envia o buffer de consulta corrente para o servidor para ser executado.
Se forem colocados parênteses após o \g,
eles irão envolver uma lista de cláusulas de opção de formatação,
separadas por espaço, contendo
opção=valor,
que serão interpretadas da mesma forma que comandos
\pset
opção
valor,
mas com efeito apenas durante esta consulta.
Nesta lista, não são permitidos espaços ao redor dos sinais de
=, mas são necessários entre as cláusulas de opção.
Se for omitido
=valor,
a opção especificada
é alterada da mesma forma que em \pset
opção sem um
valor indicado.
Se for especificado o
nome_do_arquivo,
ou o argumento
|comando,
a saída da consulta será escrita no arquivo especificado, ou
canalizada (pipe) para o comando
fornecido, em vez de mostrada como de costume.
O arquivo ou comando será escrito apenas se a consulta retornar
zero ou mais tuplas com êxito, mas não se a consulta falhar,
ou for um comando SQL sem retorno de dados.
Se o buffer de consulta corrente
estiver vazio, será executada novamente a consulta enviada mais
recentemente.
Exceto por este comportamento, \g sem nenhum
argumento é essencialmente equivalente ao ponto e vírgula.
Com argumentos, \g fornece uma alternativa
“de uma única vez” ao comando \o,
e adicionalmente permite ajustes de uma única vez das opções
de formatação de saída normalmente definidas por
\pset.
Quando o último argumento começa com |,
o restante da linha é considerado o
comando a ser
executado, e nem a interpolação de variáveis, nem a expansão
acentos grave (`), são executadas no comando.
O restante da linha é simplesmente passado literalmente para o
interpretador de comandos (shell).
\gdesc #Mostra a descrição (isto é, os nomes das colunas e os tipos de dados) do resultado do buffer de consulta corrente. A consulta não é realmente executada; porém, se contiver algum tipo de erro de sintaxe, este erro será relatado normalmente.
Se o buffer de consulta corrente estiver vazio, será descrita a consulta enviada mais recentemente.
\getenv psql_var env_var #
Obtém o valor da variável de ambiente
env_var
e atribui à variável do psql
psql_var.
Se env_var não
estiver definido no ambiente do processo
psql, então
psql_var
não será alterada. Exemplo:
\getenv home HOME
\echo :home
/var/lib/postgresql
\gexec #
Envia o buffer de consulta
corrente para o servidor, tratando cada coluna de cada linha
da saída da consulta (se houver) como uma instrução
SQL a ser executada.
Por exemplo, para criar um índice em cada coluna de
minha_tabela
SELECT format('create index on minha_tabela(%I)', attname)
FROM pg_attribute
WHERE attrelid = 'minha_tabela'::regclass AND attnum > 0
ORDER BY attnum
\gexec
CREATE INDEX
CREATE INDEX
CREATE INDEX
CREATE INDEX
As consultas geradas são executadas na ordem em que as linhas
são retornadas, e da esquerda para a direita dentro de cada
linha, se houver mais de uma coluna.
Os campos NULL são ignorados.
As consultas geradas são enviadas literalmente ao servidor para
execução, portanto, não podem ser meta-comandos do
psql, nem conter referências
a variáveis do psql.
Se qualquer consulta individual falhar, a execução das consultas
restantes prossegue, a menos que seja definido
ON_ERROR_STOP.
A execução de cada consulta está sujeita ao processamento de
ECHO.
(Definir ECHO como all ou
queries geralmente é aconselhável ao usar
\gexec.)
Registro de consulta, modo de etapa única, tempo, e outros
recursos de execução de consulta também se aplicam a cada
consulta gerada.
Se o buffer de consulta corrente estiver vazio, será executada novamente a consulta enviada mais recentemente.
\gset [ prefix ] #Envia o buffer de consulta corrente para o servidor, e armazena a saída da consulta em variáveis do psql (veja Variáveis abaixo). A consulta a ser executada deve retornar exatamente uma linha. Cada coluna da linha é armazenada em uma variável separada, com o mesmo nome da coluna. Por exemplo:
SELECT 'hello' AS var1, 10 AS var2
\gset
\echo :var1 :var2
hello 10
Se o prefixo
for especificado, esta cadeia de caracteres será anexada aos
nomes das colunas da consulta para criar os nomes das
variáveis a serem usadas:
SELECT 'hello' AS var1, 10 AS var2
\gset result_
\echo :result_var1 :result_var2
hello 10
Se o resultado da coluna for NULL, a variável
correspondente terá sua definição removida, em vez de ser
definida.
Se a consulta falhar, ou não retornar uma linha, nenhuma variável será alterada.
Se o buffer de consulta corrente estiver vazio, será executada novamente a consulta enviada mais recentemente.
\gx [ (opção=valor [...]) ] [ nome_do_arquivo ]\gx [ (opção=valor [...]) ] [ |comando ] #
\gx equivale a \g,
exceto por forçar o modo de saída expandido para esta consulta,
como se expanded=on estivesse incluído
na lista de opções de \pset.
Veja também \x.
\h ou \help [ comando ] #
Fornece ajuda de sintaxe para o comando SQL
especificado.
Se não for especificado o
comando, o
psql irá listar todos os comandos
para os quais está disponível ajuda de sintaxe.
Se o comando for um
asterisco (*), será mostrada a ajuda de
sintaxe para todos os comandos SQL.
Ao contrário da maioria dos outros meta-comandos,
o restante da linha é sempre considerado argumento(s) de
\help, e nem a interpolação de variáveis,
nem a expansão de acentos grave (`),
são executadas nos argumentos.
Para simplificar a digitação, os comandos que consistem em
várias palavras não precisam ser delimitados.
Assim, pode-se muito bem digitar
\help alter table.
\H ou \html #
Ativa o formato HTML de saída de consulta.
Se o formato HTML já estiver ativo,
ele retornará ao formato de texto alinhado padrão.
Este comando é mantido para compatibilidade e conveniência,
mas deve ser consultado \pset sobre
a configuração de outras opções de saída.
\i ou \include nome_do_arquivo #
Lê a entrada no arquivo
nome_do_arquivo,
e a executa como se tivesse sido digitada no teclado.
Se o nome_do_arquivo for um
- (hífen), então a entrada padrão será lida
até uma indicação de EOF ou o meta-comando
\q.
Pode servir para intercalar a entrada interativa com a entrada
por arquivos.
Note que o comportamento de Readline
será usado apenas se estiver ativo no nível mais externo.
Se for desejado ver as linhas na tela conforme são lidas,
deve-se definir a variável ECHO como
all.
\if expressão\elif expressão\else\endif #
Este grupo de comandos implementa blocos condicionais aninhados.
Um bloco condicional deve começar com \if
e terminar com \endif.
No meio pode haver qualquer número de cláusulas
\elif, que podem ser opcionalmente seguidas
por uma única cláusula \else.
Consultas comuns e outros tipos de comandos de contrabarra podem
aparecer (e geralmente aparecem) entre os comandos que formam
o bloco condicional.
Os comandos \if e \elif
leem seu(s) argumento(s) e os avalia como uma expressão booleana.
Se a expressão resultar em true, o
processamento continuará normalmente;
caso contrário, as linhas serão saltadas até que um
\elif, \else, ou
\endif correspondente seja alcançado.
Uma vez que um teste de \if ou
\elif tenha sido bem-sucedido, os argumentos
dos comandos \elif posteriores no mesmo bloco
não serão avaliados, sendo tratados como falsos.
As linhas que seguem o \else são processadas
somente se nenhum \if ou
\elif correspondente anterior foi bem-sucedido.
O argumento expressão
de um comando \if ou \elif
está sujeito a interpolação de variáveis e a expansão de
acentos grave (`), assim como qualquer outro argumento
de comando de contrabarra.
Após isto é avaliado como o valor de uma variável de opção
on/off.
Portanto, um valor válido é qualquer correspondência inequívoca
que não diferencie letras maiúsculas de minúsculas para um entre:
true, false, 1,
0, on, off,
yes, no.
Por exemplo, t, T e
tR serão todos considerados
true.
As expressões que não forem avaliadas corretamente como verdade ou falso vão gerar uma advertência, e serão tratadas como falsas.
As linhas saltadas são analisadas normalmente para identificar
consultas e comandos de contrabarra, mas as consultas não são
enviadas para o servidor, e os comandos de contrabarra diferentes
dos condicionais (\if, \elif,
\else, e \endif),
são ignorados.
Os comandos condicionais são verificados apenas quanto a
aninhamento válido.
As referências a variáveis nas linhas saltadas não são expandidas,
e a expansão de acentos grave (`) também não é executada.
Todos os comandos de contrabarra de um determinado bloco
condicional devem aparecer no mesmo arquivo-fonte.
Se for alcançado o EOF no arquivo de entrada
principal, ou em um arquivo \include,
antes que todos os blocos \if locais tenham
sido fechados, então o psql
irá relatar um erro.
A seguir está um exemplo:
-- verificar a existência de dois registros separados no banco de dados
-- e armazenar os resultados em variáveis do psql separadas
SELECT
EXISTS(SELECT 1 FROM customer WHERE customer_id = 123) as is_customer,
EXISTS(SELECT 1 FROM employee WHERE employee_id = 456) as is_employee
\gset
\if :is_customer
SELECT * FROM customer WHERE customer_id = 123;
\elif :is_employee
\echo 'não é cliente mas é funcionário'
SELECT * FROM employee WHERE employee_id = 456;
\else
\if yes
\echo 'não é cliente ou funcionário'
\else
\echo 'isto nunca será mostrado'
\endif
\endif
\ir ou \include_relative nome_do_arquivo #
O meta-comando \ir é semelhante ao
\i, mas resolve os nomes de arquivos
relativos de maneira diferente.
Ao executar no modo interativo, os dois comandos se comportam
de forma idêntica.
Entretanto, quando chamado a partir de um script,
\ir interpreta os nomes dos arquivos
relativamente ao diretório onde o script está localizado,
em vez do diretório de trabalho corrente.
\l[x+] ou \list[x+] [ padrão ] #
Lista os bancos de dados no servidor,
mostrando seus nomes, donos, codificações dos conjuntos de
caracteres, e privilégios de acesso.
Se o padrão
for especificado, serão mostrados apenas os bancos de dados
onde os nomes correspondem ao padrão.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, também serão mostrados os tamanhos dos bancos de dados,
os espaços de tabela padrão e as descrições.
(As informações de tamanho estão disponíveis apenas para os
bancos de dados aos quais o usuário corrente pode se conectar.)
\lo_export loid nome_do_arquivo #
Lê o objeto grande com o OID igual a
oid_de_objeto_grande
no banco de dados, e escreve no
nome_do_arquivo.
Note que é sutilmente diferente da função do servidor
lo_export, que atua com as permissões
do usuário com o qual o servidor de banco de dados executa,
e no sistema de arquivos do servidor.
Deve ser usado o meta-comando \lo_list
para descobrir o OID do objeto grande.
\lo_import nome_do_arquivo [ comentário ] #Armazena o arquivo em um objeto grande do PostgreSQL. Opcionalmente, associa o comentário fornecido ao objeto. Por exemplo:
\lo_import '/home/peter/pictures/photo.xcf' 'uma foto minha'
lo_import 152801
A resposta indica que o objeto grande recebeu o ID de objeto
152801, que poderá ser usado para acessar o objeto grande
recém-criado no futuro.
Por uma questão de legibilidade, é recomendável sempre associar
um comentário legível por humanos a cada objeto.
Os OIDs e os comentários podem ser vistos usando o meta-comando
\lo_list.
Note que este meta-comando é sutilmente diferente da função
do servidor lo_import, porque atua
como o usuário local no sistema de arquivos local, em vez do
usuário e sistema de arquivos do servidor.
\lo_list[x+] #
Mostra a lista de todos os objetos grandes do
PostgreSQL armazenados no banco de
dados, com quaisquer comentários fornecidos para eles.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Se for apensado o modificador + ao nome do
comando, cada objeto grande será listado com suas respectivas
permissões, se houver.
\lo_unlink oid_de_objeto_grande #
Exclui do banco de dados o objeto grande com o
OID igual a
oid_de_objeto_grande.
Deve ser usado o meta-comando \lo_list
para descobrir o OID do objeto grande.
\o ou \out [ nome_do_arquivo ]\o ou \out [ |comando ] #
Prepara para salvar os resultados das futuras consultas no arquivo
nome_do_arquivo,
ou canalizar os resultados futuros para o comando do
interpretador de comandos (shell)
comando.
Se não for especificado nenhum argumento, a saída da consulta
será redefinida para a saída padrão.
Se o argumento começar com |, então o
restante da linha será considerado o
comando a ser
executado, e nem a interpolação de variáveis nem a expansão de
acentos grave (`) serão realizadas nele.
O restante da linha é simplesmente passado literalmente para
o interpretador de comandos.
Os “resultados da consulta” incluem todas as tabelas,
respostas de comando, e avisos obtidos do servidor de banco de
dados, bem como a saída de vários comandos de contrabarra que
consultam o banco de dados (tal como \d);
mas nenhuma mensagem de erro.
Para intercalar a saída de texto entre os resultados da consulta,
deve ser usado \qecho.
\p ou \print #Mostra o buffer de consulta corrente na saída padrão. Se o buffer de consulta corrente estiver vazio, será mostrada a consulta executada mais recentemente.
\parse nome_da_instrução #Cria uma instrução preparada a partir do buffer de consulta corrente, com base no nome de um objeto de instrução preparada de destino. Uma cadeia de caracteres vazia representa a instrução preparada sem nome.
Exemplo:
SELECT $1 \parse stmt1
Este comando faz com que seja usado o protocolo de consulta estendido, diferentemente da operação normal do psql, que usa o protocolo de consulta simples. Uma mensagem Parse (F) será emitida por este comando, portanto, pode ser útil para testar o protocolo de consulta estendido a partir do psql. Este comando afeta apenas a próxima consulta executada; todas as consultas subsequentes usarão o protocolo de consulta simples por padrão.
\password [ nome_do_usuário ] #
Altera a senha do usuário especificado
(por padrão, o usuário corrente).
Este comando solicita a nova senha, encripta, e a envia ao
servidor como um comando ALTER ROLE.
Isto garante que a nova senha não apareça como texto não
encriptado no histórico de comandos, no registro do servidor,
ou em outro lugar.
\prompt [ texto ] nome #
Pede que o usuário forneça o texto a ser atribuído à variável
nome_da_variável.
Pode ser especificada a cadeia de caracteres opcional
texto,
mostrada no pedido.
(Para cadeias de caracteres de várias palavras, o texto deve
ser colocado entre apóstrofos.)
=>\prompt 'Digite seu sobrenome', sobrenome-- Exemplo do tradutor Digite seu sobrenome,Fagundes Telles=>\echo :sobrenomeFagundes Telles
Por padrão, o \prompt usa o terminal para
entrada e saída.
No entanto, se for usada a opção de linha de comando
-f, o \prompt usará a
entrada e saída padrão.
\pset [ opção [ valor ] ] #
Este meta-comando define as opções que afetam a saída das
tabelas de resultados da consulta.
A opção indica qual
opção deve ser definida.
A semântica do valor
varia dependendo da opção selecionada.
Para algumas opções, omitir o
valor faz com que
a opção seja alternada ou perca a definição, conforme descrito
na opção específica.
Se este comportamento não for mencionado, a omissão do
valor apenas fará
com que seja mostrada a configuração corrente.
\pset sem nenhum argumento exibe o status
corrente de todas as opções de exibição.
As opções de exibição ajustáveis são:
border #
O valor deve ser
um número.
Em geral, quanto maior o número, mais bordas e linhas terão as
tabelas, mas os detalhes dependem do formato específico.
No formato HTML, isto será traduzido
diretamente no atributo border=....
Na maioria dos outros formatos, apenas os valores 0 (sem borda),
1 (linhas divisórias internas), e 2 (moldura da tabela) fazem
sentido, e os valores acima de 2 serão tratados da mesma forma
que border = 2.
Os formatos latex e
latex-longtable também permitem um valor
igual a 3, para adicionar linhas divisórias entre as linhas de
dados.
columns #
Define a largura para o formato wrapped
(empacotado), e a largura em que a saída é suficientemente
longa para exigir o paginador, ou alternar para a exibição
vertical no modo automático expandido.
Zero (o padrão) faz com que a largura seja controlada pela
variável de ambiente COLUMNS, ou pela largura da
tela detectada se COLUMNS não estiver definida.
Além disso, se columns for zero, o formato
wrapped afetará apenas a saída na tela.
Se columns for diferente de zero, a saída
em arquivo e a saída canalizada
(pipe) também estarão sujeitas
a quebras de linha nesta largura.
csv_fieldsep #Especifica o separador de campos a ser usado no formato de saída CSV. Se o caractere separador aparecer no valor de um campo, este campo será gerado delimitado, seguindo as regras padrão para o formato CSV. O padrão é a vírgula.
expanded (ou x) #
Se o valor
for especificado, este deverá ser on ou
off, que irá ativar ou desativar o
modo expandido, ou auto.
Se for omitido o
valor, o comando
alterna entre as configurações de ativado e desativado.
Quando o modo expandido está ativo, os resultados da consulta
são mostrados em duas colunas, com o nome da coluna à esquerda
e os dados à direita.
Este modo é útil se os dados não couberem na tela no modo
“horizontal” normal.
Na configuração automática, o modo expandido é utilizado sempre
que a saída da consulta tiver mais de uma coluna e for mais
larga que a tela; caso contrário, é usado o modo normal.
A configuração automática só é efetiva nos formatos alinhados
e wrapped.
Nos outros formatos, sempre se comporta como se o modo
expandido estivesse desativado.
fieldsep #
Especifica o separador de campos a ser usado no formato de
saída não alinhada.
Dessa forma, pode-se criar, por exemplo, saída separada por
tabulações, que outros programas podem preferir ler.
Para definir a tabulação como separador de campos, deve-se
usar \pset fieldsep '\t'.
O separador de campos padrão é o caractere
'|' (barra vertical).
fieldsep_zero #Define o separador de campos a ser usado no formato de saída não alinhado como o byte zero.
footer #
Se o valor
for especificado, este deverá ser on ou
off, que irá ativar ou desativar mostrar
o rodapé da tabela
(.
Se for omitido o n linhas)valor,
o comando irá alternar entre ativar e desativar mostrar
o rodapé da tabela.
format #
Define o formato de saída como um entre
aligned,
asciidoc,
csv,
html,
latex,
latex-longtable,
troff-ms,
unaligned, ou
wrapped.
São permitidas abreviaturas únicas.
O formato aligned (alinhado) é o formato
de saída de texto padrão, legível por humanos, e bem
formatado; é o formato predefinido.
O formato unaligned (não alinhado) escreve
todas as colunas de uma linha da tabela em uma linha, separadas
pelo separador de campos atualmente ativo.
Serve para criar uma saída destinada a ser lida por outros
programas, por exemplo, no formato separado por tabulação ou
separado por vírgula.
Entretanto, o caractere separador de campos não é tratado
de forma especial se aparecer no valor de uma coluna;
portanto, o formato CSV pode ser mais
adequado para estas finalidades.
O formato csv escreve os valores das colunas
separados por vírgulas, aplicando as regras de delimitação
descritas no
RFC 4180.
Esta saída é compatível com o formato CSV do comando
COPY do servidor.
É gerada uma linha de cabeçalho com os nomes das colunas,
a menos que o parâmetro tuples_only esteja
on.
Os títulos e rodapés não são escritos.
Cada linha é terminada pelo caractere de fim de linha
dependente do sistema, que normalmente é um único caractere de
nova-linha (\n) para os sistemas baseados no
Unix, ou uma sequência
de retorno de carro e nova-linha (\r\n) para
o Microsoft Windows.
Podem ser selecionados caracteres separadores de campo
diferentes da vírgula com \pset csv_fieldsep.
O formato wrapped (quebrado) é como o
aligned (alinhado), mas quebra os valores
de dados grandes nas linhas para fazer com que a saída caiba
na largura da coluna de destino.
A largura do destino é determinada conforme descrito na opção
columns.
Note que o psql não tenta quebrar
os títulos dos cabeçalhos das colunas;
portanto, o formato wrapped irá se comportar
da mesma forma que o formato aligned, se a
largura total necessária para os cabeçalhos de coluna exceder
a largura de destino.
Os formatos asciidoc, html,
latex, latex-longtable, e
troff-ms escrevem tabelas que se destinam
a serem incluídas em documentos usando a respectiva linguagem
de marcação.
Não são documentos completos!
Isto pode não ser necessário no HTML,
mas no LaTeX deve-se ter um
invólucro de documento completo.
O formato latex usa o ambiente
tabular do LaTeX.
O formato latex-longtable requer os pacotes
LaTeX longtable
e booktabs.
linestyle #
Define o estilo de desenho da linha da borda como um entre
ascii, old-ascii, ou
unicode.
São permitidas abreviaturas únicas.
(O que significa que uma letra é o suficiente.)
A definição padrão é ascii.
Esta opção afeta apenas os formatos de saída
aligned e wrapped.
O estilo ascii usa caracteres
ASCII básicos.
As novas linhas nos dados são mostradas usando o símbolo
+ na margem direita.
Quando o formato wrapped quebra os dados
de uma linha para a próxima sem o caractere de nova-linha,
um ponto (.) é mostrado na margem direita
da primeira linha, e novamente na margem esquerda da linha
seguinte.
O estilo old-ascii usa caracteres
ASCII básicos, usando o estilo de formatação
usado no PostgreSQL 8.4 e anteriores.
As novas-linhas nos dados são mostradas usando o símbolo
: no lugar do separador de colunas à esquerda.
Quando os dados são quebrados de uma linha para a próxima sem
o caractere de nova linha, é usado o símbolo
; no lugar do separador de colunas à esquerda.
O estilo unicode usa caracteres de desenho
de caixa Unicode.
As novas-linhas nos dados são mostradas usando o símbolo
de retorno de linha na margem direita.
Quando os dados são quebrados de uma linha para a próxima
sem o caractere de nova-linha, o símbolo de reticências
é mostrado na margem direita da primeira linha, e novamente
na margem esquerda da linha seguinte.
Quando a definição de border é maior que
zero, a opção linestyle também determina
os caracteres com os quais as linhas de borda são desenhadas.
Os caracteres básicos ASCII funcionam em
qualquer lugar, mas os caracteres Unicode ficam melhores em
telas que os reconhecem.
null #
Define a cadeia de caracteres a ser mostrada no lugar de um
valor nulo.
O padrão é não mostrar nada, o que pode ser facilmente
confundido com uma cadeia de caracteres vazia.
Por exemplo, pode-se preferir \pset null
'(nulo)'.
numericlocale #
Se o valor
for especificado, este deverá ser on ou
off, que irá ativar ou desativar a
exibição de um caractere específico de localidade para
separar grupos de dígitos à esquerda do marcador de decimal.
Se for omitido o
valor, o comando
irá alternar entre a saída numérica normal e a específica do
local.
pager #
Controla o uso do programa de paginação da saída das
consultas e da ajuda do psql.
Quando a opção pager está
off, o programa de paginação não é usado.
Quando a opção pager está
on, o programa de paginação é usado quando
apropriado, ou seja, quando a saída é para um terminal e não
cabe na tela.
A opção pager também pode ser definida como
always, o que faz com que o programa de
paginação seja usado para todas as saídas no terminal,
independentemente de caber ou não na tela.
\pset pager sem um
valor alterna
entre ativar e desativar o uso do programa de paginação.
Se a variável de ambiente PSQL_PAGER ou
PAGER estiver definida, a saída a ser paginada
será direcionada para o programa especificado.
Caso contrário, será utilizado um programa padrão dependente
da plataforma (como o more).
Ao usar o comando \watch para executar uma
consulta repetidamente, a variável de ambiente
PSQL_WATCH_PAGER é usada para encontrar o
programa de paginação em sistemas
Unix.
Isto é configurado em separado, porque pode confundir os
paginadores tradicionais., mas pode ser usado para enviar
a saída para ferramentas que entendem o formato de saída do
psql
(tal como o pspg --stream).
pager_min_lines #
Se for definido pager_min_lines com um
número maior que a altura da página, o programa de paginação
não será chamado, a menos que haja pelo menos esta quantidade
de linhas de saída para mostrar.
A definição padrão é 0.
recordsep #Especifica o separador de registro (linha) a ser usado no formato de saída não alinhado. O padrão é o caractere de nova-linha.
recordsep_zero #Define o separador de registro a ser usado no formato de saída não alinhado como o byte zero.
tableattr (ou T) #
No formato HTML, especifica os atributos a
serem colocados dentro do marcador table.
Pode ser, por exemplo, cellpadding ou
bgcolor.
Note que provavelmente não seria bom especificar
border aqui, porque isto já é resolvido
por \pset border.
Se não for fornecido nenhum
valor,
os atributos da tabela terão sua definição removida.
No formato latex-longtable, esta opção
controla a largura proporcional de cada coluna contendo um
tipo de dados alinhado à esquerda.
É especificado como uma lista de valores separados por espaços
em branco, por exemplo, '0.2 0.2 0.6'.
As colunas de saída não especificadas usam o último valor
especificado.
title (ou C) #
Define o título da tabela para todas as tabelas mostradas
posteriormente.
Pode ser usado para fornecer à saída marcadores descritivos.
Se não for fornecido nenhum
valor,
será removida a definição do título.
tuples_only (ou t) #
Se o valor
for especificado, este deverá ser on ou
off, que irá ativar ou desativar o modo
somente-tuplas.
Se for omitido o
valor, o comando
irá alternar entre a saída normal e a de somente-tuplas.
A saída normal inclui informações extras, como cabeçalhos de
coluna, títulos e vários rodapés.
No modo somente-tuplas, apenas os dados da tabela são mostrados.
unicode_border_linestyle #
Define o estilo de desenho da borda para o estilo de linha
unicode como um entre
single ou double.
unicode_column_linestyle #
Define o estilo de desenho da coluna para o estilo de linha
unicode como um entre
single ou double.
unicode_header_linestyle #
Define o estilo de desenho do cabeçalho para o estilo de linha
unicode como um entre
single ou double.
xheader_width #
Define a largura máxima do cabeçalho para saída expandida
para um dos seguintes valores:
full (o valor padrão),
column, page, ou um
valor inteiro.
full: o cabeçalho expandido não é truncado
e terá a mesma largura da linha de saída mais larga.
column: trunca a linha de cabeçalho para
a largura da primeira coluna.
page: trunca a linha de cabeçalho para
a largura do terminal.
valor inteiro:
especifica a largura máxima exata da linha de cabeçalho.
Ilustrações de como estes diferentes formatos se parecem podem ser vistas em Exemplos, abaixo.
Existem vários comandos de atalho para \pset.
Veja \a, \C,
\f, \H,
\t, \T e
\x.
\q ou \quit #Sai do programa psql. Em um arquivo de script, apenas a execução desse script é encerrada.
\qecho texto [ ... ] #
Este comando é idêntico ao \echo, exceto que
a saída será escrita no canal de saída da consulta, conforme
definido por \o.
\r ou \reset #Redefine (limpa) o buffer de consulta.
\restrict chave_de_restrição #
Entre no modo “restrito” com a chave fornecida.
Neste modo, o único meta-comando permitido é
\unrestrict, para sair do modo restrito.
A chave pode conter apenas caracteres alfanuméricos.
Este comando destina-se principalmente ao uso em exportações de texto-puro geradas pelo pg_dump, pg_dumpall e pg_restore, mas pode ser útil em outros contextos.
\s [ nome_do_arquivo ] #
Escreve o histórico da linha de comando do
psql no
nome_do_arquivo.
Se for omitido o
nome_do_arquivo,
o histórico será mostrado na saída padrão
(usando o paginador, se apropriado).
Este meta-comando não estará disponível se o
psql tiver sido construído sem
suporte a Readline.
\set [ nome [ valor [ ... ] ] ] #
Define a variável
nome_da_variável do
psql com o
valor,
ou se mais de um valor for fornecido, como a concatenação de
todos eles.
Se for fornecido apenas um argumento, a variável será definida
com um valor de cadeia de caracteres vazia.
Para remover a definição de uma variável, deve ser usado o
comando \unset.
\set sem nenhum argumento mostra os nomes e
valores de todas as variáveis do psql
definidas no momento.
Os nomes de variáveis válidos podem conter letras, dígitos e sublinhados. Veja Variáveis abaixo para obter detalhes. Os nomes das variáveis diferenciam letras maiúsculas de minúsculas.
Certas variáveis são especiais, porque controlam o comportamento do psql, ou são definidas automaticamente para refletir o estado da conexão. Estas variáveis estão documentadas em Variáveis abaixo.
Este comando não está relacionado ao comando SET do SQL.
\setenv nome [ valor ] #
Define a variável de ambiente
nome_da_variável
com o valor,
ou se não for fornecido o
valor, remove a
definição da variável de ambiente.
\setenv PAGER less \setenv LESS -imx4F
\sf[+] descrição_da_função #
Este meta-comando busca e mostra a definição da função ou
procedimento especificado, na forma de um comando
CREATE OR REPLACE FUNCTION ou
CREATE OR REPLACE PROCEDURE.
A definição é escrita no canal corrente de saída de consulta,
conforme definido por \o.
A função de destino pode ser especificada apenas pelo nome,
ou pelo nome e argumentos, por exemplo,
foo(integer, text).
Devem ser fornecidos os tipos dos argumentos se houver mais
de uma função com o mesmo nome.
Se for apensado o modificador + ao nome do
comando, as linhas de saída serão numeradas, com a primeira
linha do corpo da função sendo a linha 1.
Ao contrário da maioria dos outros meta-comandos,
o restante da linha é sempre considerado argumento(s) de
\sf, e nem a interpolação de variáveis
nem a expansão de acentos grave (`)
são realizadas nos argumentos.
\sv[+] nome_da_visão #
Este meta-comando busca e mostra a definição da visão
especificada, na forma de um comando
CREATE OR REPLACE VIEW.
A definição é escrita no canal de saída de consulta corrente,
conforme definido por \o.
Se for apensado o modificador + ao nome do
comando, então as linhas de saída serão numeradas a partir de 1.
Ao contrário da maioria dos outros meta-comandos,
o restante da linha é sempre considerado argumento(s) de
\sv, e nem a interpolação de variáveis
nem a expansão de acentos grave (`)
são realizadas nos argumentos.
\startpipeline\sendpipeline\syncpipeline\endpipeline\flushrequest\flush\getresults [ número_de_resultados ] #
Este grupo de comandos implementa um fluxo de instruções
SQL.
O fluxo deve começar por \startpipeline
e terminar por \endpipeline.
Entre eles pode haver qualquer número de comandos
\syncpipeline,
que enviam uma mensagem de sincronização
sem interromper o fluxo de dados em andamento e descarregando
o buffer de envio.
No modo de fluxo, as instruções são enviadas ao servidor sem
esperar pelos resultados das instruções anteriores.
Veja Pipeline Mode para obter mais
informações.
Todas as consultas executadas enquanto o fluxo está em
andamento utilizam o protocolo de consulta estendido.
As consultas são apensadas ao fluxo quando terminam com um
ponto e vírgula.
Os meta-comandos \bind,
\bind_named, \close_prepared
e \parse pode ser usados em um fluxo em andamento.
Enquanto o fluxo está em andamento, \sendpipeline
irá apensar o buffer de consulta
corrente ao fluxo.
Outros meta-comandos como \g,
\gx ou \gdesc
não são permitidos no modo de fluxo.
\flushrequest apensa um comando de descarga
ao fluxo, permitindo a leitura de resultados com
\getresults sem executar uma sincronização
ou encerrar o fluxo.
\getresults enviará automaticamente os dados
ainda não enviados para o servidor.
\flush pode ser usado para enviar
manualmente os dados ainda não enviados.
\getresults aceita o parâmetro opcional
número_de_resultados.
Se fornecido, apenas os primeiros
número_de_resultados
resultados pendentes serão lidos.
Se não for fornecido ou for 0,
todos os resultados pendentes serão lidos.
Quando o modo de fluxo está ativo, uma variável de
aviso de comando (prompt)
dedicada fica disponível para informar o status do fluxo.
Veja %P para obter mais
informações.
COPY não tem suporte no modo de fluxo.
Exemplo:
\startpipeline SELECT * FROM pg_class; SELECT 1 \bind \sendpipeline \flushrequest \getresults \endpipeline
\t #
Alterna a exibição de cabeçalhos de nome de coluna de saída, e
rodapé de contagem de linha.
Equivale a \pset tuples_only, sendo fornecido
apenas por conveniência.
\T opções_de_tabela #
Especifica os atributos a serem colocados no marcador
table no formato de saída
HTML.
Equivale a \pset tableattr
.
opções_de_tabela
\timing [ on | off ] #Com um parâmetro, ativa ou desativa a exibição de quanto tempo cada instrução SQL levou para executar. Sem parâmetro, alterna a exibição entre ativada e desativada. A exibição é em milissegundos; intervalos maiores que 1 segundo também são mostrados no formato minutos:segundos, com campos de horas e dias adicionados, se necessário.
\unrestrict chave_de_restrição #
Sair do modo “restrito” (ou seja, onde todos os
outros meta-comandos estão bloqueados), desde que a chave
especificada corresponda àquela fornecida em
\restrict quando o modo restrito foi ativado.
Este comando destina-se principalmente ao uso em exportações de texto-puro geradas pelo pg_dump, pg_dumpall e pg_restore, mas pode ser útil em outros contextos.
\unset nome #
Remove a definição da variável (exclui)
nome_da_variável do
psql.
Grande parte das variáveis que controlam o comportamento do
psql não podem perder sua definição;
sendo assim, o comando \unset é interpretado
como as configurando para seus valores padrão.
Veja Variáveis abaixo.
\w ou \write nome_do_arquivo\w ou \write |comando #
Escreve o buffer de consulta
corrente no arquivo
nome_do_arquivo,
ou canaliza para o
comando
do interpretador de comandos (shell).
Se o buffer de consulta corrente
estiver vazio, será escrita a consulta executada mais recentemente.
Se o argumento começar com uma barra vertical
(|), então o restante da linha será
considerado o
comando a ser
executado, e nem a interpolação de variáveis nem a expansão de
acentos grave (`) são executadas nesta parte.
O restante da linha é simplesmente passado literalmente para
o interpretador de comandos.
\warn texto [ ... ] #
Este comando é idêntico ao \echo, exceto que
a saída é escrita no canal de erro padrão do
psql, em vez de na saída padrão.
\watch [ i[nterval]=segundos ] [ c[ount]=times ] [ m[in_rows]=rows ] [ segundos ] #
Executa repetidamente o buffer
de consulta corrente (como \g faz) até ser
interrompido, ou a consulta falhar, ou o limite de contagem
de execuções (se houver) for atingido, ou a consulta deixar
de retornar o número mínimo de linhas.
Aguarda o número de segundos especificado (por padrão 2)
entre as execuções.
O tempo de espera padrão pode ser alterado pela variável
WATCH_INTERVAL.
Para manter a compatibilidade com as versões anteriores,
segundos pode ser
especificado com ou sem o prefixo interval=".
Cada resultado da consulta é mostrado com um cabeçalho que
inclui a cadeia de caracteres \pset title
(se houver), a hora de início da consulta e o intervalo de atraso.
Se o buffer de consulta corrente estiver vazio, será executada novamente a consulta enviada mais recentemente.
\x [ on | off | auto ] #
Define ou alterna o modo expandido de formatação de tabela.
Como tal, equivale a \pset expanded.
\z[Sx] [ padrão ] #
Lista as tabelas, visões e sequências,
com seus privilégios de acesso associados.
Se o padrão
for especificado, serão listadas apenas as tabelas, visões
e sequências onde os nomes correspondem ao padrão.
Por padrão, apenas os objetos criados pelo usuário são mostrados;
Deve ser fornecido o padrão ou o modificador S
para incluir os objetos do sistema.
Se for apensado o modificador x ao nome do
comando, os resultados serão listados no modo expandido.
Este é um alias para \dp
(“display privileges”).
\! [ comando ] #
Sem argumento, sai para uma
sub-shell
(interpretador de comandos);
O psql retorna quando a
sub-shell é encerrada.
Com um argumento, executa o
comando
do interpretador de comandos.
Ao contrário da maioria dos outros meta-comandos,
o restante da linha é sempre considerado argumento(s) de
\!, e nem a interpolação de variáveis
nem a expansão de acentos grave (`) são executadas
nos argumentos.
O restante da linha é simplesmente passado literalmente para o
interpretador de comandos.
\? [ tópico ] #
Mostra informações de ajuda.
O parâmetro opcional
tópico
(por padrão commands) seleciona qual parte
do psql é explicada:
commands descreve os meta-comandos de
contrabarra do psql;
options descreve as opções de linha de comando
que podem ser passadas para o psql; e
variables mostra ajuda sobre a configuração
das variáveis do psql.
\; #Contrabarra ponto-e-vírgula não é um meta-comando da mesma forma que os comandos anteriores; em vez disso, simplesmente faz com que um ponto e vírgula seja adicionado ao buffer de consulta sem nenhum processamento adicional.
Normalmente, o psql envia o comando SQL para o servidor assim que atinge o ponto e vírgula no final do comando, mesmo que existam mais entradas na linha corrente. Assim, por exemplo, entrar com
select 1; select 2; select 3;
irá resultar no envio individual dos três comandos
SQL ao servidor, com os resultados de cada
um sendo mostrado antes de prosseguir para o próximo comando.
Entretanto, o ponto-e-vírgula inserido como \;
não aciona o processamento do comando, de modo que o comando
antes dele e o seguinte possam ser efetivamente combinados
e enviados ao servidor em uma única requisição.
Então, por exemplo,
select 1\; select 2\; select 3;
resulta no envio dos três comandos SQL para
o servidor em uma única requisição, quando o ponto e vírgula
sem contrabarra é atingido.
O servidor executa esta requisição como uma única transação,
a menos que haja comandos
BEGIN/COMMIT explícitos
incluídos na cadeia de caracteres para dividi-la em várias
transações.
(Veja Seção 54.2.2.1 para
obter mais detalhes sobre como o servidor lida com cadeia
de caracteres de várias consultas.)
Os vários comandos \d aceitam o parâmetro
padrão para especificar
os nomes dos objetos a serem mostrados.
No caso mais simples, o padrão é apenas o nome exato de um objeto.
Os caracteres dentro do padrão são normalmente convertidos em letras
minúsculas, assim como nos nomes SQL;
por exemplo, \dt FOO irá mostrar a tabela chamada
foo.
Como nos nomes SQL, colocar aspas
(") em torno do padrão interrompe a conversão
em letras minúsculas.
Se for necessário incluir o caractere aspas em um padrão, este
deverá ser escrito como um par de aspas ("")
numa cadeia de caracteres entre aspas; novamente, isto está em acordo
com as regras para identificadores SQL entre aspas.
Por exemplo, \dt "FOO""BAR" irá mostrar a tabela
chamada FOO"BAR (e não foo"bar).
Ao contrário das regras normais para os nomes do SQL,
pode-se envolver entre aspas apenas uma parte do padrão,
por exemplo, \dt FOO"FOO"BAR irá mostrar a tabela
chamada fooFOObar.
Sempre que o parâmetro
padrão é omitido
inteiramente, os comandos \d mostram todos os
objetos visíveis no caminho de procura de esquema corrente —
equivale a usar o * como o padrão.
(Um objeto é considerado visível, se o esquema
que o contém estiver no caminho de procura, e nenhum objeto do mesmo
tipo e nome aparecer anteriormente no caminho de procura.
Isto equivale a declarar que os objetos podem ser referenciados
pelo nome sem a qualificação explícita do esquema.)
Para ver todos os objetos no banco de dados, independentemente da
visibilidade, deve ser usado *.* como padrão.
Em um padrão, o * corresponde a qualquer
sequência de caracteres (incluindo nenhum caractere),
e ? corresponde a qualquer um único caractere.
(Esta notação é comparável aos padrões de nome de arquivo do
interpretador de comandos do
Unix.)
Por exemplo, \dt int* mostra as tabelas onde os
nomes começam com int.
Mas entre aspas, o * e o ?
perdem estes significados especiais, sendo apenas correspondidos
literalmente.
Um padrão de relação contendo um ponto (.),
é interpretado como um padrão de nome de esquema seguido por
um padrão de nome de objeto.
Um padrão de esquema contendo um ponto (.),
é interpretado como um nome de banco de dados seguido por um
padrão de nome de esquema.
Por exemplo, \dt foo*.*bar* mostra todas as
tabelas onde o nome de tabela inclui bar, e
estão em esquemas onde o nome começa com foo.
Quando não aparece nenhum ponto, o padrão corresponde apenas aos
objetos visíveis no caminho de procura de esquema corrente.
Novamente, o ponto entre aspas perde seu significado especial,
sendo correspondido literalmente.
Um padrão de relação contendo dois pontos (.),
é interpretado como um nome de banco de dados, seguido por um
padrão de nome de esquema, seguido por um padrão de nome de objeto.
A parte do nome do banco de dados não é tratada como um padrão,
devendo corresponder ao nome do banco de dados que se está conectado,
caso contrário, será relatado um erro.
Um padrão de esquema contendo um ponto (.),
é interpretado como um nome de banco de dados seguido por um padrão
de nome de esquema.
Por exemplo, \dn mydb.*foo* mostra todos os
esquemas onde o nome inclui foo.
A parte do nome do banco de dados não é tratada como um padrão,
devendo corresponder ao nome do banco de dados que se está conectado,
caso contrário, será relatado um erro.
Os usuários avançados podem usar notações de expressão regular, como
classes de caracteres, por exemplo, [0-9] para
corresponder a qualquer dígito.
Todos os caracteres especiais de expressão regular funcionam conforme
especificado em Expressões regulares POSIX, exceto para
o ., usado como separador conforme mencionado
acima, o *, traduzido para a notação de
expressão regular .*, o
?, traduzido para ., e o
$ que corresponde literalmente.
Pode-se emular estes caracteres do padrão conforme necessário,
escrevendo ? para .,
( para
R+|), ou
R*( para
R|).
O R?$ não é necessário como um caractere de expressão
regular, porque o padrão deve corresponder ao nome inteiro,
ao contrário da interpretação usual de expressões regulares
(em outras palavras, o $ é adicionado
automaticamente ao padrão).
Deve ser escrito um * no início e/ou no final
do padrão, se não se desejar que o padrão seja ancorado.
Note que entre aspas, todos os caracteres especiais de expressão
regular perdem seus significados especiais, sendo correspondidos
literalmente.
Além disso, os caracteres especiais da expressão regular são
correspondidos literalmente nos padrões de nome de operador
(ou seja, o argumento de \do).
O psql fornece recursos de substituição de variáveis semelhantes aos dos interpretadores de comandos (shells) comuns do Unix. As variáveis são simplesmente pares nome/valor, onde o valor pode ser qualquer cadeia de caracteres de qualquer comprimento. O nome deve consistir em letras (incluindo letras não latinas), dígitos e sublinhados.
Para definir uma variável, é usado o meta-comando
\set do psql.
Por exemplo,
\set foo bar
define a variável foo com o valor
bar.
Para recuperar o conteúdo da variável, o nome deve ser precedido
por dois pontos (:). Por exemplo:
\echo :foo
bar
Isto funciona tanto nos comandos SQL regulares, quanto nos meta-comandos; há mais detalhes em Interpolação SQL, abaixo.
Se \set for chamado sem o segundo argumento,
a variável será definida como o valor de cadeia de caracteres vazia.
Para remover a definição (ou seja, excluir) uma variável, deve ser
usado o comando \unset.
Para mostrar os valores de todas as variáveis, deve-se usar
\set sem nenhum argumento.
Os argumentos de \set estão sujeitos às mesmas
regras de substituição dos outros comandos.
Assim pode-se construir referências interessantes como
\set :foo 'alguma_coisa' e obter
“ligações simbólicas”
(soft links) ou “variáveis de variáveis”
(variable variables) do Perl ou do
PHP, respectivamente.
Infelizmente (ou felizmente?), não há como se fazer nada de útil
com estas construções.
Por outro lado, \set bar :foo é uma forma
perfeitamente válida de copiar uma variável.
Várias dessas variáveis são tratadas de forma especial pelo psql. Elas representam certas configurações de opções que podem ser alteradas em tempo de execução, alterando o valor da variável ou, em alguns casos, representam um estado alterável do psql. Por convenção, todos os nomes das variáveis tratadas especialmente consistem inteiramente de letras ASCII maiúsculas (e possivelmente dígitos e sublinhados). Para garantir a compatibilidade máxima no futuro, deve-se evitar usar estes nomes de variáveis para propósitos particulares.
As variáveis que controlam o comportamento do
psql geralmente não podem ter sua
definição removida, ou serem definidas com valores inválidos.
O comando \unset é permitido,
mas é interpretado como as configurando com seus valores padrão.
O comando \set sem o segundo argumento é
interpretado como configurando a variável como on,
para variáveis de controle que aceitam este valor,
sendo rejeitado para as demais.
Além disso, as variáveis de controle que aceitam os valores
on e off também aceitam
outras grafias comuns de valores booleanos, como
true e false.
As variáveis tratadas de forma especial são:
AUTOCOMMIT
#
Quando está on (o padrão), cada comando
SQL é efetivado automaticamente após
a conclusão bem-sucedida.
Neste modo, para adiar a efetivação deve-se introduzir o comando
SQL BEGIN ou
START TRANSACTION.
Quando está off, ou não definido, os comandos
SQL não são efetivados até que se introduza
explicitamente o comando COMMIT ou
END.
O modo sem autoefetivação
(autocommit-off) funciona
introduzindo um comando BEGIN implícito,
imediatamente antes de qualquer comando que não esteja em um
bloco de transação, e não seja um BEGIN,
ou outro comando de controle de transação, nem um comando que
não possa ser executado em um bloco de transação
(como o VACUUM).
No modo sem autoefetivação, deve-se interromper explicitamente
qualquer transação com falha digitando ABORT
ou ROLLBACK.
Também deve-se ter em mente que, se a sessão for encerrada
sem efetivar antes, o trabalho será perdido.
O modo com autoefetivação
(autocommit-on)
é o comportamento tradicional do
PostgreSQL, mas o modo sem
autoefetivação está mais próximo da especificação
do padrão SQL.
Se for preferido o modo sem autoefetivação, pode-se
configurá-lo no arquivo psqlrc global,
ou no arquivo ~/.psqlrc do usuário.
COMP_KEYWORD_CASE #
Determina se serão usadas letras maiúsculas ou minúsculas ao
completar uma palavra-chave do SQL.
Se definida como lower ou
upper, a palavra será completada com letras
minúsculas ou maiúsculas, respectivamente.
Se definido como preserve-lower ou
preserve-upper (o padrão), a palavra será
completada conforme a parte já digitada, mas palavras sendo
completadas sem nada digitado, as opções estarão em letras
minúsculas ou maiúsculas, respectivamente.
DBNAME #O nome do banco de dados ao qual se está conectado no momento. É definida toda vez que se conecta a um banco de dados (incluindo a inicialização do programa), mas pode ser alterada ou ter a definição removida.
ECHO #
Se definida como all, todas as linhas de
entrada não vazias serão escritas na saída padrão à medida
que são lidas. (Não se aplica a linhas lidas interativamente.)
Para selecionar este comportamento na inicialização do programa,
deve ser usada a opção -a.
Se for definida como queries, o
psql escreve cada consulta na saída
padrão à medida que é enviada ao servidor.
A opção para selecionar este comportamento é -e.
Se definida como errors, apenas as consultas
com falha serão escritas na saída de erro padrão.
A opção para selecionar este comportamento é -b.
Se definida como none (o padrão), nenhuma
consulta será mostrada.
ECHO_HIDDEN #
Quando esta variável está definida como on,
e um meta-comando de contrabarra consulta o banco de dados,
a consulta é mostrada primeiro.
Este recurso ajuda a estudar os componentes internos do
PostgreSQL, para fornecer
funcionalidade semelhante em seus próprios programas.
(Para selecionar este comportamento na inicialização do
programa, de ser usada a opção -E.)
Se esta variável for definida com o valor
noexec, as consultas serão apenas mostradas,
não sendo realmente enviadas ao servidor para execução.
O valor padrão é off.
ENCODING #
A codificação corrente do conjunto de caracteres do cliente.
É definida toda vez que se conecta a um banco de dados
(incluindo a inicialização do programa), e quando se altera
a codificação com \encoding, mas pode ser
alterada ou ter a definição removida.
ERROR #
true se a última consulta
SQL falhou, ou false
se foi bem-sucedida.
Veja também SQLSTATE.
FETCH_COUNT #
Se esta variável for definida com um valor inteiro maior que zero,
os resultados das consultas SELECT serão
buscados e mostrados em grupos dessas tantas linhas, em vez do
comportamento padrão de coletar todo o conjunto de resultados
antes de mostrar.
Portanto, apenas uma quantidade limitada de memória é usada,
independentemente do tamanho do conjunto de resultados.
As configurações de 100 a 1000 são comumente usadas ao ativar
este recurso.
Deve-se ter em mente que, ao usar este recurso, uma consulta
pode falhar após já ter mostrado algumas linhas.
Embora se possa usar qualquer formato de saída com este recurso,
o formato aligned padrão tende a parecer ruim,
porque cada grupo de linhas FETCH_COUNT será
formatado separadamente, levando a larguras de coluna diferentes
entre os grupos de linhas.
Os outros formatos de saída funcionam melhor.
HIDE_TABLEAM #
Se esta variável estiver definida como true,
os detalhes do método de acesso da tabela não serão mostrados.
Serve principalmente para testes de regressão.
HIDE_TOAST_COMPRESSION #
Se esta variável estiver definida como true,
os detalhes do método de compressão da coluna não serão mostrados.
Serve principalmente para testes de regressão.
HISTCONTROL #
Se esta variável estiver definida como
ignorespace, as linhas que começam com
espaço não serão inseridas na lista de histórico.
Se definida como ignoredups, as linhas que
correspondem à linha anterior do histórico não serão inseridas.
O valor ignoreboth combina as duas opções.
Se definida como none (o padrão), todas as
linhas lidas no modo interativo serão salvas na lista de histórico.
Esta funcionalidade foi descaradamente plagiada do Bash.
HISTFILE #
O nome do arquivo que será usado para armazenar a lista de
histórico.
Se não estiver definida, o nome do arquivo será obtido da
variável de ambiente PSQL_HISTORY.
Se também não estiver definida, o padrão será
~/.psql_history, ou
%APPDATA%\postgresql\psql_history no
Windows.
Por exemplo, colocar
\set HISTFILE ~/.psql_history-:DBNAME
no arquivo ~/.psqlrc, fará com que o
psql mantenha um histórico separado
para cada banco de dados.
Esta funcionalidade foi descaradamente plagiada do Bash.
HISTSIZE #O número máximo de comandos a serem armazenados no histórico de comandos (por padrão, 500). Se definida com um valor negativo, nenhum limite será aplicado.
Esta funcionalidade foi descaradamente plagiada do Bash.
HOST #O hospedeiro do servidor de banco de dados ao qual se está conectado no momento. É definida toda vez que se conecta a um banco de dados (incluindo a inicialização do programa), mas pode ser alterada ou ter a definição removida.
IGNOREEOF #Se definida como 1 ou menos, enviar o caractere EOF (geralmente Control+D) para uma sessão interativa do psql irá encerrar a aplicação. Se definida com um valor numérico maior, esta quantidade de caracteres EOF consecutivos devem ser digitados para encerrar uma sessão interativa. Se a variável estiver definida como um valor não numérico, ela será interpretada como 10. O padrão é 0.
Esta funcionalidade foi descaradamente plagiada do Bash.
LASTOID #
O valor do último OID afetado, conforme retornado por um comando
INSERT ou \lo_import.
Esta variável só tem garantia de validade até que o resultado
do próximo comando SQL tenha sido mostrado.
Os servidores PostgreSQL desde a
versão 12 não dão mais suporte às colunas do sistema OID,
portanto LASTOID sempre será 0 após o comando
INSERT ao usar estes servidores.
LAST_ERROR_MESSAGELAST_ERROR_SQLSTATE #
A mensagem de erro principal, e o código
SQLSTATE associado, para a consulta com
erro mais recente na sessão corrente do
psql, ou uma cadeia de caracteres
vazia e 00000, se nenhum erro ocorreu na
sessão corrente.
ON_ERROR_ROLLBACK
#
Quando definida como on, se uma instrução
em um bloco de transação produzir um erro, o erro será ignorado
e a transação continuará.
Quando definida como interactive, estes erros
são ignorados nas sessões interativas, mas não durante a
leitura de arquivos de script.
Quando definida como off (o padrão), uma
instrução em um bloco de transação que gera um erro interrompe
toda a transação.
O modo de reversão de erro funciona enviando um comando
SAVEPOINT implícito logo antes de cada
comando que está em um bloco de transação e, em seguida,
revertendo para o ponto de salvamento se o comando falhar.
ON_ERROR_STOP #
Por padrão, o processamento dos comandos continua após um erro.
Quando esta variável é definida como on,
o processamento irá parar imediatamente.
No modo interativo, o psql retornará
ao aviso de comando; caso contrário, o
psql sairá, retornando o código
de erro 3 para distinguir este caso das condições de erro fatal,
que são relatadas usando o código de erro 1.
Nos dois casos, quaisquer scripts atualmente em execução
(o script de nível superior, se houver, e quaisquer outros
scripts que possam ter sido chamados) serão encerrados
imediatamente.
Se a cadeia de caracteres de comando de nível superior contiver
vários comandos SQL, o processamento será
interrompido no comando corrente.
PIPELINE_COMMAND_COUNT #Número de comandos enfileirados em um fluxo em andamento.
PIPELINE_RESULT_COUNT #
Número de comandos enfileirados em um fluxo em andamento
que foram seguidos por um \flushrequest
ou um \syncpipeline, forçando o servidor
a enviar os resultados.
Estes resultados podem ser obtidos com
\getresults.
PIPELINE_SYNC_COUNT #Número de mensagens de sincronização enfileiradas em um fluxo em andamento
PORT #A porta do servidor de banco de dados à qual se está conectado no momento. É definida toda vez que se conecta a um banco de dados (incluindo a inicialização do programa), mas pode ser alterada ou ter a definição removida.
PROMPT1PROMPT2PROMPT3 #Especificam como devem ser os avisos de comando do psql. Veja Aviso de comando (prompt) abaixo.
QUIET #
Definir esta variável como on equivale
à opção de linha de comando -q.
Provavelmente não é muito útil no modo interativo.
ROW_COUNT #O número de linhas retornadas ou afetadas pela última consulta SQL, ou 0 se a consulta falhou ou não relatou uma contagem de linhas.
SERVER_VERSION_NAMESERVER_VERSION_NUM #
O número da versão do servidor como uma cadeia de caracteres,
por exemplo, 9.6.2, 10.1,
ou 11beta1, e na forma numérica, por exemplo,
90602 ou 100001.
São definidas toda vez que se conecta a um banco de dados
(incluindo a inicialização do programa), mas podem ser alteradas
ou terem a definição removida.
SERVICE #O nome do serviço, se aplicável.
SHELL_ERROR #
true se o último comando do
interpretador de comandos falhou,
false se foi bem sucedido.
Isto se aplica a comandos do interpretador de comandos
chamados por meio dos meta-comandos \!,
\g, \o,
\w e \copy,
bem como a expansão de acentos grave (`).
Note que, para \o, esta variável é atualizada
quando o fluxo de saída é fechado pelo próximo comando
\o.
Veja também SHELL_EXIT_CODE.
SHELL_EXIT_CODE #
O código de saída retornado pelo último comando do
interpretador de comandos:
0–127 representam códigos de saída do programa,
128–255 indicam término por meio de um sinal
e -1 indica falha ao iniciar um programa ou ao coletar seu
status de saída.
Isto se aplica a comandos do interpretador de comandos
chamados por meio dos meta-comandos \!,
\g, \o,
\w e \copy,
bem como a expansão de acentos grave (`).
Note que, para \o, esta variável é atualizada
quando o fluxo de saída é fechado pelo próximo comando
Veja também SHELL_ERROR.
SHOW_ALL_RESULTS #
Quando esta variável está definida como off,
apenas o último resultado de uma consulta combinada
(\;) é mostrado em vez de todos eles.
O padrão é on.
O comportamento off serve para manter a
compatibilidade com versões mais antigas do
psql.
SHOW_CONTEXT #
Esta variável pode ser definida com os valores
never, errors ou
always
para controlar se os campos CONTEXT são
mostrados nas mensagens do servidor.
O padrão é errors (significando que o
contexto será mostrado nas mensagens de erro, mas não nas
mensagens de aviso ou de advertência).
Esta definição não tem efeito quando VERBOSITY
está definido como terse ou
sqlstate.
(Veja também \errverbose, para seu uso quando
se desejar uma versão detalhada do erro que acabou de ser
recebido.)
SINGLELINE #
Definir esta variável como on equivale
à opção de linha de comando -S.
SINGLESTEP #
Definir esta variável como on equivale
à opção de linha de comando -s.
SQLSTATE #
O código de erro (veja Códigos de erro do PostgreSQL)
associado à falha da última consulta SQL,
ou 00000 se foi bem-sucedida.
USER #O usuário do banco de dados com o qual se está conectado no momento. É definida toda vez que se conecta a um banco de dados (incluindo a inicialização do programa), mas pode ser alterada ou ter a definição removida.
VERBOSITY #
Esta variável pode ser definida com os valores
default, verbose,
terse, ou sqlstate para
controlar a verbosidade dos relatos de erro.
(Veja também \errverbose, para usar quando
se desejar uma versão detalhada do erro que acabou de ser
recebido.)
VERSIONVERSION_NAMEVERSION_NUM #
Estas variáveis são definidas na inicialização do programa, para
refletir a versão do psql como uma
cadeia de caracteres detalhada, uma cadeia de caracteres curta
(por exemplo, 9.6.2, 10.1,
ou 11beta1), e um número (por exemplo,
90602 ou 100001),
respectivamente.
Podem ser alteradas, ou terem a definição removida.
WATCH_INTERVAL #
Esta variável define o intervalo padrão, em segundos, que o
comando \watch aguarda entre a execução das
consultas.
O valor padrão é de 2 segundos.
Especificar um intervalo no comando se sobrepõe esta variável.
Uma funcionalidade chave das variáveis do
psql é que se pode substituí-las
(“interpolar”) nas instruções SQL
regulares, bem como nos argumentos dos meta-comandos.
Além disso, o psql fornece facilidades
para garantir que os valores de variáveis usados como literais e
identificadores SQL sejam devidamente delimitados.
A sintaxe para interpolar um valor não delimitado é preceder o
nome da variável com dois-pontos (:).
Por exemplo,
\set foo 'minha_tabela' SELECT * FROM :foo;
iria consultar a tabela minha_tabela.
Veja que isto pode não ser seguro: o valor da variável é copiado
literalmente, portanto pode conter aspas não balanceadas, ou até
mesmo comandos de contrabarra.
É necessário ter certeza de que faz sentido no local onde é colocado.
Quando o valor deve ser usado como um literal ou identificador SQL, é mais seguro fazer com que seja colocado delimitado. Para delimitar o valor de uma variável como um literal SQL, deve ser escrito dois-pontos seguidos do nome da variável entre apóstrofos. Para delimitar o valor como um identificador SQL, deve ser escrito dois-pontos seguidos do nome da variável entre aspas. Estas construções lidam corretamente com as aspas e outros caracteres especiais incorporados ao valor da variável. O exemplo anterior seria escrito com mais segurança dessa forma:
\set foo 'minha_tabela' SELECT * FROM :"foo";
A interpolação de variáveis não será efetuada dentro de literais
e identificadores SQL delimitados.
Portanto, uma construção como ':foo' não funciona
para produzir um literal delimitado a partir do valor de uma variável
(e seria inseguro se funcionasse, já que não lidaria corretamente
com delimitadores incorporados ao valor).
Um exemplo de uso desse mecanismo é copiar o conteúdo de um arquivo em uma coluna da tabela. Primeiro, o arquivo deve ser carregado em uma variável, e depois interpolado o valor da variável como uma cadeia de caracteres delimitada:
\set content `cat my_file.txt` INSERT INTO minha_tabela VALUES (:'content');
(Note que esta construção não irá funcionar se o arquivo
meu_arquivo.txt contiver bytes nulos
(\0x00).
O psql não oferece suporte a bytes nulos
incorporados em valores de variáveis.)
Como os dois-pontos podem aparecer legalmente em comandos
SQL, uma aparente tentativa de interpolação
(ou seja, :nome, :'nome', ou
:"nome") não é substituído, a menos que a
variável especificada esteja definida no momento.
Em todo caso, pode-se preceder os dois-pontos com uma
contrabarra para protegê-lo de substituição.
A sintaxe especial
:{? retorna
nome}TRUE ou FALSE, dependendo
se a variável existe ou não, portanto, é sempre substituída,
a menos que os dois-pontos seja precedido por uma contrabarra.
A sintaxe de dois-pontos para variáveis, faz parte do padrão SQL para linguagens de consulta incorporadas, como o ECPG. As sintaxes de dois-pontos para partes de matriz e conversões de tipo de dados são extensões do PostgreSQL, que às vezes podem entrar em conflito com o uso padrão. A sintaxe de dois-pontos aspas para fazer o escape do valor de uma variável como um literal ou identificador SQL é uma extensão psql.
Os avisos de comando do psql podem ser
personalizados conforme a preferência do usuário.
As três variáveis PROMPT1,
PROMPT2 e PROMPT3 contêm
cadeias de caracteres e sequências especiais de escape que
descrevem a aparência do aviso de comando.
O PROMPT1 é o aviso de comando normal mostrado
quando o psql solicita um novo comando.
O PROMPT2 é mostrado quando são esperadas mais
entradas durante a entrada do comando, por exemplo, porque o comando
não foi encerrado com um ponto-e-vírgula ou uma aspas não foi fechada.
O PROMPT3 é mostrado quando se está executando
o comando SQL COPY FROM STDIN,
e é necessário digitar um valor de linha no terminal.
O valor da variável de aviso de comando selecionada é mostrado
literalmente, exceto onde é encontrado um sinal de porcentagem
(%).
Dependendo do próximo caractere, algum outro texto é colocado
em seu lugar.
As substituições definidas são:
%M #
O nome completo do hospedeiro (com o nome do domínio) do
servidor de banco de dados, ou [local]
se a conexão for por um soquete de domínio
Unix, ou
[local:,
se o soquete de domínio
Unix
não estiver compilado no local padrão.
/dir/nome]
%m #
O nome do hospedeiro do servidor de banco de dados, truncado
no primeiro ponto, ou [local] se a conexão
for por um soquete de domínio
Unix.
%> #O número da porta na qual o servidor de banco de dados está escutando.
%n #
O nome de usuário da sessão do banco de dados.
(A expansão desse valor pode mudar durante uma sessão de
banco de dados como resultado do comando
SET SESSION AUTHORIZATION.)
%s #O nome do serviço.
%/ #O nome do banco de dados corrente.
%~ #
Como %/, mas a saída será o símbolo
~ (til), se o banco de dados for o banco
de dados padrão.
%# #
Se o usuário da sessão for um superusuário de banco de dados,
então será o símbolo #, caso contrário,
será o símbolo >.
(A expansão desse valor pode mudar durante uma sessão de
banco de dados como resultado do comando
SET SESSION AUTHORIZATION.)
%p #O ID do processo servidor que se está conectado no momento.
%P #
O estado do fluxo:
off quando não está no modo de fluxo,
on quando o fluxo está em andamento ou
abort quando o fluxo foi interrompido.
%R #
No PROMPT1 normalmente o símbolo
=, mas pode ser o símbolo @,
se a sessão estiver em uma ramificação inativa de um bloco
condicional, ou pode ser o símbolo ^, se estiver
no modo de linha única, ou pode ser o símbolo !,
se a sessão estiver desconectada do servidor de banco de dados
(o que pode acontecer se \connect falhar).
No PROMPT2, %R
é substituído por um caractere que depende do motivo pelo qual
o psql espera mais entrada:
O símbolo -, se o comando simplesmente ainda
não foi terminado, o símbolo *, se houver
um comentário /* ... */ não terminado, um
apóstrofo, se houver uma cadeia de caracteres entre apóstrofos
não terminada, uma aspa, se houver um identificador entre aspas
não terminado, um cifrão, se houver uma cadeia de caracteres
entre cifrões não terminada, ou (, se houver
um parêntese esquerdo que não corresponde.
No PROMPT3, %R não produz
nada.
%x #
Estado da transação: uma cadeia de caracteres vazia quando não
estiver em um bloco de transação, ou * quando
em um bloco de transação, ou ! quando em um
bloco de transação falhado, ou ? quando o
estado da transação é indeterminado
(por exemplo, porque não há conexão).
%l #
O número da linha dentro da instrução corrente, começando em
1.
%dígitos #O caractere com o código octal indicado é substituído.
%:nome: #
O valor da variável
nome_da_variável do
psql.
Veja Variáveis, acima, para obter
detalhes.
%`comando` #
A saída do comando,
semelhante à expansão de acentos grave (`) comum.
%[ ... %] #
Os avisos de comando podem conter caracteres de controle do
terminal que, por exemplo, alteram a cor, o plano de fundo,
ou o estilo do texto do aviso de comando, ou alteram o título
da janela do terminal.
Para que os recursos de edição de linha do
Readline funcionem corretamente,
estes caracteres de controle não imprimíveis devem ser
designados como invisíveis, envolvendo-os com
%[ e %].
Podem ocorrer vários pares desses caracteres dentro do aviso
de comando. Por exemplo:
\set PROMPT1 '%[%033[1;33;40m%]%n@%/%R%[%033[0m%]%# '
resulta em aviso de comando negrito (1;),
amarelo sobre preto (33;40), em terminais
com capacidade de cores compatíveis com o
VT100.
%w #
Espaço em branco da mesma largura que a saída mais recente de
PROMPT1.
Pode ser usado como uma configuração de PROMPT2,
de modo que as instruções de várias linhas sejam alinhadas com
a primeira linha, mas não haja nenhum aviso de comando secundário
visível.
Para inserir o sinal de porcentagem no aviso de comando, deve ser
escrito %%.
Os avisos de comando padrão são '%/%R%x%# ' para
o PROMPT1 e o PROMPT2,
e '>> ' para o PROMPT3.
Esta funcionalidade foi descaradamente plagiada do tcsh.
O psql usa o Readline ou a biblioteca libedit, se estiver disponível, para facilitar a edição e recuperação das linhas. O histórico de comandos é salvo automaticamente quando o psql é encerrado e é recarregado quando o psql é iniciado. Deve ser pressionada a seta para cima ou pressionado Ctrl+P para recuperar as linhas anteriores.
Também pode-se usar a função de autocompletar com a tecla
Tab para preencher palavras-chave parcialmente
digitadas e nomes de objetos SQL em muitos
(mas não em todos) os contextos.
Por exemplo, no início de um comando, pressionar ins
e pressionar TAB preencherá insert into.
Em seguida, digitando alguns caracteres do nome de uma tabela ou
esquema e pressionando TAB o sistema preencherá
o nome incompleto, ou oferecerá um menu com possíveis complementos
quando houver mais de uma opção.
(Dependendo da biblioteca em uso, poderá ser necessário pressionar
TAB mais de uma vez para obter um menu.)
O recurso de autocompletar nomes de objetos SQL
usando a tecla Tab requer o envio de consultas
ao servidor para encontrar possíveis correspondências.
Em alguns contextos, isto pode interferir em outras operações.
Por exemplo, após o BEGIN
Será tarde demais para submeter
SET TRANSACTION ISOLATION LEVEL
se uma consulta de autocompletar com a tecla Tab
foi submetida neste meio tempo.
Se não for desejado o recurso de autocompletar com a tecla
Tab, pode-se desativá-lo permanentemente
adicionando o seguinte conteúdo ao arquivo chamado
.inputrc no diretório raiz:
$if psql set disable-completion on $endif
(Isto não é uma funcionalidade do psql, mas sim do Readline. Leia sua documentação para obter mais detalhes.)
A opção de linha de comando -n
(--no-readline) pode ser útil para desativar
o uso do Readline para uma única
execução de psql.
Isto impede o preenchimento automático com a tecla
Tab, o uso ou registro do histórico da linha
de comando e a edição de comandos com várias linhas.
É particularmente útil quando se precisa copiar e colar texto
que contém caracteres de tabulação (TAB).
COLUMNS #
Se \pset columns for zero, controla a largura
para o formato wrapped e a largura para
determinar se a saída expandida requer o paginador, ou deve ser
alternada para o formato vertical no modo automático expandido.
PGDATABASEPGHOSTPGPORTPGUSER #Parâmetros de conexão padrão (veja Variáveis de ambiente).
PG_COLOR #
Especifica se devem ser usadas cores nas mensagens de diagnóstico.
Os valores possíveis são always,
auto e never.
PSQL_EDITOREDITORVISUAL #
Editor usado pelos comandos \e,
\ef, e \ev.
Estas variáveis são examinadas na ordem mostrada acima;
Será usada a primeira que estiver definida.
Se nenhuma delas estiver definida, o padrão é usar o
vi nos sistemas
Unix, e o
notepad.exe nos sistemas
Windows.
PSQL_EDITOR_LINENUMBER_ARG #
Quando \e, \ef ou
\ev é usado com um argumento de número de linha,
esta variável especifica o argumento de linha de comando usado
para passar o número da linha inicial para o editor do usuário.
Para editores como o Emacs ou o
vi, este é um sinal de adição.
Deve ser incluído um espaço à direita no valor da variável,
se for necessário haver espaço entre o nome da opção e o número
da linha. Exemplos:
PSQL_EDITOR_LINENUMBER_ARG='+' PSQL_EDITOR_LINENUMBER_ARG='--line '
O padrão é o sinal + nos sistemas
Unix
(correspondendo ao editor padrão vi,
e útil para muitos outros editores comuns);
mas não há padrão nos sistemas
Windows.
PSQL_HISTORY #
Local alternativo para o arquivo de histórico de comandos.
É realizada a expansão do til (~).
PSQL_PAGERPAGER #
Se os resultados de uma consulta não couberem na tela, eles serão
paginados por meio desse comando.
Os valores típicos são more e
less.
O uso do paginador pode ser desativado configurando
PSQL_PAGER ou PAGER como uma
cadeia de caracteres vazia, ou ajustando as opções do meta-comando
\pset relacionadas ao paginador.
Estas variáveis são examinadas na ordem mostrada acima;
será usada a primeira que estiver definida.
Se nenhum delas estiver definida, o padrão é usar
more na maioria das plataformas,
mas usar less no
Cygwin.
PSQL_WATCH_PAGER #
Quando uma consulta é executada repetidamente com o comando
\watch, não é usado um paginador por padrão.
Este comportamento pode ser alterado definindo
PSQL_WATCH_PAGER para um comando de paginação,
em sistemas Unix.
O paginador pspg (que não faz parte do
PostgreSQL, mas está disponível em
muitas distribuições de software de código aberto) pode mostrar
a saída de \watch se iniciado com a opção
--stream.
PSQLRC #
Local alternativo do arquivo .psqlrc do usuário.
É realizada a expansão do til (~).
SHELL #
Comando executado pelo meta-comando \!.
TMPDIR #
Diretório para armazenar os arquivos temporários.
O padrão é /tmp.
Este utilitário, como a maioria dos outros utilitários do PostgreSQL, também usa as variáveis de ambiente com suporte pela libpq (veja Variáveis de ambiente).
psqlrc e ~/.psqlrc #
A não ser que seja passada a opção -X, o
psql tenta ler e executar os comandos
do arquivo de inicialização de todo o sistema
(psqlrc)
e, em seguida, o arquivo de inicialização pessoal do usuário
(~/.psqlrc), após a conexão com o banco de
dados, e antes de aceitar os comandos normais.
Estes arquivos podem ser usados para configurar o cliente e/ou
o servidor a gosto do usuário, normalmente com os comandos
\set e SET.
[188]
O arquivo de inicialização de todo o sistema se chama
psqlrc.
Por padrão, ele é buscado no diretório de configuração do sistema
da instalação, que é identificado de forma mais confiável executando
o seguinte comando: pg_config --sysconfdir.
Normalmente, este diretório será ../etc/,
relativo ao diretório que contém os executáveis do
PostgreSQL.
O diretório de busca pode ser definido explicitamente através da
variável de ambiente PGSYSCONFDIR.
O arquivo de inicialização pessoal do usuário é se chama
.psqlrc e está localizado no diretório raiz
do usuário que está executando o comando.
No Windows, o arquivo de
inicialização pessoal se chama
%APPDATA%\postgresql\psqlrc.conf.
Nos dois casos, este caminho de arquivo padrão pode ser sobreposto
definindo a variável de ambiente PSQLRC.
Tanto o arquivo de inicialização do sistema quanto o arquivo de
inicialização pessoal do usuário podem ser específicos para a
versão do psql adicionando um hífen
e o identificador da versão principal ou secundária do
PostgreSQL ao nome do arquivo como,
por exemplo ~/.psqlrc-18 ou
~/.psqlrc-18.1.
O arquivo que corresponder à versão mais específica será lido em
preferência a um arquivo que não seja específico da versão.
Estes sufixos de versão são adicionados após a determinação do
caminho do arquivo, conforme explicado acima.
.psql_history #
O histórico da linha de comando é armazenado no arquivo
~/.psql_history, ou em
%APPDATA%\postgresql\psql_history no
Windows.
O local do arquivo de histórico pode ser definido explicitamente
através da variável HISTFILE do
psql ou da variável de ambiente
PSQL_HISTORY.
O psql funciona melhor com servidores
da mesma versão, ou de uma versão principal mais antiga.
Os comandos de contrabarra provavelmente irão falhar se o servidor
for de uma versão mais recente do que o próprio
psql.
Entretanto, os comandos de contrabarra da família
\d devem funcionar com servidores de versões
anteriores à 7.4, embora não necessariamente com servidores mais
recentes que o próprio psql.
A funcionalidade geral de executar comandos SQL
e mostrar os resultados da consulta também deve funcionar com
servidores de uma versão principal mais recente, mas isto não
pode ser garantido em todos os casos.
Se for desejado usar o psql para se conectar a vários servidores de diferentes versões principais, é recomendável usar a versão mais recente do psql. Como alternativa, pode-se manter uma cópia do psql de cada versão principal, e usar a versão que corresponde ao respectivo servidor. Mas, na prática, esta complicação adicional não deve ser necessária.
Antes do PostgreSQL 9.6, a opção
-c implicava -X
(--no-psqlrc); este não é mais o caso.
Antes do PostgreSQL 8.4, o psql permitia que o primeiro argumento de um comando de contrabarra de uma única letra começasse logo após o comando, sem espaço em branco. Agora, é necessário ao menos um espaço em branco.
O psql é construído como uma “aplicação de console”. Como as janelas de console do Windows usam uma codificação diferente do restante do sistema, deve-se tomar um cuidado especial ao usar caracteres de 8 bits no psql. Se o psql detectar uma página de código de console problemática, será avisado na inicialização. Para alterar a página de código da console, são necessárias duas coisas:
Definir a página de código digitando
cmd.exe /c chcp 1252.
(1252 é a página de código apropriada para a Europa Ocidental
- ANSI Latin 1; podendo ser substituído pelo valor apropriado.)
Se estiver sendo usado o Cygwin, este comando poderá ser colocado
no arquivo /etc/profile.
Definir o fonte da console como Lucida Console,
porque o fonte
raster não funciona com uma página de código ANSI.
O primeiro exemplo mostra como dividir um comando por várias linhas de entrada. Note a mudança no aviso de comando:
testdb=> CREATE TABLE minha_tabela (
testdb(> primeiro integer not null default 0,
testdb(> segundo text)
testdb-> ;
CREATE TABLE
Vejamos então como ficou a definição da tabela:
testdb=> \d minha_tabela
Tabela "public.minha_tabela"
Coluna | Tipo | Ordenação | Pode ser nulo | Padrão
----------+---------+-----------+---------------+--------
primeiro | integer | | not null | 0
segundo | text | | |
Agora vamos mudar o aviso de comando para algo mais interessante:
testdb=> \set PROMPT1 '%n@%m %~%R%# ' peter@localhost testdb=>
Supondo que se tenha preenchido a tabela com dados, vamos dar uma olhada nela:
peter@localhost testdb=> SELECT * FROM minha_tabela;
primeiro | segundo
----------+---------
1 | um
2 | dois
3 | três
4 | quatro
(4 linhas)
As tabelas podem ser mostradas de diferentes maneiras usando o
meta-comando \pset:
peter@localhost testdb=> \pset border 2
O estilo da borda é 2.
peter@localhost testdb=> SELECT * FROM minha_tabela;
+----------+---------+ | primeiro | segundo | +----------+---------+ | 1 | um | | 2 | dois | | 3 | três | | 4 | quatro | +----------+---------+ (4 linhas)
peter@localhost testdb=> \pset border 0
O estilo da borda é 0.
peter@localhost testdb=> SELECT * FROM minha_tabela;
primeiro segundo
-------- -------
1 um
2 dois
3 três
4 quatro
(4 linhas)
peter@localhost testdb=> \pset border 1 O estilo da borda é 1. peter@localhost testdb=> \pset format csv O formato de saída é csv. peter@localhost testdb=> \pset tuples_only Somente-tuplas está ativado. peter@localhost testdb=> SELECT primeiro, segundo FROM minha_tabela;
1,um 2,dois 3,três 4,quatro
peter@localhost testdb=> \pset format unaligned O formato de saída é unaligned. peter@localhost testdb=> \pset fieldsep '\t' O separador de campos é " ". peter@localhost testdb=> SELECT segundo, primeiro FROM minha_tabela;
um 1 dois 2 três 3 quatro 4
Como alternativa, podem ser usados comandos curtos:
peter@localhost testdb=> \a \t \x O formato de saída é aligned. Somente-tuplas está desativado. A exibição expandida está ativada. peter@localhost testdb=> SELECT * FROM minha_tabela;
-[ RECORD 1 ]---- primeiro | 1 segundo | um -[ RECORD 2 ]---- primeiro | 2 segundo | dois -[ RECORD 3 ]---- primeiro | 3 segundo | três -[ RECORD 4 ]---- primeiro | 4 segundo | quatro
Além disso, estas opções de formato de saída podem ser definidas para
apenas uma consulta usando \g:
peter@localhost testdb=> SELECT * FROM minha_tabela peter@localhost testdb-> \g (format=aligned tuples_only=off expanded=on)
-[ RECORD 1 ]---- primeiro | 1 segundo | um -[ RECORD 2 ]---- primeiro | 2 segundo | dois -[ RECORD 3 ]---- primeiro | 3 segundo | três -[ RECORD 4 ]---- primeiro | 4 segundo | quatro
A seguir está um exemplo de uso do comando \df
para mostrar apenas as funções com nomes que corresondem a
int*pl e onde o segundo argumento é do
tipo de dados bigint, sendo apensado o modificador
x para mostrar os resultados no modo expandido:
testdb=> \dfx int*pl * bigint
Lista de funções -[ RECORD 1 ]----------------+----------------- Esquema | pg_catalog Nome | int28pl Tipo de dados do resultado | bigint Tipo de dados dos argumentos | smallint, bigint Tipo | func -[ RECORD 2 ]----------------+----------------- Esquema | pg_catalog Nome | int48pl Tipo de dados do resultado | bigint Tipo de dados dos argumentos | integer, bigint Tipo | func -[ RECORD 3 ]----------------+----------------- Esquema | pg_catalog Nome | int8pl Tipo de dados do resultado | bigint Tipo de dados dos argumentos | bigint, bigint Tipo | func
A seguir, é apensado o modificador + para mostrar
informações adicionais sobre uma dessas funções, além do modificador
x para mostrar os resultados no modo expandido:
testdb=> \df+x int*pl integer bigint
-[ RECORD 1 ]----------------+----------------------------- Esquema | pg_catalog Nome | int48pl Tipo de dados do resultado | bigint Tipo de dados dos argumentos | integer, bigint Tipo | func Volatilidade | imutável Paralelo | seguro Dono | postgres Segurança | chamador Leakproof? | não Privilégios de acesso | Linguagem | internal Nome interno | int48pl Descrição | implementation of + operator
Quando apropriado, os resultados da consulta podem ser mostrados em
uma representação cruzada usando o comando
\crosstabview:
testdb=> SELECT primeiro, segundo, primeiro > 2 AS gt2 FROM minha_tabela;
primeiro | segundo | gt2
----------+---------+-----
1 | um | f
2 | dois | f
3 | três | t
4 | quatro | t
(4 linhas)
testdb=> \crosstabview primeiro segundo
primeiro | um | dois | três | quatro
----------+----+------+------+--------
1 | f | | |
2 | | f | |
3 | | | t |
4 | | | | t
(4 linhas)
Este segundo exemplo mostra uma tabela de multiplicação com linhas ordenadas em ordem numérica inversa e colunas com uma ordem numérica independente e crescente.
testdb=> SELECT t1.primeiro as "A", t2.primeiro+100 AS "B", testdb-> t1.primeiro*(t2.primeiro+100) as "AxB", testdb-> row_number() over(order by t2.primeiro) AS ord testdb-> FROM minha_tabela t1 CROSS JOIN minha_tabela t2 testdb-> ORDER BY 1 DESC testdb-> \crosstabview "A" "B" "AxB" ord
A | 101 | 102 | 103 | 104 ---+-----+-----+-----+----- 4 | 404 | 408 | 412 | 416 3 | 303 | 306 | 309 | 312 2 | 202 | 204 | 206 | 208 1 | 101 | 102 | 103 | 104 (4 linhas)
Exemplo 159. Exemplo do tradutor
Acesso remoto
Neste exemplo o psql acessa o banco de dados cristina da usuária cristina no servidor 192.168.3.6, o mesmo usado em Exemplo da visão foreign_server_options.
$ psql --username=cristina --dbname=cristina --host=192.168.3.6
Senha para o usuário cristina:
psql (18.3 (Debian 18.3-1.pgdg12+1), servidor 17.9 (Debian 17.9-1.pgdg13+1))
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384,
compression: desativado, ALPN: postgresql)
Digite "help" para obter ajuda.
cristina=> SELECT inet_server_addr();
inet_server_addr ------------------ 192.168.3.6 (1 linha)
cristina=> \conninfo
Connection Information
Parâmetro | Valor
----------------------+------------------------
Banco de dados | cristina
Client User | cristina
Host | 192.168.3.6
Server Port | 5432
Opções |
Protocol Version | 3.0
Password Used | true
GSSAPI Authenticated | false
Backend PID | 6027
SSL Connection | true
SSL Library | OpenSSL
SSL Protocol | TLSv1.3
SSL Key Bits | 256
SSL Cipher | TLS_AES_256_GCM_SHA384
SSL Compression | false
ALPN | postgresql
Superuser | off
Hot Standby | off
(18 linhas)
cristina=> \dt
List of tables
Esquema | Nome | Tipo | Dono
---------+--------+--------+----------
public | pessoa | tabela | cristina
(1 linha)
[186] Here Document é um bloco de código de propósito especial, que utiliza uma forma de redirecionamento de E/S para fornecer uma lista de comandos a um programa interativo ou a um comando. (N. T.)
[187] Crosstab é a situação em que se exige que os resultados da tabela ou consulta sejam rotacionados no sentido de levar os dados que estão presentes nas colunas a serem mostrados de maneira horizontal, e os dados que estão presentes nas linhas da tabela a ser representado no formato vertical. EDUCBA – Introduction to SQL Crosstab (N. T.)
[188] O arquivo de inicialização não é criado durante a instalação do PostgreSQL, devendo ser criado pelo administrador do banco de dados ou pelo usuário. (N. T.)