GSP416

Visão geral

O BigQuery é um banco de dados de análise NoOps, totalmente gerenciado e de baixo custo desenvolvido pelo Google. Com ele, você pode consultar muitos terabytes de dados sem ter que gerenciar uma infraestrutura ou precisar de um administrador de banco de dados. O BigQuery usa SQL e está disponível no modelo de pagamento por uso. Assim, você pode se concentrar na análise dos dados para encontrar insights relevantes.

Neste laboratório, você vai trabalhar intensamente com dados semiestruturados (fazendo a ingestão de dados dos tipos matriz e JSON) dentro do BigQuery. A desnormalização do seu esquema em uma única tabela com campos aninhados e repetidos pode gerar melhorias de desempenho, mas a sintaxe SQL para trabalhar com dados do tipo matriz pode ser complexa. Nas atividades práticas, você vai aprender a carregar, consultar, solucionar problemas e desaninhar vários conjuntos de dados semiestruturados.

Atividades

Neste curso, você vai aprender a:

• Carregar, consultar e fazer o desaninhamento de dados semiestruturados.
• Resolver problemas nas consultas de dados semiestruturados.

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

Abrir o console do BigQuery

1. No Console do Google Cloud, selecione o menu de navegação > BigQuery:

Você verá a caixa de mensagem Olá! Este é o BigQuery no Console do Cloud. Ela tem um link para o guia de início rápido e as notas de versão.

2. Clique em OK.

O console do BigQuery vai abrir.

Tarefa 1: criar um novo conjunto de dados para armazenar as tabelas

1. No BigQuery, clique nos três pontos ao lado do ID do projeto e selecione Criar conjunto de dados:

2. Nomeie o novo conjunto de dados como fruit_store. Não altere as outras opções (Local dos dados, Expiração padrão das tabelas).

3. Clique em Criar conjunto de dados.

Tarefa 2: praticar o uso de matrizes no SQL

No SQL, normalmente você terá um único valor para cada linha, como nesta lista de frutas abaixo:

Row	Fruit
1	raspberry
2	blackberry
3	strawberry
4	cherry

E se você quisesse uma lista de frutas para cada pessoa na loja? Ela poderia ficar assim:

Row	Fruit	Person
1	raspberry	sally
2	blackberry	sally
3	strawberry	sally
4	cherry	sally
5	orange	frederick
6	apple	frederick

Em um banco de dados SQL relacional tradicional, você examinaria a repetição de nomes e consideraria imediatamente dividir a tabela acima em duas, uma com as frutas e outra com as pessoas. Esse processo é chamado de normalização (o ato de transformar uma tabela em várias). Trata-se de uma abordagem comum para bancos de dados transacionais como o mySQL.

Para o armazenamento em data warehouse, os analistas de dados costumam fazer o contrário (a desnormalização) e transformam muitas tabelas separadas em uma grande tabela de relatórios.

Agora você vai aprender uma abordagem diferente que armazena dados em diversos níveis de granularidade em uma só tabela usando campos repetidos:

Row	Fruit (array)	Person
1	raspberry	sally
	blackberry
	strawberry
	cherry
2	orange	frederick
	apple

O que há de estranho na tabela anterior?

• Ela tem apenas duas linhas.
• Há vários valores de campo (frutas) em uma única linha.
• As pessoas estão associadas a mais de um valor de campo.

Qual é o dado estratégico? O tipo de dados array.

Uma maneira mais fácil de interpretar a matriz de frutas:

Row	Fruit (array)	Person
1	[raspberry, blackberry, strawberry, cherry]	sally
2	[orange, apple]	frederick

As duas últimas tabelas são iguais, e aprendemos duas coisas importantes com elas:

• Uma matriz é simplesmente uma lista de itens entre colchetes [ ]
• O BigQuery mostra visualmente as matrizes niveladas. Isso significa que os valores da matriz são listados na vertical (observe que todos eles ainda pertencem a uma única linha)

Teste por conta própria.

1. Digite o seguinte no Editor de consultas do BigQuery:

#standardSQL SELECT ['raspberry', 'blackberry', 'strawberry', 'cherry'] AS fruit_array

2. Clique em Executar.

3. Agora tente executar esta consulta:

#standardSQL SELECT ['raspberry', 'blackberry', 'strawberry', 'cherry', 1234567] AS fruit_array

Será exibido um erro parecido com este:

Erro: Array elements of types {INT64, STRING} do not have a common supertype at [3:1]

As matrizes podem ter só um tipo de dados (somente strings ou números, por exemplo).

4. Esta é a tabela final de consulta:

#standardSQL SELECT person, fruit_array, total_cost FROM `data-to-insights.advanced.fruit_store`;

5. Clique em Executar.

6. Depois que você receber os resultados, clique na guia JSON para ver a estrutura aninhada.

Carregar dados JSON semiestruturados no BigQuery

E se você precisasse ingerir um arquivo JSON no BigQuery?

Crie uma nova tabela chamada fruit_details no conjunto de dados.

1. Clique no conjunto de dados fruit_store.

A opção Criar tabela vai aparecer.

Observação: talvez você tenha que ampliar a janela do navegador para acessar a opção "Criar tabela".

2. Adicione os seguintes detalhes à tabela:

• Origem: escolha Google Cloud Storage no menu suspenso Criar tabela de.
• Selecione o arquivo do bucket do Cloud Storage: cloud-training/data-insights-course/labs/optimizing-for-performance/shopping_cart.json
• Formato do arquivo: JSONL (JSON delimitado por nova linha)

3. Defina o nome da nova tabela como fruit_details.

4. Marque a caixa de seleção de Esquema (Detectar automaticamente).

5. Clique em Criar tabela.

No esquema, observe que fruit_array está marcada como REPEATED. Isso significa que ela é uma matriz.

Resumo

• O BigQuery tem suporte nativo a matrizes
• Os valores da matriz precisam ser dados do mesmo tipo
• No BigQuery, as matrizes são identificadas como campos REPEATED

Clique em Verificar meu progresso para ver o objetivo. Crie um novo conjunto de dados e uma nova tabela para armazenar os dados

Tarefa 3: criar suas próprias matrizes com ARRAY_AGG()

Você ainda não tem matrizes nas suas tabelas? Vamos criar!

1. Copie e cole a consulta abaixo para analisar este conjunto de dados público:

SELECT fullVisitorId, date, v2ProductName, pageTitle FROM `data-to-insights.ecommerce.all_sessions` WHERE visitId = 1501570398 ORDER BY date

2. Clique em Executar para ver os resultados.

Agora, use a função ARRAY_AGG() para agregar os valores da string em uma matriz.

3. Copie e cole a consulta abaixo para analisar este conjunto de dados público:

SELECT fullVisitorId, date, ARRAY_AGG(v2ProductName) AS products_viewed, ARRAY_AGG(pageTitle) AS pages_viewed FROM `data-to-insights.ecommerce.all_sessions` WHERE visitId = 1501570398 GROUP BY fullVisitorId, date ORDER BY date

4. Clique em Executar para ver os resultados

5. A seguir, use a função ARRAY_LENGTH() para contar o número de páginas e de produtos que foram visualizados:

SELECT fullVisitorId, date, ARRAY_AGG(v2ProductName) AS products_viewed, ARRAY_LENGTH(ARRAY_AGG(v2ProductName)) AS num_products_viewed, ARRAY_AGG(pageTitle) AS pages_viewed, ARRAY_LENGTH(ARRAY_AGG(pageTitle)) AS num_pages_viewed FROM `data-to-insights.ecommerce.all_sessions` WHERE visitId = 1501570398 GROUP BY fullVisitorId, date ORDER BY date

6. Em seguida, elimine a duplicação de páginas e produtos para ver quantos produtos únicos foram visualizados adicionando DISTINCT a ARRAY_AGG():

