Uso de SnowSQL

Este tópico descreve como usar o SnowSQL, incluindo iniciar/parar o cliente, usar comandos e variáveis no cliente e outras informações gerais de uso.

Neste tópico:

Execução de comandos

Em uma sessão do Snowflake, você pode emitir comandos para tomar ações específicas. Todos os comandos no SnowSQL começam com um ponto de exclamação (!), seguido pelo nome do comando.

Por exemplo:

user#> !help

+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+
| Command    | Use                                       | Aliases     | Description                                                                                |
|------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------|
| !abort     | !abort <query id>                         |             | Abort a query                                                                              |
| !connect   | !connect <connection_name>                |             | Create a new connection                                                                    |
| !define    | !define <variable>=<value>                |             | Define a variable as the given value                                                       |
| !edit      | !edit <query>                             |             | Opens up a text editor. Useful for writing longer queries. Defaults to last query          |
| !exit      | !exit                                     | !disconnect | Drop the current connection                                                                |
| !help      | !help                                     | !helps, !h  | Show the client help.                                                                      |
| !options   | !options                                  | !opts       | Show all options and their values                                                          |
| !pause     | !pause                                    |             | Pauses running queries.                                                                    |
| !print     | !print <message>                          |             | Print given text                                                                           |
| !queries   | !queries help, <filter>=<value>, <filter> |             | Lists queries matching the specified filters. Write <!queries> help for a list of filters. |
| !quit      | !quit                                     | !q          | Drop all connections and quit SnowSQL                                                      |
| !rehash    | !rehash                                   |             | Refresh autocompletion                                                                     |
| !result    | !result <query id>                        |             | See the result of a query                                                                  |
| !set       | !set <option>=<value>                     |             | Set an option to the given value                                                           |
| !source    | !source <filename>, <url>                 | !load       | Execute given sql file                                                                     |
| !spool     | !spool <filename>, off                    |             | Turn on or off writing results to file                                                     |
| !system    | !system <system command>                  |             | Run a system command in the shell                                                          |
| !variables | !variables                                | !vars       | Show all variables and their values                                                        |
+------------+-------------------------------------------+-------------+--------------------------------------------------------------------------------------------+
Copy

Para uma descrição detalhada de cada comando, consulte Referência de comandos (neste tópico).

Uso de variáveis

Você pode usar variáveis para armazenar e reutilizar valores em uma sessão do Snowflake. As variáveis permitem usar valores definidos pelo usuário e de banco de dados em consultas.

As próximas seções explicam como definir e utilizar variáveis:

Definição de variáveis

Você pode definir variáveis para o SnowSQL de várias maneiras:

Definição de variáveis antes da conexão (arquivo de configuração)

Para definir variáveis antes de conectar-se ao Snowflake, adicione as variáveis no arquivo de configuração config:

  1. Abra o arquivo de configuração do SnowSQL (chamado config) em um editor de texto. A localização padrão do arquivo é:

    Linux/macOS:

    ~/.snowsql/

    Windows:

    %USERPROFILE%\.snowsql\

    Nota

    Você pode mudar o local padrão especificando o sinalizador de linha de comando --config path ao iniciar o SnowSQL.

  1. Na seção [variables], defina quaisquer variáveis que você planeja utilizar:

    [variables]
    <variable_name>=<variable_value>
    
    Copy

    Onde:

    • variable_name é uma cadeia de caracteres alfanuméricos (que não diferencia maiúsculas e minúsculas) que representa o nome da variável.

    • variable_value é uma cadeia que representa o valor da variável. Se necessário, a cadeia de caracteres pode estar entre aspas simples ou duplas.

    Por exemplo:

    [variables]
    tablename=CENUSTRACKONE
    
    Copy

Definição de variáveis durante a conexão (sinalizador de linha de comando -D ou --variable)

Para definir variáveis durante a conexão ao Snowflake, na linha de comando do terminal, especifique o sinalizador de linha de comando -D ou --variable. Para o argumento deste sinalizador, especifique o nome e o valor da variável na forma de variable_name=variable_value.

Por exemplo:

Linux/macOS:
$ snowsql ... -D tablename=CENUSTRACKONE --variable db_key=$DB_KEY
Copy
Windows:
$ snowsql ... -D tablename=CENUSTRACKONE --variable db_key=%DB_KEY%
Copy

