Visão geral

Damos as boas-vindas ao quickstart "Powered by Tasty Bytes: do zero ao Snowflake", voltado para o processamento de dados semiestruturados!

Neste quickstart, vamos aprender sobre o processamento de dados semiestruturados no Snowflake. Vamos aprofundar o conhecimento sobre o tipo de dados VARIANT, o processamento de dados semiestruturados em combinação de notação de pontos com nivelamento lateral, bem como a criação de exibições e gráficos no Snowsight.

Para obter mais informações sobre dados semiestruturados no Snowflake, consulte a documentação visão geral de dados semiestruturados.

Pré-requisitos

Você vai aprender

O que será desenvolvido

Visão geral

Neste quickstart, vamos acompanhar a história da Tasty Bytes por meio de uma planilha SQL do Snowsight. Esta página servirá como um guia de referência completo com comentários adicionais, imagens e links para a documentação.

Nesta seção vamos mostrar como acessar o Snowflake, criar uma planilha nova, renomeá-la, copiar o código SQL do GitHub e colar o código SQL que usaremos neste quickstart.

Etapa 1 - Acessar o Snowflake via URL

Etapa 2 - Fazer login no Snowflake

Etapa 3 - Acessar as planilhas

Etapa 4 - Criar uma planilha

Etapa 5 - Renomear uma planilha

Etapa 6 - Acessar o código SQL do quickstart no GitHub

Etapa 7 - Copiar o Setup SQL do GitHub

Etapa 8 - Colar o Setup SQL do GitHub para a sua planilha do Snowflake

Etapa 9 - Clicar em Next –>

Visão geral

Enquanto engenheiros de dados da Tasty Bytes, recebemos a tarefa de criar o perfil dos nossos dados de menu, que incluem uma coluna de dados semiestruturados. A partir desta tabela de menu, precisamos criar uma exibição da camada de análise de dados que apresente as restrições alimentares e os ingredientes aos usuários finais.

Etapa 1 - Definir o contexto e consultar a tabela

Para começar, vamos executar as três primeiras consultas juntas, que vão:

USE ROLE tasty_data_engineer; 
USE WAREHOUSE tasty_de_wh;

SELECT TOP 10 
    m.truck_brand_name, 
    m.menu_type, 
    m.menu_item_name, 
    m.menu_item_health_metrics_obj 
FROM frostbyte_tasty_bytes.raw_pos.menu m;

No resultado, podemos ver que menu_item_health_metrics_obj deve mostrar os dados semiestruturados que contêm as métricas que precisamos fornecer mais adiante no processo.

Ao clicar em uma das células nesta coluna, o Snowsight vai expandir automaticamente o painel de estatísticas para que vejamos melhor o conteúdo.

Etapa 2 - Explorar a coluna de dados semiestruturados

Para analisar em mais detalhes como esta coluna é definida no Snowflake, execute a próxima consulta que usa SHOW COLUMNS para descobrir os tipos de dados presentes na tabela menu.

SHOW COLUMNS IN frostbyte_tasty_bytes.raw_pos.menu;

Ao observar o conjunto de resultados, vamos notar que menu_item_health_metrics_obj é do tipo de dados VARIANT.

Etapa 3 - Percorrer dados semiestruturados usando a notação de pontos

Na coluna menu_item_health_metrics_obj, vimos que menu_item_id estava incluído entre os dados aninhados de ingredientes e restrições alimentares que precisamos acessar.

Execute a consulta a seguir, em que começamos a usar a notação de pontos para percorrer os dados semiestruturados.

SELECT 
    m.menu_item_health_metrics_obj:menu_item_id AS menu_item_id,
    m.menu_item_health_metrics_obj:menu_item_health_metrics AS menu_item_health_metrics
FROM frostbyte_tasty_bytes.raw_pos.menu m;

