Snowflake em 20 minutos

Introdução

Este tutorial usa o SnowSQL, cliente de linha de comando do Snowflake, para introduzir conceitos e tarefas essenciais, como:

  • Criação de objetos do Snowflake — Você cria um banco de dados e uma tabela para o armazenamento de dados.

  • Carregamento de dados — Uma pequena quantidade de arquivos de dados de amostra CSV é fornecida para que você possa carregar na tabela.

  • Consultas — Por fim, você explora exemplos de consultas.

Nota

O Snowflake requer um warehouse virtual para carregar os dados e executar consultas. Um warehouse em execução consome créditos do Snowflake. Entretanto, o número de créditos consumidos neste tutorial será mínimo porque ele pode ser concluído em menos de 30 minutos. Além disso, o Snowflake fatura uma quantidade mínima para o armazenamento em disco utilizado para os dados das amostras neste tutorial. No entanto, este tutorial fornece passos para descartar a tabela e minimizar o custo de armazenamento. Se você estiver usando uma conta de teste de 30 dias, a conta fornecerá créditos gratuitos e você não incorrerá em nenhum custo. Para obter mais informações sobre tamanhos e custos de warehouses, consulte Tamanho do warehouse.

O que você aprenderá

Neste tutorial você aprenderá a:

  • Criação de objetos Snowflake — Você criará um banco de dados e uma tabela para armazenar dados.

  • Instalação do SnowSQL — Você instalará e usará o SnowSQL, a ferramenta de consulta de linha de comando Snowflake.

    Os usuários do Visual Studio Code podem considerar usar Snowflake Extension for Visual Studio Code em vez de SnowSQL.

  • Carregamento de arquivo de dados CSV — Você usará vários mecanismos para carregar dados em tabelas de arquivos CSV

  • Escrita e execução de consultas de amostra – Você escreverá e executará uma variedade de consultas em dados recém-carregados.

Pré-requisitos

Este tutorial requer um banco de dados, uma tabela e um warehouse para carregar e consultar dados. A criação desses objetos Snowflake requer um usuário Snowflake com uma função com os privilégios de controle de acesso necessários. Além disso, o SnowSQL é necessário para executar as instruções SQL no tutorial. Finalmente, o tutorial requer arquivos CSV com os dados de exemplo que serão carregados.

Você pode concluir este tutorial usando um warehouse, banco de dados e tabela existentes do Snowflake e seus próprios arquivos de dados locais, mas recomendamos usar os objetos Snowflake e o conjunto de dados fornecidos.

Para configurar o Snowflake para este tutorial, faça o seguinte antes de continuar:

  1. Crie um usuário

    Para criar o banco de dados, a tabela e o warehouse virtual, você deve entrar como um usuário do Snowflake com uma função que lhe concede os privilégios para criar esses objetos.

    • Se você estiver usando uma conta de teste do 30 dias, você pode entrar como o usuário criado para a conta. Este usuário tem a função com os privilégios necessários para criar os objetos.

    • Se você não tiver um usuário Snowflake, não poderá executar este tutorial. Se você não tiver uma função que permita criar um usuário, peça a alguém que execute essa etapa para você. Usuários com a função ACCOUNTADMIN ou SECURITYADMIN podem criar usuários.

  2. Instalação do SnowSQL

    Para instalar o SnowSQL, consulte Instalação do SnowSQL.

  3. Download de arquivos de dados de amostra

    Para este tutorial, você baixará as amostras de arquivos de dados de funcionários no formato CSV fornecido pelo Snowflake.

    Para baixar e descompactar os arquivos de dados de amostra:

    1. Baixe o conjunto de arquivos de dados de amostra. Clique com o botão direito do mouse sobre o nome do arquivo, getting-started.zip, e salve o link/arquivo no seu sistema de arquivo local.

    2. Descompacte os arquivos de amostra. O tutorial pressupõe que você descompactou os arquivos em um dos seguintes diretórios:

    • Linux/macOS: /tmp

    • Windows: C:\\temp

    Cada arquivo tem cinco registros de dados. Os dados usam uma vírgula (,) como delimitador de campo. Um exemplo de registro é mostrado:

    Althea,Featherstone,afeatherstona@sf_tuts.com,"8172 Browning Street, Apt B",Calatrava,7/12/2017
    
    Copy

Não há espaços em branco antes ou depois das vírgulas que separam os campos em cada registro. Esse é o padrão que o Snowflake espera ao carregar os dados CSV.

Login no SnowSQL