No exemplo acima:

  • -D define uma variável chamada tablename como CENUSTRACKONE.

  • --variable atribui uma variável do Snowflake chamada db_key para a variável de ambiente DB_KEY.

Definição de variáveis dentro de uma sessão (comando !define)

Para definir uma variável após a conexão com Snowflake, execute o comando !define na sessão.

Por exemplo:

user#> !define tablename=CENUSTRACKONE
Copy

Habilitação da substituição de variáveis

Para permitir que o SnowSQL substitua os valores das variáveis, defina a opção de configuração variable_substitution como true de uma das seguintes maneiras:

  • Para definir esta opção antes de iniciar o SnowSQL, abra o arquivo de configuração do SnowSQL em um editor de texto e defina esta opção na seção [options]:

    [options]
    variable_substitution = True
    
    Copy
  • Para definir esta opção ao iniciar o SnowSQL, especifique o sinalizador de linha de comando -o:

    $ snowsql ... -o variable_substitution=true
    
    Copy
  • Para definir esta opção em uma sessão do SnowSQL, execute o comando !set na sessão:

    user#> !set variable_substitution=true
    
    Copy

    Nota

    Atualmente não há opção para remover um valor de opção, tal como a opção variable_substitution. Se você precisar desativar a substituição de variáveis, execute o comando !set variable_substitution=false.

Substituição de variáveis em uma sessão

Depois que você habilitar a substituição de variáveis, pode usar variáveis nas instruções SQL.

Para usar uma variável em uma instrução, use a sintaxe &variable_name. Observe que os nomes das variáveis não fazem distinção entre maiúsculas e minúsculas. Por exemplo:

user#> !define snowshell=bash

user#> !set variable_substitution=true

user#> select '&snowshell';

+--------+
| 'BASH' |
|--------|
| bash   |
+--------+
Copy

Se a opção variable_substitution não estiver ativada, não ocorre nenhuma substituição de variável. Por exemplo:

user#> !define snowshell=bash

user#> !set variable_substitution=false

user#> select '&snowshell';

+--------------+
| '&SNOWSHELL' |
|--------------|
| &snowshell   |
+--------------+
Copy

Se você se referir a uma variável que não foi definida, o SnowSQL exibe um erro. Por exemplo:

select '&z';

Variable z is not defined
Copy

Para combinar uma variável com texto, inclua a referência da variável entre chaves. Por exemplo:

user#> !define snowshell=bash

user#> !set variable_substitution=true

select '&{snowshell}_shell';

+--------------+
| 'BASH_SHELL' |
|--------------|
| bash_shell   |
+--------------+
Copy

Para usar um sinal de E comercial sem usar substituição, escape o sinal de E comercial com um segundo sinal idêntico:

&&variable

Por exemplo:

user#> !set variable_substitution=true

user#> select '&notsubstitution';

Variable notsubstitution is not defined

user#> select '&&notsubstitution';

+--------------------+
| '&NOTSUBSTITUTION' |
|--------------------|
| &notsubstitution   |
+--------------------+
Copy

Listagem de variáveis

Para listar variáveis, execute o comando !variables ou !vars na sessão:

user#> !variables

+-----------+-------+
| Name      | Value |
|-----------+-------|
| snowshell | bash  |
+-----------+-------+
Copy

Uso das variáveis internas

O SnowSQL inclui um conjunto de variáveis internas que retornam metadados sobre instruções executadas na sessão atual do usuário.

Cada um desses nomes de variáveis começa com dois caracteres de sublinhado (“__”).

__rowcount

Retorna o número de linhas afetadas pela mais recente instrução DML executada pelo usuário.

user#> insert into a values(1),(2),(3);

+-------------------------+
| number of rows inserted |
|-------------------------|
|                       3 |
+-------------------------+
3 Row(s) produced. Time Elapsed: 0.950s

user#> !set variable_substitution=true

user#> select &__rowcount;

+---+
| 3 |
|---|
| 3 |
+---+
Copy
__sfqid

Retorna a ID para a consulta mais recente executada pelo usuário.

user#> !set variable_substitution=true

user#> select * from a;

user#> select '&__sfqid';