Ao usar a notação de pontos, podemos extrair os dados completamente menu_item_id, mas parece que ainda há objetos semiestruturados no resultado da coluna menu_item_health_metrics.

Vamos clicar novamente em uma das células da coluna para analisar melhor.

Estamos progredindo! Vamos ver como processar ainda mais a coluna menu_item_health_metrics na próxima seção usando funções adicionais do Snowflake.

Etapa 4 - Clicar em Next –>

Visão geral

Depois de ver como é fácil consultar os dados semiestruturados em uma coluna Variant usando a notação de pontos, nosso engenheiro de dados da Tasty já pode fornecer os dados solicitados aos colaboradores internos.

Nesta seção, vamos realizar um processamento adicional dos dados semiestruturados para atender aos requisitos.

Etapa 1 - Introdução ao nivelamento lateral

Para extrair da coluna menu_item_health_metrics_obj dados mais detalhados solicitados pelos usuários, execute a consulta a seguir. Ela usa a notação de pontos junto da função FLATTEN do Snowflake e o recurso LATERAL JOIN para nos fornecer a primeira matriz ingredient solicitada.

SELECT 
    m.menu_item_name,
    obj.value:"ingredients"::VARIANT AS ingredients
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj;

Etapa 2 - Explorar de uma função de matriz

Antes de extrair os dados de restrições alimentares solicitados, execute a próxima consulta, que destaca as funções de matriz do Snowflake, que explorará a coluna ingredients em busca de qualquer menu_item_name que inclua "alface" ("lettuce", se os dados estiverem em inglês) usando ARRAY_CONTAINS.

SELECT 
    m.menu_item_name,
    obj.value:"ingredients"::VARIANT AS ingredients
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj
WHERE ARRAY_CONTAINS('Lettuce'::VARIANT, obj.value:"ingredients"::VARIANT);

Com base nos resultados, vemos que muitos dos itens do menu contêm "alface" ("lettuce"). Esse tipo de análise pode ser bem útil para os gerentes de compras de cadeia de suprimentos no caso de recalls alimentares realizados em cidades e países onde atuamos.

Etapa 3 - Estruturar dados semiestruturados em escala

Tendo acabado de ver o valor que podemos agregar à organização, é hora de executar a última consulta desta seção.

Esta consulta vai usar a notação de pontos e combinar as funções de tabela LATERAL JOIN e FLATTEN para gerar o conjunto de resultados solicitado inicialmente.

SELECT 
    m.menu_item_health_metrics_obj:menu_item_id::integer AS menu_item_id,
    m.menu_item_name,
    obj.value:"ingredients"::VARIANT AS ingredients,
    obj.value:"is_healthy_flag"::VARCHAR(1) AS is_healthy_flag,
    obj.value:"is_gluten_free_flag"::VARCHAR(1) AS is_gluten_free_flag,
    obj.value:"is_dairy_free_flag"::VARCHAR(1) AS is_dairy_free_flag,
    obj.value:"is_nut_free_flag"::VARCHAR(1) AS is_nut_free_flag
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj;

Maravilha! O resultado parece atender exatamente aos requisitos solicitados por nossos colaboradores. Na seção a seguir veremos como levar os resultados à nossa camada de análise de dados, onde eles poderão ser acessados.

Etapa 4 - Clicar em Next –>

Visão geral

Na última seção, criamos uma consulta que fornece o resultado exato solicitado por usuários finais ao usar uma série de funcionalidades do Snowflake para dados semiestruturados. A seguir, vamos dar continuidade ao processo de promover essa consulta com base na camada bruta, passando pela camada harmonizada, até chegar à camada de análise de dados, para que os usuários finais possam ler os resultados.

Observação: aos usuários mais familiarizados com modelos de dados Bronze, Silver e Gold, podemos pensar na camada bruta como Bronze, a camada harmonizada como Silver e a de análise de dados como Gold.

Etapa 1 - Criar um modo de exibição harmonizado com o SQL de nivelamento semiestruturado

