psql

psql — terminal interativo do PostgreSQL

Sinopse

psql [opção...] [nome_do_banco_de_dados [nome_do_usuário]]

Descrição

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.

Opções

-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 < nome_do_arquivo. Em geral, as duas farão o que se espera, mas usar -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.

Nota

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.

Código de saída

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.

Utilização

Conexão com o banco de dados

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.

Entrada de comandos SQL

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.

Meta-comandos

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 :'nome_da_variável' 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 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 :nome_da_variável, onde nome_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 :'nome_da_variável' 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.

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 título. (O nome desse comando vem de caption, porque anteriormente era usado apenas para definir o título em uma tabela HTML.)

\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.

Dica

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 contador 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 \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.

Dica

Outra forma de obter o mesmo resultado que \copy ... to é usar o comando COPY .. TO STDOUT do SQL, e terminá-lo com \g nome_do_arquivo ou \g |programa. Diferentemente de \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 (`).

Dica

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.

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.

Nota

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.

Cuidado

\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.

Dica

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).

Dica

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.

Dica

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.

Nota

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.

Nota

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.

Dica

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.

Exclui do banco de dados o objeto grande com o OID igual a oid_de_objeto_grande.

Dica

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.

Dica

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 :sobrenome
Fagundes 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.

Se o valor for especificado, este deverá ser on ou off, que irá ativar ou desativar mostrar o rodapé da tabela (n linhas). Se for omitido o 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.

Dica

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.

Nota

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.)

Padrões

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 ., (R+|) para R*, ou (R|) para R?. O $ 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).

Funcionalidades avançadas

Variáveis

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.

Nota

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).

Nota

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.

Nota

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.

Dica

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.

Nota

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.

Nota

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.

Nota

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.

Nota

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_MESSAGE
LAST_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.

PROMPT1
PROMPT2
PROMPT3 #

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_NAME
SERVER_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.)

VERSION
VERSION_NAME
VERSION_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.

Interpolação SQL

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 :{?nome} retorna 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.

Aviso de comando (prompt)

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:/dir/nome], se o soquete de domínio Unix não estiver compilado no local padrão.

%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.

Nota

Esta funcionalidade foi descaradamente plagiada do tcsh.

Edição de linha de comando

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).

Variáveis de ambiente

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.

PGDATABASE
PGHOST
PGPORT
PGUSER #

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_EDITOR
EDITOR
VISUAL #

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_PAGER
PAGER #

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).

Arquivos

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.

Notas

  • 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.

Notas para usuários do Windows

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.

Exemplos

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.)