Esta página foi traduzida pela API Cloud Translation.

Transforme Big Data em insights com as Planilhas e Apresentações Google

1. Da análise de Big Data à apresentação de slides

Existem muitas ferramentas para os cientistas de dados realizarem análises de Big Data, mas, no final das contas, os analistas ainda precisam justificar os resultados para o gerenciamento. Muitos números no papel ou em um banco de dados dificilmente podem ser apresentados às principais partes interessadas. Este codelab intermediário do Google Apps Script usa duas plataformas para desenvolvedores do Google (Google Workspace e Console do Google Cloud) para ajudar você a automatizar essa etapa final.

As ferramentas para desenvolvedores do Google Cloud permitem realizar análises de dados profundas. Em seguida, você pode pegar os resultados, inseri-los em uma planilha e gerar uma apresentação de slides com os dados. Essa é uma maneira mais adequada de entregar dados ao gerenciamento. Este codelab aborda a API BigQuery do console do Cloud (como um serviço avançado do Apps Script) e os serviços integrados do Apps Script para as Planilhas Google e as Apresentações.

Motivação

O app de exemplo neste codelab foi inspirado por estes outros exemplos de código:

O app de amostra Google Apps Script BigQuery Service que tem código aberto no GitHub (em inglês).
O app de exemplo mostrado no vídeo do desenvolvedor Como gerar slides a partir de dados de planilhas e publicado nesta postagem do blog.
O app de exemplo apresentado no codelab da API Google Slides.

Embora o app de exemplo do codelab da API Slides também tenha o BigQuery e o Apresentações, ele é diferente do app de exemplo deste codelab de várias maneiras:

O app Node.js e o Apps Script.
Eles usam APIs REST, enquanto nós usamos os serviços do Apps Script.
Eles usam o Google Drive, mas não o Planilhas Google. Este app usa o Planilhas, mas não o Drive.

Neste codelab, queremos reunir várias tecnologias em um único app e, ao mesmo tempo, apresentar recursos e APIs do Google Cloud de uma forma parecida com um caso de uso real. O objetivo é inspirar você a usar sua imaginação e considerar usar o console do Cloud e o Google Workspace para resolver problemas desafiadores da organização e dos clientes.

O que você vai aprender

Como usar o Google Apps Script com vários serviços do Google
Como usar o Google BigQuery para analisar Big Data
Como criar uma Planilha Google e inserir dados nela
Como criar um gráfico no Planilhas
Como transferir dados e gráficos do Planilhas para um arquivo das Apresentações Google

O que é necessário

Um navegador da Web com acesso à Internet
Uma Conta do Google (as contas do Google Workspace podem exigir a aprovação do administrador)
Conhecimento básico do Planilhas Google
Saber ler a notação A1 em planilhas.
Habilidades básicas de JavaScript
Ter conhecimento de desenvolvimento no Apps Script é útil, mas não obrigatório.

2. Pesquisa

Como você usará este codelab/tutorial?

Leia o documento para fins informativos e, possivelmente, repasse para colegas técnicos

Explicar o máximo que puder e fazer o máximo de exercícios que puder

Vamos lá, vou fazer todo o codelab

Como você classificaria sua experiência com as ferramentas para desenvolvedores do Google Workspace? APIs?

Iniciante

Intermediário

Proficiente

Como você classificaria sua experiência especificamente com o Apps Script?

Iniciante

Intermediário

Proficiente

Como avaliaria sua experiência com as ferramentas para desenvolvedores do console do Cloud e APIs?

Iniciante

Intermediário

Proficiente

3. Visão geral

Agora que você sabe do que se trata este codelab, veja o que vai fazer:

Use uma amostra do Apps Script-BigQuery e comece a usá-la.
Com a amostra, aprenda a enviar uma consulta ao BigQuery e receber os resultados.
Crie uma planilha Google e insira os resultados do BigQuery nela.
Modifique o código para alterar levemente os dados retornados e inseridos na planilha.
Use o serviço Planilhas no Apps Script para criar um gráfico com os dados do BigQuery.
Use o serviço Apresentações para criar um arquivo do Apresentações Google.
Adicione um título e um subtítulo ao slide padrão.
Crie um slide com uma tabela de dados e exporte as células de dados da planilha para ela.
Crie outro slide e insira o gráfico de planilha nele.

Vamos começar com algumas informações básicas sobre Apps Script, BigQuery, Planilhas e Apresentações.

Google Apps Script e BigQuery

O Google Apps Script é uma plataforma de desenvolvimento do Google Workspace que opera em um nível superior às APIs REST do Google. Ele é um ambiente de desenvolvimento e hospedagem de aplicativos sem servidor que pode ser usado por desenvolvedores de todos os níveis. Basicamente, o Apps Script é um ambiente de execução JavaScript sem servidor para automação, extensão e integração do Google Workspace.