Com base na consulta que encerrou a última seção, execute agora a próxima consulta que inclui este SQL e as colunas adicionais da tabela menu já estruturadas.

Nessa consulta, usaremos CREATE VIEW em nosso esquema harmonizado para encapsular a lógica de processamento e colunas adicionais semiestruturadas como tabela.

CREATE OR REPLACE VIEW frostbyte_tasty_bytes.harmonized.menu_v
    AS
SELECT 
    m.menu_id,
    m.menu_type_id,
    m.menu_type,
    m.truck_brand_name,
    m.menu_item_health_metrics_obj:menu_item_id::integer AS menu_item_id,
    m.menu_item_name,
    m.item_category,
    m.item_subcategory,
    m.cost_of_goods_usd,
    m.sale_price_usd,
    obj.value:"ingredients"::VARIANT AS ingredients,
    obj.value:"is_healthy_flag"::VARCHAR(1) AS is_healthy_flag,
    obj.value:"is_gluten_free_flag"::VARCHAR(1) AS is_gluten_free_flag,
    obj.value:"is_dairy_free_flag"::VARCHAR(1) AS is_dairy_free_flag,
    obj.value:"is_nut_free_flag"::VARCHAR(1) AS is_nut_free_flag
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj;

Dentro da exibição harmonized.menu_v criada, agora é possível executar consultas sem usar o SQL complexo de antes. Considerando que a camada de análise de dados é onde nossos colaboradores acessam dados, o próximo passo é levar tudo até lá.

Etapa 2 - Promover da camada de harmonização para a análise de dados com facilidade

Consultando o harmonized.menu_v, é hora de executar a próxima consulta que vai criar analytics.menu_v e agregar valor imediatamente ao processo.

Nesta consulta, veremos algumas funções novas, ainda não abordadas. Primeiro adicionamos um COMMENT, que pode ser visto dentro do comando SHOW VIEWS ou na interface do Snowsight para documentar o que um usuário pode ver ao consultar essa exibição.

Também usaremos os parâmetros SELECT * EXCLUDE e RENAME que podem facilitar o trabalho dos desenvolvedores de SQL ao simplificar a definição de consultas e as exibições.

Etapa 3 - Clicar em Next –>

Visão geral

Com nossa exibição de menu disponível na camada de análise de dados, vamos executar algumas consultas que forneceremos aos usuários finais, demonstrando como o Snowflake permite uma experiência de consulta relacional sobre dados semiestruturados sem a necessidade de cópias adicionais ou processamento complexo.

Etapa 1 - Analisar as matrizes

Na seção anterior, obtivemos a coluna ingredients como resultado da consulta. Agora, ela está disponível sem a necessidade de notação de pontos no modo de exibição analytics.menu_v.

Com isso, execute a próxima consulta que emprega duas funções de matriz Snowflake adicionais ARRAY_INTERSECTION e ARRAYS_OVERLAP para verificar quais itens do menu não relacionados a bebidas coincidem em cada um dos menus de nossas marcas de food trucks.

SELECT 
    m1.menu_type,
    m1.menu_item_name,
    m2.menu_type AS overlap_menu_type,
    m2.menu_item_name AS overlap_menu_item_name,
    ARRAY_INTERSECTION(m1.ingredients, m2.ingredients) AS overlapping_ingredients
FROM frostbyte_tasty_bytes.analytics.menu_v m1
JOIN frostbyte_tasty_bytes.analytics.menu_v m2
    ON m1.menu_item_id <> m2.menu_item_id -- avoid joining the same menu item to itself
    AND m1.menu_type <> m2.menu_type 
WHERE 1=1
    AND m1.item_category <> 'Beverage' -- remove beverages
    AND m2.item_category <> 'Beverage' -- remove beverages
    AND ARRAYS_OVERLAP(m1.ingredients, m2.ingredients) -- evaluates to TRUE if one ingredient is in both arrays