+----------------------------------------+
| 'A5F35B56-49A2-4437-BA0E-998496CE793E' |
|----------------------------------------|
| a5f35b56-49a2-4437-ba0e-998496ce793e   |
+----------------------------------------+
Copy

Uso do preenchimento automático

Várias funções SQL, nomes de tabelas e variáveis são armazenadas no SnowSQL e preenchidas automaticamente em modo interativo. Para selecionar uma sugestão de preenchimento automático, pressione a tecla Tab. Para escolher uma sugestão diferente, use as teclas e para destacar a opção desejada e pressione Tab.

Para desativar o preenchimento automático interativamente, defina a opção de configuração auto_completion para False no arquivo de configuração.

Visualização de seu histórico de linha de comando

Seu histórico recente da linha de comando pode ser recuperado usando a tecla . Pressione a tecla repetidamente para passar pelo buffer.

Arquivo de histórico

O arquivo de histórico interativo da linha de comando é chamado history e está localizado em ~/.snowsql/history.

Execução de scripts em lote

Você pode executar scripts em lote de duas maneiras:

  • Usando parâmetros de conexão (enquanto se conecta ao Snowflake)

  • Execução de comandos (na linha de comando na sessão Snowflake)

Execução durante a conexão (parâmetro de conexão -f)

Para executar um script SQL enquanto se conecta ao Snowflake, use o parâmetro de conexão -f <nome_do_arquivo_de_entrada>.

Um arquivo de saída para o script pode ser especificado usando -o output_file=<nome_do_arquivo_de_saída>. Além disso, você pode usar -o quiet=true para desativar a saída padrão e -o friendly=false as mensagens de inicialização e saída.

Por exemplo:

snowsql -a myorganization-myaccount -u jsmith -f /tmp/input_script.sql -o output_file=/tmp/output.csv -o quiet=true -o friendly=false -o header=false -o output_format=csv
Copy

Para obter mais informações sobre todos os parâmetros de conexão, consulte Referência de parâmetros de conexão.

Execução em uma sessão (comando !source ou !load)

Para executar um script SQL após a conexão ao Snowflake, execute o comando !source (ou !load) na sessão.

Por exemplo:

user#> !source example.sql
Copy

Exportação de dados

A consulta de saída resulta em um arquivo em um formato definido usando as seguintes opções de configuração:

  • output_format=output_format

  • output_file=output_filename

Para remover o texto de abertura, o texto de cabeçalho, o tempo e a mensagem de despedida da saída, defina também as seguintes opções:

  • friendly=false

  • header=false

  • timing=false

Como em todas as opções de configuração, você pode defini-las usando qualquer um dos seguintes métodos:

  • No arquivo de configuração (antes de conectar ao Snowflake).

  • Usando o parâmetro de conexão -o ou --options (enquanto se conecta ao Snowflake).

  • Executando o comando !set (na linha de comando na sessão Snowflake).

Observe que consultas consecutivas são anexadas ao arquivo de saída. Alternativamente, para redirecionar a saída da consulta para um arquivo e substituir o arquivo com cada nova instrução, use o sinal de maior que (>) em um script.

No exemplo a seguir, o SnowSQL se conecta a uma conta usando uma conexão nomeada e consulta uma tabela. A saída é escrita em um arquivo CSV com o nome output_file.csv no diretório local atual:

Linux/macOS:

snowsql -c my_example_connection -d sales_db -s public -q 'select * from mytable limit 10' -o output_format=csv -o header=false -o timing=false -o friendly=false  > output_file.csv
Copy
Windows:

snowsql -c my_example_connection -d sales_db -s public -q "select * from mytable limit 10" -o output_format=csv -o header=false -o timing=false -o friendly=false  > output_file.csv
Copy

Alteração do formato do prompt SnowSQL

O prompt SnowSQL exibe dinamicamente informações de contexto sobre a sessão atual:

  • Quando você entra no Snowflake, o prompt exibe seu nome de usuário, bem como o warehouse padrão, o banco de dados e o esquema (se os padrões tiverem sido definidos).

  • Se você usar um comando USE na sessão para definir ou alterar o warehouse, banco de dados ou esquema, o prompt muda imediatamente para refletir o contexto.