Depois de ter SnowSQL, inicie SnowSQL para se conectar ao Snowflake:

  1. Abra uma janela de linha de comando.

  2. Iniciar o SnowSQL:

    $ snowsql -a <account_identifier> -u <user_name>
    
    Copy

    Onde:

    Nota

    Se sua conta tiver um provedor de identidade (IdP) definido para sua conta, você pode usar um navegador web para autenticar em vez de uma senha, como demonstra o exemplo a seguir.

    $ snowsql -a <account_identifier> -u <user_name> --authenticator externalbrowser
    
    Copy

    Para obter mais informações, consulte Uso de um navegador da web para autenticação federada/SSO.

  3. Quando solicitado pelo SnowSQL, digite a senha do usuário Snowflake.

Se você entrar com sucesso, o SnowSQL exibirá um prompt de comando que inclui seu warehouse atual, banco de dados e esquema.

Nota

Se você tiver o acesso à conta bloqueado e não conseguir obter o identificador da conta, você poderá encontrá-lo no e-mail de boas-vindas que Snowflake enviou quando você se inscreveu para a conta de teste, ou você pode contatar seu ORGADMIN para obter os detalhes da conta. Você também pode encontrar os valores para locator, cloud e region no e-mail de boas-vindas.

Se seu usuário Snowflake não tiver um warehouse, banco de dados e esquema padrão, ou se você não tiver configurado o SnowSQL para especificar um warehouse, banco de dados e esquema padrão, o prompt exibe no warehouse, no database e no schema. Por exemplo:

user-name#(no warehouse)@(no database).(no schema)>
Copy

Este prompt indica que não há nenhum warehouse, banco de dados e esquema selecionado para a sessão atual. Você cria estes objetos na próxima etapa. Ao seguir os próximos passos neste tutorial para criar estes objetos, o prompt é atualizado automaticamente para incluir os nomes destes objetos.

Para obter mais detalhes, consulte Conexão por meio do SnowSQL.

Criação de objetos Snowflake

Nesta etapa, você criará os seguintes objetos do Snowflake:

  • Um banco de dados (sf_tuts) e uma tabela (emp_basic). Você carrega os dados de amostra nesta tabela.

  • Um warehouse virtual (sf_tuts_wh). Este warehouse fornece os recursos de computação necessários para carregar os dados na tabela e consultar a tabela. Para este tutorial, você cria um warehouse X-Small.

No fim deste tutorial, você removerá estes objetos.

Criação de um banco de dados

Você pode criar um banco de dados sf_tuts usando o comando CREATE DATABASE:

CREATE OR REPLACE DATABASE sf_tuts;
Copy

Neste tutorial, você usa o esquema padrão (public) disponível para cada banco de dados em vez de criar um novo esquema.

Observe que o banco de dados e o esquema que você acabou de criar estão agora em uso para sua sessão atual, conforme refletido no prompt de comando do SnowSQL. Você também pode usar as funções de contexto para obter estas informações.

SELECT CURRENT_DATABASE(), CURRENT_SCHEMA();
Copy

O resultado a seguir é um exemplo:

+--------------------+------------------+
| CURRENT_DATABASE() | CURRENT_SCHEMA() |
|--------------------+------------------|
| SF_TUTS            | PUBLIC           |
+--------------------+------------------+

Criação de uma tabela

Você pode criar uma tabela chamada emp_basic em sf_tuts.public usando o comando CREATE TABLE:

CREATE OR REPLACE TABLE emp_basic (
   first_name STRING ,
   last_name STRING ,
   email STRING ,
   streetaddress STRING ,
   city STRING ,
   start_date DATE
   );
Copy

Observe que o número de colunas na tabela, suas posições e seus tipos de dados correspondem aos campos nos arquivos de dados CSV que você vai preparar na próxima etapa deste tutorial.

Criação de um warehouse virtual

Você pode criar um warehouse X-Small chamado sf_tuts_wh usando o comando CREATE WAREHOUSE:

CREATE OR REPLACE WAREHOUSE sf_tuts_wh WITH
   WAREHOUSE_SIZE='X-SMALL'
   AUTO_SUSPEND = 180
   AUTO_RESUME = TRUE
   INITIALLY_SUSPENDED=TRUE;
Copy

O warehouse sf_tuts é inicialmente suspenso, mas a instrução DML também define AUTO_RESUME = true. A configuração AUTO_RESUME faz com que um warehouse seja iniciado automaticamente quando as instruções SQL que requerem recursos de computação são executadas.

Após criar o warehouse, ele estará agora em uso para sua sessão atual. Estas informações são exibidas em seu prompt de comando do SnowSQL. Você também pode recuperar o nome do warehouse usando a seguinte função de contexto:

SELECT CURRENT_WAREHOUSE();
Copy

O resultado a seguir é um exemplo:

+---------------------+
| CURRENT_WAREHOUSE() |
|---------------------|
| SF_TUTS_WH          |
+---------------------+

Preparação de arquivos de dados

Um estágio do Snowflake é um local no armazenamento em nuvem que você usa para carregar e descarregar dados de uma tabela. O Snowflake oferece suporte a:

  • Estágios internos — Usado para armazenar arquivos de dados internamente dentro do Snowflake. Cada usuário e tabela no Snowflake recebe um estágio interno por padrão para a preparação de arquivos de dados.

  • Estágios externos* — Usado para armazenar arquivos de dados externamente no Amazon S3, Google Cloud Storage ou Microsoft Azure. Se seus dados já estiverem armazenados nestes serviços de armazenamento em nuvem, você pode usar um estágio externo para carregar dados nas tabelas do Snowflake.

Neste tutorial, carregamos os arquivos de dados de amostra (baixados em Pré-requisitos) no estágio interno da tabela emp_basic que você criou anteriormente. Use o comando PUT para carregar os seguintes arquivos de dados de amostra para esse estágio:

Preparação de arquivos de dados de amostra

Execute PUT em SnowSQL para carregar os arquivos de dados locais no estágio de tabela fornecido para a tabela emp_basic que você criou.

PUT file://<file-path>[/\]employees0*.csv @sf_tuts.public.%emp_basic;
Copy

Por exemplo:

  • Linux ou macOS

    PUT file:///tmp/employees0*.csv @sf_tuts.public.%emp_basic;
    
    Copy
  • Windows

    PUT file://C:\temp\employees0*.csv @sf_tuts.public.%emp_basic;
    
    Copy

Vamos analisar melhor o comando:

  • file://<caminho-arquivo>[/\]employees0*.csv especifica o caminho completo do diretório e os nomes dos arquivos na máquina local que devem ser preparados. Observe que caracteres curinga do sistema de arquivos são permitidos e, se vários arquivos se enquadrarem no padrão, todos serão exibidos.

  • @<namespace>.%<nome_tabela> diz para usar o estágio para a tabela especificada, neste caso a tabela emp_basic.

O comando retorna o seguinte resultado, mostrando os arquivos preparados:

+-----------------+--------------------+-------------+-------------+--------------------+--------------------+----------+---------+
| source          | target             | source_size | target_size | source_compression | target_compression | status   | message |
|-----------------+--------------------+-------------+-------------+--------------------+--------------------+----------+---------|
| employees01.csv | employees01.csv.gz |         360 |         287 | NONE               | GZIP               | UPLOADED |         |
| employees02.csv | employees02.csv.gz |         355 |         274 | NONE               | GZIP               | UPLOADED |         |
| employees03.csv | employees03.csv.gz |         397 |         295 | NONE               | GZIP               | UPLOADED |         |
| employees04.csv | employees04.csv.gz |         366 |         288 | NONE               | GZIP               | UPLOADED |         |
| employees05.csv | employees05.csv.gz |         394 |         299 | NONE               | GZIP               | UPLOADED |         |
+-----------------+--------------------+-------------+-------------+--------------------+--------------------+----------+---------+

O comando PUT comprime os arquivos por padrão usando gzip, como indicado na coluna TARGET_COMPRESSION.

Listagem dos arquivos preparados (opcional)

Você pode listar os arquivos preparados usando o comando LIST.

LIST @sf_tuts.public.%emp_basic;
Copy

O resultado a seguir é um exemplo:

+--------------------+------+----------------------------------+------------------------------+
| name               | size | md5                              | last_modified                |
|--------------------+------+----------------------------------+------------------------------|
| employees01.csv.gz |  288 | a851f2cc56138b0cd16cb603a97e74b1 | Tue, 9 Jan 2018 15:31:44 GMT |
| employees02.csv.gz |  288 | 125f5645ea500b0fde0cdd5f54029db9 | Tue, 9 Jan 2018 15:31:44 GMT |
| employees03.csv.gz |  304 | eafee33d3e62f079a054260503ddb921 | Tue, 9 Jan 2018 15:31:45 GMT |
| employees04.csv.gz |  304 | 9984ab077684fbcec93ae37479fa2f4d | Tue, 9 Jan 2018 15:31:44 GMT |
| employees05.csv.gz |  304 | 8ad4dc63a095332e158786cb6e8532d0 | Tue, 9 Jan 2018 15:31:44 GMT |
+--------------------+------+----------------------------------+------------------------------+