ORDER BY m1.menu_type;

De novo, ao utilizar o mesmo modo de exibição, criamos esse tipo de consulta capaz de agregar valor real de negócios aos operadores de food trucks, pois eles poderiam à medida que trabalham com o setor de compras prever e fazer pedidos de ingredientes semanais.

Etapa 2 - Fornecer métricas aos executivos

Agora vamos ver como ajudar os executivos da Tasty Bytes a tomarem decisões baseadas em dados para os menus ao fornecer métricas de alto nível relativas às restrições alimentares que utilizamos atualmente em nossas marcas.

Execute a consulta a seguir, que usa COUNT, SUM e instruções condicionais CASE para agregar a métricas exigidas do analytics.menu_v.

SELECT
    COUNT(DISTINCT menu_item_id) AS total_menu_items,
    SUM(CASE WHEN is_healthy_flag = 'Y' THEN 1 ELSE 0 END) AS healthy_item_count,
    SUM(CASE WHEN is_gluten_free_flag = 'Y' THEN 1 ELSE 0 END) AS gluten_free_item_count,
    SUM(CASE WHEN is_dairy_free_flag = 'Y' THEN 1 ELSE 0 END) AS dairy_free_item_count,
    SUM(CASE WHEN is_nut_free_flag = 'Y' THEN 1 ELSE 0 END) AS nut_free_item_count
FROM frostbyte_tasty_bytes.analytics.menu_v m;

Com o resultado obtido, saímos de uma tabela bruta com dados semiestruturados para uma única linha agregada facilmente acessível a qualquer usuário da organização, dando autonomia à Tasty Bytes para que se baseie cada vez mais em dados.

Etapa 3 - Transformar os resultados em gráficos

Alguns executivos da Tasty Bytes preferem representações visuais dos dados. Então, vamos ver como é simples transformar tabelas em gráficos de fácil compreensão dentro do Snowsight.

Execute a próxima consulta que vai adicionar filtros a três de nossas marcas de food trucks ao SQL executado anteriormente.

SELECT
    m.brand_name,
    SUM(CASE WHEN is_gluten_free_flag = 'Y' THEN 1 ELSE 0 END) AS gluten_free_item_count,
    SUM(CASE WHEN is_dairy_free_flag = 'Y' THEN 1 ELSE 0 END) AS dairy_free_item_count,
    SUM(CASE WHEN is_nut_free_flag = 'Y' THEN 1 ELSE 0 END) AS nut_free_item_count
FROM frostbyte_tasty_bytes.analytics.menu_v m
WHERE m.brand_name IN  ('Plant Palace', 'Peking Truck','Revenge of the Curds')
GROUP BY m.brand_name;

Por padrão, o Snowsight exibe os resultados em formato tabular. Porém, um recurso avançado do Snowsight, que ainda não abordamos, é o de uso de gráficos.

Na captura de tela abaixo, siga as setas para criar seu próprio gráfico de barras comparando estas diferentes marcas de food trucks em termos de itens do menu que atendem a certas restrições alimentares.

Para terminar esse quickstart, devemos ressaltar a facilidade com que um executivo da Tasty Bytes poderia fazer esse tipo de análise sozinho sem precisar conhecer processamento de dados semiestruturados que encapsulamos nas exibições criadas. Sendo assim, podemos estar certos de que estamos contribuindo para a democratização dos dados na Tasty Bytes.

Etapa 4 - Clicar em Next –>

Conclusão

Ótimo trabalho! Você concluiu com sucesso o quickstart "Tasty Bytes: do zero ao Snowflake - dados semiestruturados".

Neste módulo, você:

Caso queira refazer este quickstart, use os scripts de Reset que aparecem no final da planilha associada.

Próximas etapas

Para continuar sua jornada no Snowflake Data Cloud, clique no link abaixo para ver mais quickstarts Powered By Tasty Bytes disponíveis para você.