Você pode controlar a aparência e a estrutura do prompt usando a opção de configuração prompt_format e um token Pygments entre parênteses para cada tipo de objeto, na forma de [token] (por exemplo, [user] ou [warehouse]).

O token afeta o prompt a partir de agora. Você pode mudar a ordem e a cor para cada token, assim como os delimitadores entre tokens.

Como em todas as opções de configuração, você pode definir o prompt usando qualquer um dos seguintes métodos:

  • No arquivo de configuração (antes de conectar ao Snowflake).

  • Usando o parâmetro de conexão -o ou --options (enquanto se conecta ao Snowflake).

  • Executando o comando !set (na linha de comando na sessão Snowflake).

Nota

Se você alterar o prompt usando o parâmetro de conexão ou diretamente na linha de comando, a alteração se aplica somente à sessão atual. Para preservar a mudança em sessões futuras, defina a opção no arquivo de configuração.

Tokens com suporte

O SnowSQL suporta os seguintes tipos de objetos como tokens:

  • user

  • account

  • role

  • database

  • schema

  • warehouse

Prompt padrão

O prompt padrão do SnowSQL usa os seguintes tokens e estrutura:

[user]#[warehouse]@[database].[schema]>
Copy

Por exemplo:

jdoe#DATALOAD@BOOKS_DB.PUBLIC>
Copy

Exemplo de prompt

Continuando o exemplo acima, o seguinte comando !set executado na linha de comando adiciona o token de função e muda a ordem dos tokens para user e role, database e schema, depois warehouse. Também muda o delimitador para cada token para um ponto (.) e define os tokens para usar cores diferentes:

jdoe#DATALOAD@BOOKS_DB.PUBLIC> !set prompt_format=[#FF0000][user].[role].[#00FF00][database].[schema].[#0000FF][warehouse]>
Copy

Este exemplo resulta no seguinte prompt para a sessão:

Formato do prompt SnowSQL

Desconexão do Snowflake e interrupção do SnowSQL

O SnowSQL fornece comandos separados para:

  • Sair de conexões individuais (ou seja, sessões) sem parar o SnowSQL.

  • Sair do SnowSQL, o que também encerra automaticamente todas as conexões.

Para sair de uma conexão/sessão, use o comando !exit (ou seu alias, !disconnect). Você pode se conectar novamente usando !connect <nome_da_conexão> se puder definir múltiplas conexões no arquivo SnowSQL config. Note que, se você tiver apenas uma conexão aberta, o comando !exit também fecha/para o SnowSQL.

Para sair de todas as conexões e depois fechar/parar o SnowSQL, use o comando !quit (ou seu alias, !q). Você também pode digitar CTRL + d no teclado.

Códigos de saída

Há vários códigos de saída possíveis que são retornados quando o SnowSQL fecha:

0:

Tudo correu bem.

1:

Algo deu errado com o cliente.

2:

Algo deu errado com os argumentos da linha de comando.

3:

O SnowSQL não pôde entrar em contato com o servidor.

4:

O SnowSQL não conseguiu se comunicar adequadamente com o servidor.

5:

A opção de configuração exit_on_error foi definida e o SnowSQL fechou por causa de um erro.

Vinculações de chave padrão

Tab

Aceita a sugestão atual de preenchimento automático.

CTRL + d

Fecha/para o SnowSQL.

Referência de comandos

!abort

Anula uma consulta (especificada pela ID de consulta). A ID da consulta pode ser obtida da página History Guia Histórico na interface da Web.

Por exemplo:

user#> !abort 77589bd1-bcbf-4ec8-9ebc-6c949b00614d;
Copy

!connect

O SnowSQL suporta várias sessões (ou seja, conexões) com !connect <nome_da_conexão>:

  • Os parâmetros/opções de conexão associados a connection_name são armazenados na seção correspondente [connections.<nome_da_conexão>] no arquivo de configuração SnowSQL.

  • Se um parâmetro/opção não for especificado na seção [connections.<nome_da_conexão>], o parâmetro não especificado será o padrão para os parâmetros sob [connections].

Ao conectar, a conexão é adicionada à sua pilha de conexões, e a saída o retornará à sua conexão anterior. Fechar encerrará todas as suas conexões, não importa quantas conexões você tenha.

Por exemplo:

Arquivo de configuração:

[connections.my_example_connection]
...
Copy

Linha de comando:

user#> !connect my_example_connection
Copy

!define

Define uma variável para um valor especificado, usando o seguinte formato:

!define <nome_da_variável>=<valor_da_variável>

O nome e o valor devem ser separados por um único =, sem espaços. Os caracteres válidos que podem ser usados na variável são:

0-9a-zA-Z_

Para obter mais informações sobre a definição e utilização de variáveis, consulte Uso de variáveis.

!edit

Abre o editor que foi definido usando o parâmetro de conexão editor (se nenhum editor foi definido, o padrão é vim). O comando aceita uma consulta como um argumento. Se nenhum argumento for passado, abre-se a última consulta que foi feita.

Nota

Você deve salvar antes ou ao sair do editor, ou então qualquer texto que tenha sido inserido/modificado no editor não será salvo.

!exit, !disconnect

Descarta a conexão atual e fecha o SnowSQL se for a última conexão.

!help, !helps, !h

Exibe a ajuda para os comandos SnowSQL.

!options, !opts

Retorna uma lista de todas as opções de configuração do SnowSQL e seus valores atualmente definidos. Estas opções podem ser definidas usando o comando !set na sessão SnowSQL atual.

Nota

Estas opções também podem ser definidas no arquivo de configuração para SnowSQL ou como parâmetros de conector na linha de comando ao chamar o SnowSQL.

!pause

Pausa consultas em andamento. Pressione a tecla Return para continuar.

!print

Imprime o texto especificado para a tela e quaisquer arquivos que você estiver reproduzindo no momento.

Por exemplo:

user#> !print Include This Text
Copy

!queries

Lista todas as consultas que correspondem aos filtros especificados. Os filtros padrão são session e amount=25, que retornam as 25 consultas mais recentes na sessão atual.

Por exemplo:

  • Retornar as 25 consultas mais recentes que foram feitas nesta sessão atual:

    !queries session
    
    Copy
  • Retornar as 20 consultas mais recentes na conta:

    !queries amount=20
    
    Copy
  • Retornar as 20 consultas mais recentes na conta que levaram mais de 200 milissegundos para serem executadas:

    !queries amount=20 duration=200
    
    Copy
  • Retornar as 25 consultas mais recentes que foram feitas no warehouse especificado:

    !queries warehouse=mywh
    
    Copy

Este comando cria uma variável para cada ID de consulta retornada. Note que a substituição de variáveis deve estar habilitada para que você possa usar essas variáveis. Por exemplo:

user#> !queries session

+-----+--------------------------------------+----------+-----------+----------+
| VAR | QUERY ID                             | SQL TEXT | STATUS    | DURATION |
|-----+--------------------------------------+----------+-----------+----------|
| &0  | acbd6778-c68c-4e79-a977-510b2d8c08f1 | select 1 | SUCCEEDED |       19 |
+-----+--------------------------------------+----------+-----------+----------+

user#> !result &0

+---+
| 1 |
|---|
| 1 |
+---+

user#> !result acbd6778-c68c-4e79-a977-510b2d8c08f1

+---+
| 1 |
|---|
| 1 |
+---+
Copy

!quit , !q (também CTRL + d)

Descarta todas as conexões e sai do SnowSQL.

!rehash

Sincroniza novamente os tokens de preenchimento automático.

O uso normal não requer repetir a sincronização dos tokens de preenchimento automático. Entretanto, forçar uma atualização dos tokens do lado do servidor pode ser útil em certos cenários (por exemplo, se uma nova função definida pelo usuário for criada em uma sessão diferente).

!result

Retorna o resultado de uma consulta concluída (especificado pela ID da consulta). As IDs de consulta podem ser obtidas na página History Guia Histórico da interface da Web ou usando o comando !queries.

Se a consulta ainda estiver em execução, o comando espera até que a consulta seja concluída.

Por exemplo:

user#> !result 77589bd1-bcbf-4ec8-9ebc-6c949b00614d;
Copy

!set

Define a opção de configuração do SnowSQL especificada para um determinado valor usando o formato <opção>=<valor>.

Note que atualmente não há opção para remover um valor de opção. Para alterar o valor de uma opção, execute novamente o comando !set com o valor desejado.

Por exemplo:

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 1000              |
 ...