SELECT fullVisitorId, date, ARRAY_AGG(DISTINCT v2ProductName) AS products_viewed, ARRAY_LENGTH(ARRAY_AGG(DISTINCT v2ProductName)) AS distinct_products_viewed, ARRAY_AGG(DISTINCT pageTitle) AS pages_viewed, ARRAY_LENGTH(ARRAY_AGG(DISTINCT pageTitle)) AS distinct_pages_viewed FROM `data-to-insights.ecommerce.all_sessions` WHERE visitId = 1501570398 GROUP BY fullVisitorId, date ORDER BY date

Clique em Verificar meu progresso para ver o objetivo. Execute a consulta para ver quantos produtos únicos foram visualizados

Resumo

É possível fazer coisas muito úteis com as matrizes, por exemplo:

• Encontrar a quantidade de elementos com ARRAY_LENGTH(<array>)
• Eliminar a duplicação de elementos com ARRAY_AGG(DISTINCT <field>)
• Ordenar elementos com ARRAY_AGG(<field> ORDER BY <field>)
• Limitar com ARRAY_AGG(<field> LIMIT 5)

Tarefa 4: consultar tabelas que têm matrizes

O conjunto de dados público do BigQuery para Google Analytics bigquery-public-data.google_analytics_sample tem muito mais campos e linhas do que o conjunto de dados data-to-insights.ecommerce.all_sessions do nosso curso. Mais importante do que isso, ele já armazena valores de campos, como produtos, páginas e transações de forma nativa como MATRIZES.

1. Copie e cole a consulta abaixo para analisar os dados disponíveis e tentar encontrar campos com valores repetidos (matrizes):

SELECT * FROM `bigquery-public-data.google_analytics_sample.ga_sessions_20170801` WHERE visitId = 1501570398

2. Execute a consulta.

3. Role para a direita nos resultados até encontrar o campo hits.product.v2ProductName (os campos com múltiplos aliases serão discutidos em breve).

A quantidade de campos disponíveis no esquema do Google Analytics pode sobrecarregar a análise.

4. Tente consultar somente os campos referentes a visitas e nomes de páginas, como fizemos anteriormente.

SELECT visitId, hits.page.pageTitle FROM `bigquery-public-data.google_analytics_sample.ga_sessions_20170801` WHERE visitId = 1501570398

Você vai receber um erro: Erro: Cannot access field page on a value with type ARRAY<STRUCT<hitNumber INT64, time INT64, hour INT64, ...>> at [3:8]

Para consultar os campos "REPEATED" (as matrizes) normalmente, você precisa organizar as matrizes em linhas.

Por exemplo, a matriz de hits.page.pageTitle está armazenada como uma linha única, da seguinte forma:

['homepage','product page','checkout']

e ela precisa ser:

['homepage', 'product page', 'checkout']

Como fazer isso com o SQL?

Resposta: use a função UNNEST() no seu campo de matriz:

SELECT DISTINCT visitId, h.page.pageTitle FROM `bigquery-public-data.google_analytics_sample.ga_sessions_20170801`, UNNEST(hits) AS h WHERE visitId = 1501570398 LIMIT 10

Vamos abordar o UNNEST() com mais detalhes posteriormente. Por enquanto, basta saber que:

• você precisa desaninhar as matrizes por meio do UNNEST() para trazer os elementos da matriz de volta às linhas;
• o UNNEST() sempre segue o nome da tabela na sua cláusula FROM. Pense nele conceitualmente como uma tabela pré-mesclada.

Clique em Verificar meu progresso para ver o objetivo. Execute a consulta para usar o UNNEST() no campo da matriz

Tarefa 5: introdução aos STRUCTs

Você pode estar se perguntando por que o alias de campo hit.page.pageTitle parece ser três campos em um, separados por pontos. Da mesma forma que os valores matriz oferecem a flexibilidade de aprofundamento na granularidade dos seus campos, outros tipos de dados permitem maior amplitude no seu esquema, com o agrupamento de campos relacionados. Esse tipo de dado SQL é o STRUCT.

A maneira mais fácil de entender conceitualmente um STRUCT é pensar que ele é uma tabela separada e pré-mesclada na sua tabela principal.

Um STRUCT pode ter:

• um ou mais campos;
• tipos de dados iguais ou diferentes para cada campo;
• um alias próprio.

Até parece uma tabela, não é mesmo?

Analisar um conjunto de dados com STRUCTs

1. Para abrir o conjunto de dados bigquery-public-data, clique em +ADICIONAR, selecione Marcar um projeto com estrela por nome e insira bigquery-public-data

2. Clique em Marcar com estrela.

O projeto bigquery-public-data será listado na seção "Explorer".

3. Abra bigquery-public-data.

4. Encontre e abra o conjunto de dados google_analytics_sample.

5. Clique na tabela ga_sessions(366)_.

6. Comece a rolar pelo esquema e responda à pergunta abaixo usando o recurso de busca do seu navegador.

Como você pode imaginar, em um site moderno de e-commerce há uma quantidade enorme de dados de sessão armazenados.

A principal vantagem de ter 32 STRUCTs em uma única tabela é que isso permite a execução de consultas como esta, sem o uso de mesclagens:

SELECT visitId, totals.*, device.* FROM `bigquery-public-data.google_analytics_sample.ga_sessions_20170801` WHERE visitId = 1501570398 LIMIT 10 Observação: a sintaxe .* diz ao BigQuery para retornar todos os campos desse STRUCT (como se totals.* fosse uma tabela separada que mesclamos).

O armazenamento de grandes tabelas de relatórios como STRUCTs ("tabelas" pré-mescladas) e MATRIZES (granularidade profunda) permite que você:

• ganhe vantagens significativas de desempenho ao evitar a mesclagem de 32 tabelas;
• receba dados granulares de MATRIZES quando precisar, mas sem nenhuma punição se não for o caso (o BigQuery armazena cada coluna individualmente no disco);
• tenha todo o contexto comercial em uma tabela, sem se preocupar com chaves de mesclagem e com quais tabelas vão ter os dados necessários.

Tarefa 6: praticar com STRUCTS e matrizes

O próximo conjunto de dados contém os tempos das voltas completadas por corredores em uma pista. Cada volta será chamada de "split".

1. Para essa consulta, use a sintaxe de um STRUCT e observe os diferentes tipos de campo dentro do contêiner do struct:

#standardSQL SELECT STRUCT("Rudisha" as name, 23.4 as split) as runner

Row	runner.name	runner.split
1	Rudisha	23.4

O que você observa sobre os aliases de campos? Como existem campos aninhados dentro do struct (name e split são um subconjunto de runner), você acaba com uma notação de ponto.

E se o corredor tiver vários tempos de volta em uma única corrida (como tempo por volta)?

Usaremos uma matriz, é claro!

2. Execute a consulta abaixo para confirmar:

#standardSQL SELECT STRUCT("Rudisha" as name, [23.4, 26.3, 26.4, 26.1] as splits) AS runner

Row	runner.name	runner.splits
1	Rudisha	23.4
		26.3
		26.4
		26.1

Recapitulando:

• Structs são contêineres que podem ter vários nomes de campos e tipos de dados aninhados.
• Matrizes podem ser os tipos de campo de um struct (como o campo splits no código acima).

Pratique a ingestão de dados JSON

1. Crie um novo conjunto de dados chamado racing.

2. Clique no conjunto de dados racing e selecione "Criar tabela".

Observação: talvez você precise ampliar a janela do navegador para ver a opção "Criar tabela".

• Origem: selecione Google Cloud Storage no menu suspenso Criar tabela de.
• Selecione o arquivo do bucket do Cloud Storage: cloud-training/data-insights-course/labs/optimizing-for-performance/race_results.json
• Formato do arquivo: JSONL (JSON delimitado por nova linha)
• Em Esquema, clique no controle deslizante Editar como texto e adicione as seguintes informações:

[ { "name": "race", "type": "STRING", "mode": "NULLABLE" }, { "name": "participants", "type": "RECORD", "mode": "REPEATED", "fields": [ { "name": "name", "type": "STRING", "mode": "NULLABLE" }, { "name": "splits", "type": "FLOAT", "mode": "REPEATED" } ] } ]