Ele usa JavaScript do lado do servidor, semelhante ao Node.js, mas se concentra na integração total com o Google Workspace e outros serviços do Google, em vez de uma hospedagem de aplicativos rápida e assíncrona e orientada a eventos. Além disso, o ambiente de desenvolvimento dele pode ser diferente do que você conhece. Com o Apps Script, é possível:

Os scripts podem ser desenvolvidos com um editor de código baseado em navegador, mas também podem ser desenvolvidos localmente com a clasp, a ferramenta de implantação de linha de comando do Apps Script.
Escreva código em uma versão especializada de JavaScript personalizada para acessar o Google Workspace e outros serviços do Google ou serviços externos (usando os serviços URL Fetch ou JDBC do Apps Script).
Evite escrever o código de autorização enquanto o Apps Script faz isso para você.
não hospedar seu aplicativo, já que ele é armazenado e executado nos servidores do Google na nuvem.

O Apps Script interage com outras tecnologias do Google de duas maneiras diferentes:

Como um serviço integrado
Como um serviço avançado

Um serviço integrado tem métodos de alto nível para interagir com os dados do usuário, outros sistemas do Google e sistemas externos. Os serviços avançados são basicamente wrappers simples de uma API Google Workspace ou da API REST do Google. Os serviços avançados oferecem cobertura completa da API REST e muitas vezes podem fazer mais do que os serviços integrados, mas exigem mais complexidade de código (embora ainda sejam mais fáceis de usar do que a API REST completa). É preciso ativar os serviços avançados para um projeto de script antes de usá-los.

Quando possível, os desenvolvedores devem usar um serviço integrado porque eles são mais fáceis de usar e fazem mais do que os serviços avançados. No entanto, algumas APIs do Google não têm serviços integrados. Nesses casos, usar um serviço avançado pode ser a única opção. Por exemplo, o Google BigQuery não tem um serviço integrado, mas existe o serviço do BigQuery. O BigQuery é um serviço do console do Cloud que permite usar a API Google BigQuery para fazer consultas em grandes volumes de dados (por exemplo, vários terabytes), mas ainda gera resultados em segundos.

Acessar Planilhas e Apresentações do Apps Script

Ao contrário do BigQuery, as Planilhas e as Apresentações têm serviços integrados. Elas também têm serviços avançados para acessar recursos encontrados apenas na API. Consulte os documentos dos serviços integrados do Planilhas e do Apresentações antes de partir para o código. Também existem documentos para os serviços avançados do Planilhas e do Apresentações.

4. Tarefa 1: execute o BigQuery e registre os resultados no app Planilhas

Introdução

Vamos fazer uma grande parte deste codelab com a primeira tarefa. Na verdade, quando você terminar, já estará na metade do codelab. Dividido em várias subseções, você vai:

Crie um projeto do Google Apps Script e do console do Cloud.
Ative o acesso ao serviço avançado do BigQuery.
Abra o editor de script e insira o código-fonte do aplicativo.
Navegar pelo processo de autorização de aplicativos (OAuth2).
Execute o aplicativo que envia uma solicitação ao BigQuery.
Revise o novo arquivo do Planilhas Google criado com os resultados do BigQuery.

Configuração

Para criar um projeto do Apps Script, acesse script.google.com e clique em Novo projeto.
Para renomear seu projeto do Apps Script, clique em Projeto sem título, digite um título e clique em Renomear.

Em seguida, crie um projeto do Console do Cloud para consultar dados no BigQuery.

Para criar um projeto do console do Cloud, use este link de atalho para criar um projeto, dê um nome a ele e clique em Criar.

Quando a criação do projeto for concluída, uma notificação vai aparecer na página. Verifique se o novo projeto está selecionado na lista de projetos na parte superior da página.
Clique em Menu e acesse APIs e Serviços > Tela de permissão OAuth (link direto).
Clique em Interno > Crie um app para os usuários do Google Workspace da sua organização.
No campo App name, digite "Big Data Codelab".
Insira os e-mails de contato nos campos Suporte ao usuário e Dados de contato do desenvolvedor.
Clique em Salvar e continuar > Salvar e continuar.
Clique em Mais na barra de navegação e selecione Configurações do projeto (link direto).
Copie o valor listado em Número do projeto. Um campo ID do projeto separado será usado posteriormente no codelab.

Em seguida, você vai conectar seu projeto do Apps Script ao projeto do console do Cloud.

Mude para o editor do App Script e clique em Configurações do projeto .
Em "Projeto do Google Cloud Platform (GCP)", clique em Alterar projeto.
Digite o número do projeto e clique em Definir projeto.
Em seguida, clique em Editor para começar a adicionar o serviço avançado do BigQuery.
Ao lado de Serviços, clique em Adicionar um serviço .
Na caixa de diálogo "Adicionar um serviço", selecione API BigQuery e clique em Adicionar.

A etapa final é ativar a API BigQuery no console do Cloud.

Para fazer isso, acesse o console do Cloud e clique em APIs e Serviços > Painel de controle. (Verifique se você ainda está no mesmo projeto criado na Etapa 3.)
Clique em Ativar APIs e serviços.
Pesquise por "big query", selecione a API BigQuery (não a API BigQuery Data Transfer) e clique em Ativar.

Agora está tudo pronto para você inserir o código do aplicativo, passar pelo processo de autorização e fazer a primeira iteração desse aplicativo funcionar.

Fazer upload e executar o aplicativo

No editor de script, substitua o bloco de código myFunction() padrão por este:

// File name for data results
var QUERY_NAME = "Most common words in all of Shakespeare's works";
// Replace this value with your Google Cloud Console Project ID
var PROJECT_ID = '';
if (!PROJECT_ID) throw Error('Project ID is required in setup');

/**
 * Runs a BigQuery query; puts results into a Sheet. You must turn on
 * the BigQuery advanced service before you can run this code.
 * @see https://developers.google.com/apps-script/advanced/bigquery#run_query
 * @see https://github.com/googleworkspace/apps-script-samples/blob/master/advanced/bigquery.gs
 *
 * @returns {Spreadsheet} Returns a spreadsheet with BigQuery results
 * @see https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet
 */
function runQuery() {
  // Replace sample with your own BigQuery query.
  var request = {
    query:
        'SELECT ' +
            'LOWER(word) AS word, ' +
            'SUM(word_count) AS count ' +
        'FROM [bigquery-public-data:samples.shakespeare] ' +
        'GROUP BY word ' +
        'ORDER BY count ' +
        'DESC LIMIT 10'
  };
  var queryResults = BigQuery.Jobs.query(request, PROJECT_ID);
  var jobId = queryResults.jobReference.jobId;

  // Wait for BigQuery job completion (with exponential backoff).
  var sleepTimeMs = 500;
  while (!queryResults.jobComplete) {
    Utilities.sleep(sleepTimeMs);
    sleepTimeMs *= 2;
    queryResults = BigQuery.Jobs.getQueryResults(PROJECT_ID, jobId);
  }

  // Get all results from BigQuery.
  var rows = queryResults.rows;
  while (queryResults.pageToken) {
    queryResults = BigQuery.Jobs.getQueryResults(PROJECT_ID, jobId, {
      pageToken: queryResults.pageToken
    });
    rows = rows.concat(queryResults.rows);
  }

  // Return null if no data returned.
  if (!rows) {
    return Logger.log('No rows returned.');
  }

  // Create the results spreadsheet.
  var spreadsheet = SpreadsheetApp.create(QUERY_NAME);
  var sheet = spreadsheet.getActiveSheet();

  // Add headers to Sheet.
  var headers = queryResults.schema.fields.map(function(field) {
    return field.name.toUpperCase();
  });
  sheet.appendRow(headers);

  // Append the results.
  var data = new Array(rows.length);
  for (var i = 0; i < rows.length; i++) {
    var cols = rows[i].f;
    data[i] = new Array(cols.length);
    for (var j = 0; j < cols.length; j++) {
      data[i][j] = cols[j].v;
    }
  }

  // Start storing data in row 2, col 1
  var START_ROW = 2;      // skip header row
  var START_COL = 1;
  sheet.getRange(START_ROW, START_COL, rows.length, headers.length).setValues(data);

  Logger.log('Results spreadsheet created: %s', spreadsheet.getUrl());
}

Clique em Salvar .
Ao lado de Code.gs, clique em Mais > Renomear. Altere o título de Code.gs para bq-sheets-slides.js.
Agora vamos revisar o código que consulta o BigQuery e grava os resultados em uma planilha Google. Você pode vê-lo perto da parte de cima do runQuery():

SELECT
    LOWER(word) AS word,
    SUM(word_count) AS count
FROM [bigquery-public-data:samples.shakespeare]
GROUP BY word
ORDER BY count
DESC LIMIT 10

Essa consulta examina as obras de Shakespeare, que fazem parte do conjunto de dados público do BigQuery, e retorna as 10 palavras que mais aparecem em todas as obras, classificadas em ordem decrescente de frequência. Você tem uma ideia de como o BigQuery pode ser útil quando imagina quanto trabalho seria necessário fazer essa compilação manualmente.

A função também declara uma variável PROJECT_ID que requer um ID de projeto válido do Console do Cloud. A instrução if na variável evita que o aplicativo prossiga sem o ID do projeto.

Alterne para seu projeto do Console do Cloud, clique em Mais na barra de navegação e selecione Configurações do projeto.
Copie o valor listado em ID do projeto.
Volte ao editor do App Script, localize a variável PROJECT_ID em bq-sheets-slides.js e adicione o valor.
Clique em Salvar > Executar.
Clique em Revisar permissões para continuar.

Assim que o script começa a ser executado, o registro de execução integrado é aberto e registra as ações do script em tempo real.

Quando o registro de execução mostrar "Execução concluída", acesse o Google Drive (drive.google.com) e encontre o arquivo do Planilhas Google chamado "Most common words in all of Shakespeare's works". (ou o nome atribuído à variável QUERY_NAME, se você a atualizou):
Abra a planilha para visualizar as 10 palavras mais comuns e suas contagens totais classificadas em ordem decrescente:

Resumo da tarefa 1

Para revisar, você executou um código que consultou todas as obras de Shakespeare analisando cada palavra das peças do autor. Ele contou as palavras e as classificou em ordem decrescente de aparência. Você também usou o serviço integrado do Apps Script para o app Planilhas Google para exibir esses dados.

O código que você usou para bq-sheets-slides.js também pode ser encontrado na pasta step1 do repositório do GitHub deste codelab em github.com/googlecodelabs/bigquery-sheets-slides (link em inglês). O código foi inspirado neste exemplo original na página de serviços avançados do BigQuery (em inglês), que executou uma consulta um pouco diferente para recuperar as palavras mais comuns com 10 ou mais caracteres usados por Shakespeare. Também é possível ver um exemplo no repositório do GitHub.

Se você tiver interesse em outras consultas que podem ser criadas com as obras de Shakespeare ou com outras tabelas de dados públicas, acesse Como consultar as tabelas de exemplo do BigQuery e este repositório do GitHub (em inglês).

Também é possível executar consultas usando a página do BigQuery no console do Cloud antes de executá-las no Apps Script. Para encontrá-lo, clique em Menu e acesse interface do BigQuery > Espaço de trabalho SQL (link direto). Por exemplo, veja como nossa consulta aparece na interface gráfica do BigQuery:

BigQueryUI

5. Tarefa 2: crie um gráfico no Planilhas Google

O objetivo do runQuery() é usar o BigQuery e enviar os resultados dos dados para uma planilha Google. Em seguida, precisamos fazer um gráfico usando os dados. Vamos criar uma nova função com o nome createColumnChart() que chame as Planilhas Google. newChart().

No editor do Apps Script, adicione a função createColumnChart() ao bq-sheets-slides.js após runQuery(). O código recebe a planilha e solicita um gráfico de colunas com todos os dados. O intervalo de dados começa na célula A2 porque a primeira linha contém os cabeçalhos das colunas.

/**
 * Uses spreadsheet data to create a column chart.
 * @param {Spreadsheet} Spreadsheet containing results data
 * @returns {EmbeddedChart} Visualizes the results
 * @see https://developers.google.com/apps-script/reference/spreadsheet/embedded-chart
 */
function createColumnChart(spreadsheet) {
  // Retrieve the populated (first) Sheet.
  var sheet = spreadsheet.getSheets()[0];
  // Data range in Sheet is from cell A2 to B11.
  var START_CELL = 'A2';  // skip header row
  var END_CELL = 'B11';
  // Place chart on Sheet starting on cell E5.
  var START_ROW = 5;      // row 5
  var START_COL = 5;      // col E
  var OFFSET = 0;

  // Create & place chart on the Sheet using above values.
  var chart = sheet.newChart()
     .setChartType(Charts.ChartType.COLUMN)
     .addRange(sheet.getRange(START_CELL + ':' + END_CELL))
     .setPosition(START_ROW, START_COL, OFFSET, OFFSET)
     .build();
  sheet.insertChart(chart);
}

A função createColumnChart() requer um parâmetro de objeto da planilha. Portanto, precisamos atualizar runQuery() para retornar um objeto spreadsheet que podemos transmitir para createColumnChart(). No final de runQuery(), retorne o objeto spreadsheet depois de registrar a criação da planilha:

  Logger.log('Results spreadsheet created: %s', spreadsheet.getUrl());

  // NEW: Return the spreadsheet object for later use.
  return spreadsheet;
}

Crie uma função createBigQueryPresentation() para chamar runQuery() e createColumnChart(). A prática recomendada é separar logicamente o BigQuery e a funcionalidade de criação de gráficos:

/**
 * Runs the query, adds data and a chart to a spreadsheet.
 */
function createBigQueryPresentation() {
  var spreadsheet = runQuery();
  createColumnChart(spreadsheet);
}

Você realizou duas etapas importantes acima: retornar o objeto da planilha e criar a função de entrada. Para tornar o runQuery() mais utilizável, precisamos mover a linha de registro de runQuery() para createBigQueryPresentation(). Seu método ficará assim:

/**
 * Runs a BigQuery query, adds data and a chart to a spreadsheet.
 */
function createBigQueryPresentation() {
  var spreadsheet = runQuery();
  Logger.log('Results spreadsheet created: %s', spreadsheet.getUrl()); // MOVED HERE
  createColumnChart(spreadsheet);
}

Com as mudanças acima (exceto para PROJECT_ID), seu bq-sheets-slides.js ficará assim. Esse código também pode ser encontrado em step2 do repositório do GitHub (link em inglês).

// File name for data results
var QUERY_NAME = "Most common words in all of Shakespeare's works";
// Replace this value with your Google Cloud Console Project ID
var PROJECT_ID = '';
if (!PROJECT_ID) throw Error('Project ID is required in setup');

/**
 * Runs a BigQuery query; puts results into a sheet. You must turn on
 * the BigQuery advanced service before you can run this code.
 * @see https://developers.google.com/apps-script/advanced/bigquery#run_query
 * @see https://github.com/googleworkspace/apps-script-samples/blob/master/advanced/bigquery.gs
 *
 * @returns {Spreadsheet} Returns a spreadsheet with BigQuery results
 * @see https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet
 */
function runQuery() {
  // Replace sample with your own BigQuery query.
  var request = {
    query:
        'SELECT ' +
            'LOWER(word) AS word, ' +
            'SUM(word_count) AS count ' +
        'FROM [bigquery-public-data:samples.shakespeare] ' +
        'GROUP BY word ' +
        'ORDER BY count ' +
        'DESC LIMIT 10'
  };
  var queryResults = BigQuery.Jobs.query(request, PROJECT_ID);
  var jobId = queryResults.jobReference.jobId;

  // Wait for BigQuery job completion (with exponential backoff).
  var sleepTimeMs = 500;
  while (!queryResults.jobComplete) {
    Utilities.sleep(sleepTimeMs);
    sleepTimeMs *= 2;
    queryResults = BigQuery.Jobs.getQueryResults(PROJECT_ID, jobId);
  }

  // Get all results from BigQuery.
  var rows = queryResults.rows;
  while (queryResults.pageToken) {
    queryResults = BigQuery.Jobs.getQueryResults(PROJECT_ID, jobId, {
      pageToken: queryResults.pageToken
    });
    rows = rows.concat(queryResults.rows);
  }

  // Return null if no data returned.
  if (!rows) {
    return Logger.log('No rows returned.');
  }

  // Create the results spreadsheet.
  var spreadsheet = SpreadsheetApp.create(QUERY_NAME);
  var sheet = spreadsheet.getActiveSheet();

  // Add headers to sheet.
  var headers = queryResults.schema.fields.map(function(field) {
    return field.name.toUpperCase();
  });
  sheet.appendRow(headers);

  // Append the results.
  var data = new Array(rows.length);
  for (var i = 0; i < rows.length; i++) {
    var cols = rows[i].f;
    data[i] = new Array(cols.length);
    for (var j = 0; j < cols.length; j++) {
      data[i][j] = cols[j].v;
    }
  }

  // Start storing data in row 2, col 1
  var START_ROW = 2;      // skip header row
  var START_COL = 1;
  sheet.getRange(START_ROW, START_COL, rows.length, headers.length).setValues(data);

  // Return the spreadsheet object for later use.
  return spreadsheet;
}

/**
 * Uses spreadsheet data to create a columnar chart.
 * @param {Spreadsheet} Spreadsheet containing results data
 * @returns {EmbeddedChart} Visualizes the results
 * @see https://developers.google.com/apps-script/reference/spreadsheet/embedded-chart
 */
function createColumnChart(spreadsheet) {
  // Retrieve the populated (first) sheet.
  var sheet = spreadsheet.getSheets()[0];
  // Data range in sheet is from cell A2 to B11.
  var START_CELL = 'A2';  // skip header row
  var END_CELL = 'B11';
  // Place chart on Sheet starting on cell E5.
  var START_ROW = 5;      // row 5
  var START_COL = 5;      // col E
  var OFFSET = 0;

  // Create & place chart on the sheet using above values.
  var chart = sheet.newChart()
     .setChartType(Charts.ChartType.COLUMN)
     .addRange(sheet.getRange(START_CELL + ':' + END_CELL))
     .setPosition(START_ROW, START_COL, OFFSET, OFFSET)
     .build();
  sheet.insertChart(chart);
}

/**
 * Runs a BigQuery query, adds data and a chart to a spreadsheet.
 */
function createBigQueryPresentation() {
  var spreadsheet = runQuery();
  Logger.log('Results spreadsheet created: %s', spreadsheet.getUrl());
  createColumnChart(spreadsheet);
}

No editor de script, salve o projeto. Em seguida, selecione createBigQueryPresentation na lista de funções e clique em Executar. Depois de concluída, outra planilha é criada em seu Google Drive, mas desta vez um gráfico é incluído na planilha ao lado dos dados:

Planilha com gráfico

6. Tarefa 3: coloque os dados dos resultados em uma apresentação de slides

Na parte final deste codelab, você vai criar um arquivo das Apresentações Google, adicionar o título e o subtítulo ao slide correspondente e criar slides para as células de dados e o gráfico.

No editor do Apps Script, adicione a função createSlidePresentation() ao bq-sheets-slides.js após createColumnChart(). Todo o trabalho na apresentação de slides ocorre nessa função. Vamos começar com a criação de uma apresentação de slides e adicionar um título e um subtítulo ao slide padrão.

/**
 * Create presentation with spreadsheet data and a chart
 * @param {Spreadsheet} Spreadsheet containing results data
 * @param {EmbeddedChart} Sheets chart to embed on a slide
 * @returns {Presentation} Slide deck with the results
  * @see https://developers.google.com/apps-script/reference/slides/presentation
 */
function createSlidePresentation(spreadsheet, chart) {
  // Create the presentation.
  var deck = SlidesApp.create(QUERY_NAME);

  // Populate the title slide.
  var [title, subtitle] = deck.getSlides()[0].getPageElements();
  title.asShape().getText().setText(QUERY_NAME);
  subtitle.asShape().getText().setText('using Google Cloud Console and Google Workspace APIs:\n' +
    'Google Apps Script, BigQuery, Sheets, Slides');

A próxima etapa no createSlidePresentation() é importar os dados de células do Planilhas Google para a nova apresentação de slides. Adicione este snippet de código à função:

  // Data range to copy is from cell A1 to B11
  var START_CELL = 'A1';  // include header row
  var END_CELL = 'B11';
  // Add the table slide and insert an empty table on it with
  // the dimensions of the data range; fails if the sheet is empty.
  var tableSlide = deck.appendSlide(SlidesApp.PredefinedLayout.BLANK);
  var sheetValues = spreadsheet.getSheets()[0].getRange(
      START_CELL + ':' + END_CELL).getValues();
  var table = tableSlide.insertTable(sheetValues.length, sheetValues[0].length);

  // Populate the table with spreadsheet data.
  for (var i = 0; i < sheetValues.length; i++) {
    for (var j = 0; j < sheetValues[0].length; j++) {
      table.getCell(i, j).getText().setText(String(sheetValues[i][j]));
    }
  }

A etapa final no createSlidePresentation() é adicionar mais um slide, importar o gráfico da nossa planilha e retornar o objeto Presentation. Adicione este snippet de código à função:

  // Add a chart slide and insert the chart on it.
  var chartSlide = deck.appendSlide(SlidesApp.PredefinedLayout.BLANK);
  chartSlide.insertSheetsChart(chart);

  // Return the presentation object for later use.
  return deck;
}

Agora que nossa função está concluída, olhe novamente para a assinatura dela. O createSlidePresentation() requer parâmetros de objetos de planilha e gráfico. Já ajustamos o runQuery() para retornar o objeto Spreadsheet, mas precisamos fazer uma mudança semelhante em createColumnChart() para que retorne um objeto de gráfico (EmbeddedChart). Retorne a createColumnChart() e adicione o seguinte snippet de código ao final da função:

  // NEW: Return the chart object for later use.
  return chart;
}

Como createColumnChart() agora retorna um objeto de gráfico, precisamos salvar o gráfico em uma variável. Em seguida, transmitimos ambas a planilha e as variáveis do gráfico para createSlidePresentation(). Além disso, como registramos o URL da planilha recém-criada, vamos registrar o URL da nova apresentação de slides. Atualize o createBigQueryPresentation() para que ele fique assim:

/**
 * Runs a BigQuery query, adds data and a chart to a spreadsheet,
 * and adds the data and chart to a new slide presentation.
 */
function createBigQueryPresentation() {
  var spreadsheet = runQuery();
  Logger.log('Results spreadsheet created: %s', spreadsheet.getUrl());
  var chart = createColumnChart(spreadsheet); // UPDATED
  var deck = createSlidePresentation(spreadsheet, chart); // NEW
  Logger.log('Results slide deck created: %s', deck.getUrl()); // NEW
}

Salve e execute createBigQueryPresentation() novamente. Antes de ser executado, o aplicativo precisa de mais um conjunto de permissões do usuário para visualizar e gerenciar apresentações do Apresentações Google. Depois que você revisar e autorizar essas permissões, o processo vai continuar como antes.
Agora, além da planilha criada, você também deve gerar uma nova apresentação com três slides (título, tabela de dados, gráfico de dados), conforme mostrado abaixo:

7. Conclusão

Parabéns, você criou um aplicativo que usa os dois lados do Google Cloud. Ela faz uma solicitação ao Google BigQuery que consulta um dos conjuntos de dados públicos, cria uma planilha do Planilhas Google para armazenar os resultados, adiciona um gráfico com base nos dados e, por fim, cria uma apresentação Google com os dados e os resultados do gráfico da planilha.

Essas etapas são o que você fez tecnicamente. De modo geral, você passou da análise de Big Data para um resultado que pode apresentar às partes interessadas: tudo automatizado usando código. Esperamos que este exemplo inspire você a personalizá-lo para seus próprios projetos. Ao final deste codelab, forneceremos algumas sugestões sobre como você pode melhorar ainda mais o app de exemplo.

Com as mudanças da tarefa final (exceto para PROJECT_ID), seu bq-sheets-slides.js ficará assim:

/**
 * Copyright 2018 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at apache.org/licenses/LICENSE-2.0.
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// File name for data results
var QUERY_NAME = "Most common words in all of Shakespeare's works";
// Replace this value with your Google Cloud Console Project ID
var PROJECT_ID = '';
if (!PROJECT_ID) throw Error('Project ID is required in setup');

/**
 * Runs a BigQuery query; puts results into a spreadsheet. You must turn on
 * the BigQuery advanced service before you can run this code.
 * @see https://developers.google.com/apps-script/advanced/bigquery#run_query
 * @see https://github.com/googleworkspace/apps-script-samples/blob/master/advanced/bigquery.gs
 *
 * @returns {Spreadsheet} Returns a spreadsheet with BigQuery results
 * @see https://developers.google.com/apps-script/reference/spreadsheet/spreadsheet
 */
function runQuery() {
  // Replace sample with your own BigQuery query.
  var request = {
    query:
        'SELECT ' +
            'LOWER(word) AS word, ' +
            'SUM(word_count) AS count ' +
        'FROM [bigquery-public-data:samples.shakespeare] ' +
        'GROUP BY word ' +
        'ORDER BY count ' +
        'DESC LIMIT 10'
  };
  var queryResults = BigQuery.Jobs.query(request, PROJECT_ID);
  var jobId = queryResults.jobReference.jobId;

  // Wait for BigQuery job completion (with exponential backoff).
  var sleepTimeMs = 500;
  while (!queryResults.jobComplete) {
    Utilities.sleep(sleepTimeMs);
    sleepTimeMs *= 2;
    queryResults = BigQuery.Jobs.getQueryResults(PROJECT_ID, jobId);
  }

  // Get all results from BigQuery.
  var rows = queryResults.rows;
  while (queryResults.pageToken) {
    queryResults = BigQuery.Jobs.getQueryResults(PROJECT_ID, jobId, {
      pageToken: queryResults.pageToken
    });
    rows = rows.concat(queryResults.rows);
  }

  // Return null if no data returned.
  if (!rows) {
    return Logger.log('No rows returned.');
  }

  // Create the results spreadsheet.
  var spreadsheet = SpreadsheetApp.create(QUERY_NAME);
  var sheet = spreadsheet.getActiveSheet();

  // Add headers to sheet.
  var headers = queryResults.schema.fields.map(function(field) {
    return field.name.toUpperCase();
  });
  sheet.appendRow(headers);

  // Append the results.
  var data = new Array(rows.length);
  for (var i = 0; i < rows.length; i++) {
    var cols = rows[i].f;
    data[i] = new Array(cols.length);
    for (var j = 0; j < cols.length; j++) {
      data[i][j] = cols[j].v;
    }
  }

  // Start storing data in row 2, col 1
  var START_ROW = 2;      // skip header row
  var START_COL = 1;
  sheet.getRange(START_ROW, START_COL, rows.length, headers.length).setValues(data);

  // Return the spreadsheet object for later use.
  return spreadsheet;
}

/**
 * Uses spreadsheet data to create a column chart.
 * @param {Spreadsheet} Spreadsheet containing results data
 * @returns {EmbeddedChart} Visualizes the results
 * @see https://developers.google.com/apps-script/reference/spreadsheet/embedded-chart
 */
function createColumnChart(spreadsheet) {
  // Retrieve the populated (first) sheet.
  var sheet = spreadsheet.getSheets()[0];
  // Data range in sheet is from cell A2 to B11.
  var START_CELL = 'A2';  // skip header row
  var END_CELL = 'B11';
  // Place chart on sheet starting on cell E5.
  var START_ROW = 5;      // row 5
  var START_COL = 5;      // col E
  var OFFSET = 0;

  // Create & place chart on the sheet using above values.
  var chart = sheet.newChart()
     .setChartType(Charts.ChartType.COLUMN)
     .addRange(sheet.getRange(START_CELL + ':' + END_CELL))
     .setPosition(START_ROW, START_COL, OFFSET, OFFSET)
     .build();
  sheet.insertChart(chart);
  
  // Return the chart object for later use.
  return chart;
}

/**
 * Create presentation with spreadsheet data and a chart
 * @param {Spreadsheet} Spreadsheet containing results data
 * @param {EmbeddedChart} Sheets chart to embed on a slide
 * @returns {Presentation} Slide deck with the results
 * @see https://developers.google.com/apps-script/reference/slides/presentation
 */
function createSlidePresentation(spreadsheet, chart) {
  // Create the presentation.
  var deck = SlidesApp.create(QUERY_NAME);

  // Populate the title slide.
  var [title, subtitle] = deck.getSlides()[0].getPageElements();
  title.asShape().getText().setText(QUERY_NAME);
  subtitle.asShape().getText().setText('using Google Cloud Console and Google Workspace APIs:\n' +
    'Google Apps Script, BigQuery, Sheets, Slides');

  // Data range to copy is from cell A1 to B11
  var START_CELL = 'A1';  // include header row
  var END_CELL = 'B11';
  // Add the table slide and insert an empty table on it with
  // the dimensions of the data range; fails if the sheet is empty.
  var tableSlide = deck.appendSlide(SlidesApp.PredefinedLayout.BLANK);
  var sheetValues = spreadsheet.getSheets()[0].getRange(
      START_CELL + ':' + END_CELL).getValues();
  var table = tableSlide.insertTable(sheetValues.length, sheetValues[0].length);

  // Populate the table with spreadsheet data.
  for (var i = 0; i < sheetValues.length; i++) {
    for (var j = 0; j < sheetValues[0].length; j++) {
      table.getCell(i, j).getText().setText(String(sheetValues[i][j]));
    }
  }

  // Add a chart slide and insert the chart on it.
  var chartSlide = deck.appendSlide(SlidesApp.PredefinedLayout.BLANK);
  chartSlide.insertSheetsChart(chart);

  // Return the presentation object for later use.
  return deck;
}

/**
 * Runs a BigQuery query, adds data and a chart to a spreadsheet,
 * and adds the data and chart to a new slide presentation.
 */
function createBigQueryPresentation() {
  var spreadsheet = runQuery();
  Logger.log('Results spreadsheet created: %s', spreadsheet.getUrl());
  var chart = createColumnChart(spreadsheet);
  var deck = createSlidePresentation(spreadsheet, chart);
  Logger.log('Results slide deck created: %s', deck.getUrl());
}

Esse exemplo de código também pode ser encontrado na pasta final no repositório do GitHub (link em inglês).

8. Outros recursos

Confira abaixo mais recursos para você se aprofundar no que foi abordado neste codelab e conhecer outras maneiras de acessar as ferramentas para desenvolvedores do Google de maneira programática.

Recursos para este aplicativo

Documentação

Site da documentação do Google Apps Script
Apps Script: serviço das Planilhas
Apps Script: serviço do Apresentações
Apps Script: serviço avançado do BigQuery

Vídeos

Notícias e atualizações

Blog do Google Cloud Platform
Blog de análise de dados do Google Cloud
Blog do Google Developers
Twitter: Google Developers (@managing)
Blog de desenvolvedores do Google Workspace
Twitter: Google Workspace Developers (@workspacedevs)

Outros codelabs

Básico

[Planilhas Google] Noções básicas do Apps Script com o Planilhas Google
[APIs REST] Usar o Google Workspace e APIs do Google para acessar arquivos e pastas no seu Google Drive

Intermediário

[Apps Script] Ferramenta de linha de comando Apps Script CLASP
[Apps Script] Complementos do Google Workspace para o Gmail
[Apps Script] Bots personalizados para o Hangouts Chat
[APIs REST] Usar o Planilhas Google como a ferramenta de relatórios do seu aplicativo
[APIs REST] Gerar apresentações Google usando a API BigQuery

9. Próxima etapa: desafios no código

Confira abaixo diferentes maneiras de aprimorar ou ampliar o exemplo que criamos neste codelab. Esta lista não é completa, mas fornece algumas ideias inspiradoras sobre como você pode dar o próximo passo.

Aplicativo: você não quer se limitar ao uso de JavaScript ou às restrições impostas pelo Apps Script? Faça a portabilidade deste aplicativo para sua linguagem de programação favorita que usa as APIs REST para Google BigQuery, Planilhas e Apresentações.
BigQuery: tente fazer uma consulta diferente no conjunto de dados de Shakespeare do seu interesse. Outra amostra de consulta pode ser encontrada no app de amostra do BigQuery no Apps Script (em inglês).
BigQuery: teste alguns dos outros conjuntos de dados públicos do BigQuery para encontrar o que seja mais significativo para você.
BigQuery: anteriormente, mencionamos outras consultas que podem ser criadas com as obras de Shakespeare ou outras tabelas de dados públicas. Eles estão disponíveis nesta página da Web e neste repositório do GitHub (links em inglês).
Planilhas: teste outros tipos de gráficos na Galeria de gráficos.
Planilhas e BigQuery—Use seu próprio grande conjunto de dados de planilha. Em 2016, a equipe do BigQuery lançou um recurso para os desenvolvedores usarem uma planilha como fonte de dados. Para mais informações, acesse (Integração do Google BigQuery com o Google Drive.
Apresentações: adicione outros slides à apresentação gerada, como imagens ou outros recursos vinculados à análise de Big Data. Esta é a documentação de referência do serviço integrado do Apresentações.
Google Workspace: use outros serviços do Google Workspace ou os serviços integrados do Google no Apps Script. como Gmail, Agenda, Documentos, Drive, Maps, Analytics, YouTube etc., entre outros serviços avançados. Para saber mais, consulte a visão geral de referências dos serviços integrados e avançados.