+-----------------------+-------------------+

user#> !set rowset_size=500

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 500               |
 ...
+-----------------------+-------------------+

user#> !set rowset_size=1000

user#> !options

+-----------------------+-------------------+
| Name                  | Value             |
|-----------------------+-------------------|
 ...
| rowset_size           | 1000              |
 ...
+-----------------------+-------------------+
Copy

Importante

Não são permitidos espaços entre uma opção e seu valor. Algumas opções oferecem suporte para um conjunto definido de valores; o SnowSQL retorna um erro se o valor fornecido não tiver suporte. Você não pode criar novas opções.

Para obter uma lista de todas as opções de configuração que você pode definir, use o comando !options.

!source, !load

Executa SQL a partir de um arquivo. Você pode usar SQL a partir de arquivos locais ou uma URL.

Por exemplo:

user#> !source example.sql

user#> !load /tmp/scripts/example.sql

user#> !load http://www.example.com/sql_text.sql
Copy

!spool

Este comando pode ser executado de duas maneiras:

  • Habilite o spooling e grave os resultados de todas as instruções/consultas subsequentes no arquivo especificado:

    !spool <nome_do_arquivo>

  • Desative o spooling dos resultados (se estiver habilitado):

    !spool off

Por exemplo:

user#> select 1 num;

+-----+
| NUM |
|-----|
|   1 |
+-----+

user#> !spool /tmp/spool_example

user#> select 2 num;

+---+
| 2 |
|---|
| 2 |
+---+

user#> !spool off

user#> select 3 num;

+---+
| 3 |
|---|
| 3 |
+---+

user#> !exit

Goodbye!

$ cat /tmp/spool_example

+---+
| 2 |
|---|
| 2 |
+---+
Copy

Você pode mudar o formato de saída executando primeiro o comando !set output_format=<formato>. A opção suporta os seguintes valores:

  • expanded

  • fancy_grid

  • grid

  • html

  • latex

  • latex_booktabs

  • mediawiki

  • orgtbl

  • pipe

  • plain

  • psql

  • rst

  • simple

  • tsv

Valor recomendado: psql, fancy_grid ou grid

Por exemplo, para produzir uma saída em formato CSV:

user#> !set output_format=csv

user#> !spool /tmp/spool_example
Copy

!system

Executa um comando do shell.

!system <comando>

O seguinte exemplo executa o comando ls no diretório base do usuário:

user#> !system ls ~
Copy

!variables , !vars

Lista todas as variáveis atuais. Retorna cada par <nome_da_variável>=<valor_da_variável> atualmente definido.

Uma vez que uma variável é atribuída, ela não pode ser excluída, mas seu valor pode ser removido especificando-se o nome da variável sem nenhum valor. Por exemplo:

user#> !set variable_substitution=true

user#> !define SnowAlpha=_ALPHA_

user#> !variables

+------------------+---------+
| Name             | Value   |
|------------------+---------|
| snowalpha        | _ALPHA_ |
+------------------+---------+

user#> !define SnowAlpha

user#> !variables

+------------------+-------+
| Name             | Value |
|------------------+-------|
| snowalpha        |       |
+------------------+-------+

user#> !define snowalpha=456

user#> select &snowalpha;

+-----+
| 456 |
|-----|
| 456 |
+-----+
Copy

Para obter mais informações sobre a definição de variáveis, consulte Uso de variáveis (neste tópico).

Solução de problemas

Mensagem de erro: Variable is not defined

Causa:

Se você vir esta mensagem de erro ao executar comandos no SnowSQL, a causa pode ser um E comercial (&) dentro de um comando CREATE FUNCTION. (O E comercial é o caráter de substituição de variáveis do SnowSQL). Por exemplo, executar o seguinte código no SnowSQL causa esse erro:

create function mask_bits(...)
    ...
    as
    $$
    var masked = (x & y);
    ...
    $$;
Copy

O erro ocorre quando a função é criada, e não quando a função é chamada.

Solução:

Se você não pretende usar a substituição de variáveis no SnowSQL, você pode desativar explicitamente a substituição de variáveis executando o seguinte comando:

!set variable_substitution=false;
Copy

Para obter mais informações sobre a substituição de variáveis, consulte Uso de variáveis.