3. Nomeie a nova tabela como race_results.

4. Clique em Criar tabela.

5. Depois do job de carregamento, veja o esquema da tabela recém-criada:

Qual campo é o STRUCT? Como você sabe disso?

O campo participants é um STRUCT porque é do tipo RECORD.

Qual campo é uma MATRIZ?

O campo participants.splits é uma matriz de pontos flutuantes dentro do struct participants. Ele tem o modo REPEATED que indica uma matriz. Os valores dessa matriz são chamados de valores aninhados porque estão dentro de um único campo.

Clique em Verificar meu progresso para ver o objetivo. Crie um conjunto de dados e uma tabela para processar dados JSON

Pratique consultas em campos repetidos e aninhados

1. Agora vamos conferir todos os corredores da prova de 800 metros:

#standardSQL SELECT * FROM racing.race_results

Quantas linhas foram retornadas?

Resposta: 1

E se você quisesse listar o nome de cada corredor e o tipo de corrida?

2. Execute o esquema abaixo e descubra o que acontece:

#standardSQL SELECT race, participants.name FROM racing.race_results

Erro: Cannot access field name on a value with type ARRAY<STRUCT<name STRING, splits ARRAY<FLOAT64>>>> at [2:27]

Isso também acontece quando esquecemos de adicionar GROUP BY com funções de agregação. Temos dois níveis diferentes de granularidade: uma linha para a corrida e três linhas para os nomes dos participantes. Como você mudaria isto...

Row	race	participants.name
1	800 m	Rudisha
2	???	Makhloufi
3	???	Murphy

... para ter isto:

Row	race	participants.name
1	800 m	Rudisha
2	800 m	Makhloufi
3	800 m	Murphy

No SQL relacional tradicional, se você tivesse uma tabela de corridas e uma de participantes, o que você faria para extrair informações das duas? Você usaria JOIN para combiná-las. Aqui, o STRUCT com os participantes (que, conceitualmente, é muito semelhante a uma tabela) já faz parte da tabela de corridas, mas ainda não está associado corretamente ao campo não STRUCT "race".

Você consegue pensar em um comando SQL com duas palavras que você usaria para associar a corrida de 800 m a cada um dos corredores na primeira tabela?

Resposta: CROSS JOIN

Ótimo.

3. Agora execute esta consulta:

#standardSQL SELECT race, participants.name FROM racing.race_results CROSS JOIN participants # this is the STRUCT (it is like a table within a table)

Table name "participants" missing dataset while no default dataset is set in the request.

Ainda que o STRUCT com os participantes seja como uma tabela, tecnicamente ele é um campo na tabela racing.race_results.

4. Adicione o nome do conjunto de dados à consulta:

#standardSQL SELECT race, participants.name FROM racing.race_results CROSS JOIN race_results.participants # full STRUCT name

5. E clique em Executar.

Uau! Você listou todos os corredores de cada corrida.

Row	race	name
1	800 m	Rudisha
2	800 m	Makhloufi
3	800 m	Murphy
4	800 m	Bosse
5	800 m	Rotich
6	800 m	Lewandowski
7	800 m	Kipketer
8	800 m	Berian

6. Faça o seguinte para simplificar a última consulta:

• Adicione um alias para a tabela original.
• Substitua as palavras "CROSS JOIN" por uma vírgula (implicitamente, uma vírgula realiza essa operação).

Isso retornará o mesmo resultado desta consulta:

#standardSQL SELECT race, participants.name FROM racing.race_results AS r, r.participants

Se você tivesse mais de um tipo de corrida (800 m, 100 m, 200 m), um CROSS JOIN poderia associar cada nome de corredor a todas as corridas possíveis como um produto cartesiano?

Resposta: não. Esta é uma função CROSS JOIN correlacionada que só descompacta os elementos associados a uma única linha. Para mais detalhes, veja como trabalhar com matrizes e STRUCTs.

Recapitulando o que são STRUCTs:

• Um STRUCT SQL nada mais é do que um contêiner com campos de dados que podem ser de diferentes tipos. O termo "struct", que vem da palavra inglesa "structure", significa estrutura de dados. Use o exemplo anterior: STRUCT(``"Rudisha" as name, [23.4, 26.3, 26.4, 26.1] as splits``)`` AS runner
• Os STRUCTs recebem um alias (como "runner" acima) e podemos entendê-los conceitualmente como uma tabela dentro da sua tabela principal.
• Você precisa descompactar os STRUCTs (e as matrizes) para operar os elementos deles. Coloque o nome do struct ou do campo do struct que é uma matriz em UNNEST () para descompactá-lo e nivelá-lo.

Tarefa 7: pergunta do laboratório: STRUCT()

Responda às perguntas abaixo usando a tabela racing.race_results que você criou.

Tarefa: escreva uma consulta para usar COUNT e descobrir quantos corredores participaram da corrida.

• Para começar, use a consulta parcialmente escrita abaixo:

#standardSQL SELECT COUNT(participants.name) AS racer_count FROM racing.race_results Observação: você vai precisar correlacionar o nome do struct a uma outra fonte de dados após FROM.

Possível solução:

#standardSQL SELECT COUNT(p.name) AS racer_count FROM racing.race_results AS r, UNNEST(r.participants) AS p

Row	racer_count.
1	8

Resposta: 8 corredores participaram da corrida.

Clique em Verificar meu progresso para ver o objetivo. Execute a consulta para usar COUNT e descobrir quantos corredores participaram da corrida.

Tarefa 8: Pergunta do laboratório: como descompactar matrizes com UNNEST( ).

Escreva uma consulta que listará o tempo total dos corredores com nomes que começam com R. Ordene os resultados começando pelo menor tempo total. Use o operador UNNEST() e comece com a consulta parcialmente escrita abaixo.

• Complete a consulta:

#standardSQL SELECT p.name, SUM(split_times) as total_race_time FROM racing.race_results AS r , r.participants AS p , p.splits AS split_times WHERE GROUP BY ORDER BY ; Observação:

• Você vai precisar descompactar o struct e a matriz dentro do struct como fontes de dados após a cláusula FROM.
• Use aliases quando apropriado.

Possível solução:

#standardSQL SELECT p.name, SUM(split_times) as total_race_time FROM racing.race_results AS r , UNNEST(r.participants) AS p , UNNEST(p.splits) AS split_times WHERE p.name LIKE 'R%' GROUP BY p.name ORDER BY total_race_time ASC;

Row	name	total_race_time.
1	Rudisha	102.19999999999999
2	Rotich	103.6

Clique em Verificar meu progresso para ver o objetivo. Execute uma consulta que listará o tempo total dos corredores com nomes que começam com R

Tarefa 9: Filtrar os valores da matriz

Você verificou que o tempo de volta mais rápido registrado na corrida de 800 m foi de 23,2 segundos, mas não sabe quem conseguiu esse tempo. Crie uma consulta que retorne esse resultado.

• Complete a consulta parcialmente escrita:

#standardSQL SELECT p.name, split_time FROM racing.race_results AS r , r.participants AS p , p.splits AS split_time WHERE split_time = ;

Possível solução:

#standardSQL SELECT p.name, split_time FROM racing.race_results AS r , UNNEST(r.participants) AS p , UNNEST(p.splits) AS split_time WHERE split_time = 23.2;

Row	name	split_time.
1	Kipketer	23.2

Clique em Verificar meu progresso para ver o objetivo. Execute a consulta para ver qual corredor fez a volta mais rápida

Parabéns!

Você ingeriu conjuntos de dados JSON, criou matrizes e structs e usou dados semiestruturados desaninhados para extrair insights.

Próximas etapas / Saiba mais

• Como leitura complementar, consulte Como trabalhar com matrizes.
• Confira estes laboratórios:
  • Como criar tabelas particionadas por data no BigQuery
  • Estimar tarifas de táxi com um modelo de previsão do BigQuery ML
  • Como ingerir novos conjuntos de dados no BigQuery

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 3 de fevereiro de 2024

Laboratório testado em 25 de agosto de 2023

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.