Cópia de dados em tabelas de destino

Para carregar seus dados preparados na tabela de destino, execute COPY INTO <tabela>.

O comando COPY INTO <tabela> utiliza o warehouse virtual que você criou em Criação de objetos Snowflake para copiar arquivos.

COPY INTO emp_basic
  FROM @%emp_basic
  FILE_FORMAT = (type = csv field_optionally_enclosed_by='"')
  PATTERN = '.*employees0[1-5].csv.gz'
  ON_ERROR = 'skip_file';
Copy

Onde:

  • A cláusula FROM especifica o local que contém os arquivos de dados (o estágio interno da tabela).

  • A cláusula FILE_FORMAT especifica o tipo de arquivo como CSV e o caractere de aspas duplas (") como o caractere usado para delimitar cadeias de caracteres. O Snowflake oferece suporte a diversos tipos e opções de arquivos. Eles estão descritos em CREATE FILE FORMAT.

  • A cláusula PATTERN especifica que o comando deve carregar dados dos nomes dos arquivos que correspondem a esta expressão regular (.*employees0[1-5].csv.gz).

  • A cláusula ON_ERROR especifica o que fazer quando o comando COPY encontra erros nos arquivos. Por padrão, o comando para o carregamento de dados quando o primeiro erro for encontrado. Este exemplo ignora qualquer arquivo que contenha um erro e segue para o carregamento do próximo arquivo. Nenhum dos arquivos deste tutorial contém erros, isso foi incluído para fins ilustrativos.

O comando COPY também oferece uma opção para validação dos arquivos antes do carregamento. Para obter mais instruções de validação e verificação de erros, consulte o tópico COPY INTO <tabela> e os outros tutoriais de carregamento de dados.

O comando COPY retorna um resultado mostrando a lista de arquivos copiados e informações relacionadas:

+--------------------+--------+-------------+-------------+-------------+-------------+-------------+------------------+-----------------------+-------------------------+
| file               | status | rows_parsed | rows_loaded | error_limit | errors_seen | first_error | first_error_line | first_error_character | first_error_column_name |
|--------------------+--------+-------------+-------------+-------------+-------------+-------------+------------------+-----------------------+-------------------------|
| employees02.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees04.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees05.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees03.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
| employees01.csv.gz | LOADED |           5 |           5 |           1 |           0 | NULL        |             NULL |                  NULL | NULL                    |
+--------------------+--------+-------------+-------------+-------------+-------------+-------------+------------------+-----------------------+-------------------------+

Consulta de dados carregados

Você pode consultar os dados carregados na tabela emp_basic usando SQL padrão e quaisquer funções e operadores com suporte.

Você também pode manipular os dados (atualizar os dados carregados, inserir mais dados, etc.) usando comandos DML padrão.

Recuperação de todos os dados

Você pode exibir todas as linhas e colunas da tabela:

SELECT * FROM emp_basic;
Copy

O resultado parcial a seguir é um exemplo:

+------------+--------------+---------------------------+-----------------------------+--------------------+------------+
| FIRST_NAME | LAST_NAME    | EMAIL                     | STREETADDRESS               | CITY               | START_DATE |
|------------+--------------+---------------------------+-----------------------------+--------------------+------------|
| Arlene     | Davidovits   | adavidovitsk@sf_tuts.com  | 7571 New Castle Circle      | Meniko             | 2017-05-03 |
| Violette   | Shermore     | vshermorel@sf_tuts.com    | 899 Merchant Center         | Troitsk            | 2017-01-19 |
| Ron        | Mattys       | rmattysm@sf_tuts.com      | 423 Lien Pass               | Bayaguana          | 2017-11-15 |
 ...
 ...
 ...
| Carson     | Bedder       | cbedderh@sf_tuts.co.au    | 71 Clyde Gallagher Place    | Leninskoye         | 2017-03-29 |
| Dana       | Avory        | davoryi@sf_tuts.com       | 2 Holy Cross Pass           | Wenlin             | 2017-05-11 |
| Ronny      | Talmadge     | rtalmadgej@sf_tuts.co.uk  | 588 Chinook Street          | Yawata             | 2017-06-02 |
+------------+--------------+---------------------------+-----------------------------+--------------------+------------+
Copy

Inserção de linhas de dados adicionais

Além de carregar dados de arquivos preparados em uma tabela, você pode inserir linhas diretamente na tabela usando o comando INSERT DML.

Por exemplo, para inserir duas linhas adicionais na tabela:

INSERT INTO emp_basic VALUES
   ('Clementine','Adamou','cadamou@sf_tuts.com','10510 Sachs Road','Klenak','2017-9-22') ,
   ('Marlowe','De Anesy','madamouc@sf_tuts.co.uk','36768 Northfield Plaza','Fangshan','2017-1-26');
Copy

Consulta de linhas com base no endereço de e-mail

Retorna uma lista de endereços de e-mail com domínios de nível superior do Reino Unido usando a função LIKE:

SELECT email FROM emp_basic WHERE email LIKE '%.uk';
Copy

O resultado a seguir é um exemplo:

+--------------------------+
| EMAIL                    |
|--------------------------|
| gbassfordo@sf_tuts.co.uk |
| rtalmadgej@sf_tuts.co.uk |
| madamouc@sf_tuts.co.uk   |
+--------------------------+

Consulta de linhas com base na data de início

Por exemplo, para calcular quando determinados benefícios dos funcionários podem começar, adicione 90 dias às datas de início dos funcionários usando a função DATEADD. Filtre a lista pelos funcionários com data de início anterior a 1.º de janeiro de 2017:

SELECT first_name, last_name, DATEADD('day',90,start_date) FROM emp_basic WHERE start_date <= '2017-01-01';
Copy

O resultado a seguir é um exemplo:

+------------+-----------+------------------------------+
| FIRST_NAME | LAST_NAME | DATEADD('DAY',90,START_DATE) |
|------------+-----------+------------------------------|
| Granger    | Bassford  | 2017-03-30                   |
| Catherin   | Devereu   | 2017-03-17                   |
| Cesar      | Hovie     | 2017-03-21                   |
| Wallis     | Sizey     | 2017-03-30                   |
+------------+-----------+------------------------------+

Resumo, limpeza e recursos adicionais

Parabéns! Você concluiu esse tutorial introdutório com sucesso.

Reserve alguns minutos para ver um pequeno resumo e os pontos principais abordados no tutorial. Você também pode excluir os objetos criados no tutorial para liberar espaço. Saiba mais revisando outros tópicos na documentação do Snowflake.

Resumo e pontos principais

Em resumo, o carregamento de dados será realizado em 2 etapas:

  1. Prepare os arquivos de dados para carregamento. Os arquivos podem ser preparados internamente (no Snowflake) ou em um local externo. Neste tutorial, você prepara os arquivos em um estágio interno.

  2. Copie os dados dos arquivos preparados em uma tabela de destino existente. Você precisa de um warehouse em execução para essa etapa.

Pontos principais sobre o carregamento de arquivos CSV:

  • Um arquivo CSV consiste em 1 ou mais registros, com 1 ou mais campos em cada registro, e às vezes um registro de cabeçalho.

  • Os registros e campos de cada arquivo são separados por delimitadores. Os delimitadores padrão são:

    Registros

    caracteres de nova linha

    Campos

    vírgulas

    Em outras palavras, o Snowflake espera que cada registro em um arquivo CSV seja separado por novas linhas e que os campos (isto é, os valores individuais) sejam separados por vírgulas. Se caracteres diferentes forem usados como delimitadores de registro e campo, você precisa especificar explicitamente que eles fazem parte do formato do arquivo ao fazer o carregamento.

  • Existe uma correlação direta entre os campos dos arquivos e as colunas da tabela que você vai carregar, em termos de:

    • Número de campos (no arquivo) e colunas (na tabela de destino).

    • Posições dos campos e colunas dentro de seu respectivo arquivo/tabela.

    • Tipos de dados, tais como cadeias de caracteres, número ou data, em campos e colunas.

    Os registros não serão carregados se os números, as posições e os tipos de dados não estiverem alinhados com os dados.

    Nota

    O Snowflake oferece suporte ao carregamento de arquivos com campos não exatamente alinhados às colunas da tabela de destino. No entanto, esse é um tópico mais avançado de carregamento de dados (abordado em Transformação de dados durante um carregamento).

Tutorial de limpeza (opcional)

Se os objetos criados neste tutorial não forem mais necessários, você poderá removê-los do sistema com as instruções DROP <objeto>.

DROP DATABASE IF EXISTS sf_tuts;

DROP WAREHOUSE IF EXISTS sf_tuts_wh;
Copy

Como sair da conexão

Para sair de uma conexão, use o comando !exit no SnowSQL (ou o alias !disconnect).

Ao sair, a conexão atual é descartada e fecha o SnowSQL se for a última conexão.

Qual é o próximo passo?

Continue aprendendo sobre o Snowflake com os seguintes recursos: