Rastreabilidade da cadeia de suprimentos com o BigQuery Graph

1. Introdução

Neste codelab, você vai aprender a usar o BigQuery Graph para resolver problemas complexos de cadeia de suprimentos e logística.

Você vai modelar uma rede de cadeia de suprimentos de restaurante com foco na segurança alimentar e no controle de qualidade. Quando surge um problema de segurança alimentar, como um ingrediente contaminado de um fornecedor, o tempo é essencial. Identificar o "raio de impacto" e executar um recall cirúrgico rapidamente pode economizar custos e proteger os clientes.

Alerta de contaminação de alimentos em restaurante

Os modelos relacionais tradicionais exigem operações JOIN complexas e de várias etapas para rastrear itens em vários estágios (fornecedor -> CD -> cozinha industrial -> loja -> item finalizado). Com o BigQuery Graph, modelamos essas conexões diretamente, permitindo consultas intuitivas e rápidas usando o padrão ISO GQL (Graph Query Language).

O que você vai aprender

  • Como definir um modelo de gráfico com base em tabelas atuais do BigQuery.
  • Como criar um gráfico de propriedades no BigQuery.
  • Como executar consultas de travessia para rastrear impactos upstream e downstream.

O que é necessário

  • um projeto do Google Cloud com faturamento ativado
  • Google Cloud Shell.

Custo estimado

O custo esperado deste laboratório é de menos de US$5 em taxas de análise do BigQuery, bem dentro das alocações do nível sem custo financeiro para novos usuários.

2. Configuração e requisitos

Abrir o Cloud Shell

A maior parte do trabalho será feita no Cloud Shell, um ambiente carregado com tudo o que você precisa para usar o Google Cloud.

  1. Acesse o Console do Google Cloud.
  2. Clique no ícone Ativar o Cloud Shell na barra de ferramentas no canto superior direito.
  3. Clique em Continuar se necessário.

Configurar variáveis de ambiente

No Cloud Shell, defina o ID do projeto para simplificar comandos futuros.

export PROJECT_ID=$(gcloud config get-value project)

Ativar a BigQuery API

Verifique se a API BigQuery está ativada. Ela geralmente é ativada por padrão, mas é melhor ter certeza.

gcloud services enable bigquery.googleapis.com

3. Como criar o esquema e as tabelas

Você vai criar um conjunto de dados e tabelas que representam os componentes da sua cadeia de suprimentos:

  • item: a definição genérica do item (por exemplo, tomate, frango).
  • location: instalações (fornecedores, centros de distribuição, cafés).
  • itemlocation: a tabela de interseção que representa os locais de inventário.
  • bom: lista de materiais (define relações de peso, por exemplo, o item A vai no item B).
  • makes: mapeia itemlocation para item.
  • stored_at: mapeia itemlocation para location.

Criar conjunto de dados

É possível executar os comandos SQL neste laboratório prático usando o Cloud Shell ou o Console do BigQuery.

Para usar o console do BigQuery:

  1. Abra o console do BigQuery em uma nova guia.
  2. Cole cada snippet SQL deste laboratório no editor e clique no botão Executar para executar.

Editor do BigQuery

Execute o comando a seguir no Cloud Shell ou use o console do BigQuery para criar o esquema. Você vai usar variáveis de nó no SQL.

Esquema de dados do BigQuery

Observação: (1) Para executar isso no Google Colab, também é possível usar os comandos mágicos do BigQuery: %%bigquery. O snippet a seguir cria o esquema do restaurante no seu projeto para armazenar os dados do gráfico. (2) Use %%bigquery –project <PROJECT_ID> se estiver executando em um Google Colab. Verifique se o campo PROJECT_ID está mapeado para o projeto adequado que você pretende usar: PROJECT_ID = "argolis-project-340214" # @param {"type":"string"} (3) Se você estiver usando o Colab, dependendo dos seus requisitos, será necessário instalar algumas bibliotecas. Se você for usar a visualização de gráficos, instale a biblioteca com o pip: spanner-graph-notebook==1.1.5

Recurso mágico do BigQuery no Colab

%%bigquery --project=$PROJECT_ID
CREATE SCHEMA IF NOT EXISTS restaurant ;

Criar tabelas

Execute o código SQL a seguir para criar as tabelas.

%%bigquery --project=$PROJECT_ID
-- 1. Item Table
DROP TABLE IF EXISTS `restaurant.item`;
CREATE TABLE `restaurant.item` (
  itemKey STRING,
  itemName STRING,
  itemCategory STRING,
  shelfLifeDays INT64,
  PRIMARY KEY (itemKey) NOT ENFORCED
);

-- 2. Location Table
DROP TABLE IF EXISTS `restaurant.location`;
CREATE TABLE `restaurant.location` (
  locationKey STRING,
  locationType STRING,
  locationCity STRING,
  locationState STRING,
  dunsNumber INT64,
  PRIMARY KEY (locationKey) NOT ENFORCED
);
-- 3. ItemLocation Table
DROP TABLE IF EXISTS `restaurant.itemlocation`;
CREATE TABLE `restaurant.itemlocation` (
  itemLocationKey STRING,
  itemKey STRING,
  locationKey STRING,
  variants INT64,
  PRIMARY KEY (itemLocationKey) NOT ENFORCED,
  -- Foreign Key Definitions
  FOREIGN KEY (itemKey) REFERENCES `restaurant.item`(itemKey) NOT ENFORCED,
  FOREIGN KEY (locationKey) REFERENCES `restaurant.location`(locationKey) NOT ENFORCED
);

-- 4. BOM Table
DROP TABLE IF EXISTS `restaurant.bom`;
CREATE TABLE `restaurant.bom` (
  bomKey INT64,
  parentItemLocation STRING,
  childItemLocation STRING,
  childQuantity FLOAT64,
  PRIMARY KEY (bomKey) NOT ENFORCED
);

-- 5. Makes Table
DROP TABLE IF EXISTS `restaurant.makes`;
CREATE TABLE `restaurant.makes` (
  itemLocationKey STRING,
  itemKey STRING,
  locationKey STRING,
  variants INT64,
  PRIMARY KEY (itemLocationKey) NOT ENFORCED
);

DROP TABLE IF EXISTS `restaurant.stored_at`;
CREATE TABLE `restaurant.stored_at` (
  itemLocationKey STRING,
  itemKey STRING,
  locationKey STRING,
  variants INT64,
  PRIMARY KEY (itemLocationKey) NOT ENFORCED
);

4. Carregando dados de amostra

Para que este laboratório seja totalmente independente, você vai preencher as tabelas com dados de amostra usando instruções SQL LOAD DATA. Isso representa uma rede que começa com um fornecedor, passa por um centro de distribuição (CD) e uma cozinha industrial e chega a um café de varejo.

Execute as seguintes consultas SQL para carregar os dados:

Carregamento de dados do BigQuery

Observação: você pode omitir %%bigquery se estiver executando diretamente no BigQuery Studio.

%%bigquery --project=$PROJECT_ID
-- Load Item
LOAD DATA OVERWRITE `restaurant.item`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/item2.csv'], skip_leading_rows = 1);

-- Load Location
LOAD DATA OVERWRITE `restaurant.location`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/location.csv'], skip_leading_rows = 1);

-- Load ItemLocation
LOAD DATA OVERWRITE `restaurant.itemlocation`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/itemlocation.csv'], skip_leading_rows = 1);

-- Load BOM
LOAD DATA OVERWRITE `restaurant.bom`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/bom2.csv'], skip_leading_rows = 1);

-- Load Makes
LOAD DATA OVERWRITE `restaurant.makes`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/makes.csv'], skip_leading_rows = 1);

-- Load StoredAt
LOAD DATA OVERWRITE `restaurant.stored_at`
FROM FILES (format = 'CSV', uris = ['gs://supply_chain_demo/itemlocation.csv'], skip_leading_rows = 1);

5. Adicionar restrições e definir o gráfico

Antes de criar o gráfico, declare as relações semânticas usando as restrições de chave primária e chave estrangeira do SQL padrão. Eles orientam o BigQuery a entender os identificadores de nós e conectar tabelas de arestas a tabelas de nós.

Criar gráfico de propriedades

Agora, você une essas tabelas em uma única estrutura de grafo coesa chamada restaurant.bombod.

Você define:

  • Nós: item, location, itemlocation
  • Bordas: makes, stored_at e consists_of (BOM)
%%bigquery --project=$PROJECT_ID

CREATE OR REPLACE PROPERTY GRAPH `restaurant.bombod`
NODE TABLES (
  `restaurant.item` KEY (itemKey) LABEL item PROPERTIES ALL COLUMNS,
  `restaurant.location` KEY (locationKey) LABEL location PROPERTIES ALL COLUMNS,
  `restaurant.itemlocation` KEY (itemLocationKey) LABEL itemlocation PROPERTIES ALL COLUMNS
)
EDGE TABLES (
  `restaurant.makes`
    KEY (itemLocationKey)
    SOURCE KEY (itemLocationKey) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    DESTINATION KEY (itemKey) REFERENCES `restaurant.item`(itemKey)
    LABEL makes PROPERTIES ALL COLUMNS,
    
  `restaurant.bom`
    KEY (bomKey)
    SOURCE KEY (childItemLocation) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    DESTINATION KEY (parentItemLocation) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    LABEL consists_of PROPERTIES ALL COLUMNS,
    
  `restaurant.stored_at`
    KEY (itemLocationKey)
    SOURCE KEY (itemLocationKey) REFERENCES `restaurant.itemlocation`(itemLocationKey)
    DESTINATION KEY (locationKey) REFERENCES `restaurant.location`(locationKey)
    LABEL stored_at PROPERTIES ALL COLUMNS
);

6. Visualizar a cadeia de suprimentos

Você pode executar uma consulta de travessia de cima para baixo para ver toda a rede da cadeia de suprimentos. Em um notebook padrão ou em uma interface que oferece suporte a isso (como %%bigquery --graph), isso retorna um mapa visual.

Use consultas de gráfico absolutas para configurar nós e arestas.

Observação: como mencionado anteriormente, para executar isso nos notebooks do Google Colab ou do Colab Enterprise, você também pode usar os comandos mágicos do BigQuery: %%bigquery. Além disso, para visualizar o gráfico nos notebooks do Google Colab ou do Colab Enterprise, inclua a flag "–graph" como: %%bigquery –graph.

%%bigquery  --project=$PROJECT_ID --graph output

Graph restaurant.bombod

match p=(a:itemlocation)-[c:consists_of]->(b:itemlocation)
match q=(a)-[d:stored_at]->(e:location)
optional match z=(f)-[g:makes]-(b)

return to_json(p) as ppath, to_json(q) as qpath, to_json(z) as zpath

Saída:

Gráfico de materiais para restaurante

7. Caso de uso 1: rastreamento de uma reclamação upstream

Cenário: um cliente reclama da qualidade do frango no sanduíche dele na loja de Nova York. É necessário rastrear o item finalizado para trás e conferir as etapas de montagem imediatas.

Consulta de travessia

Execute a consulta usando o formato de consulta de travessia de gráfico. Isso analisa as arestas consists_of que relacionam montagens downstream a ingredientes upstream.

%%bigquery --project=$PROJECT_ID --graph

GRAPH restaurant.bombod
MATCH p=(a:itemlocation)-[c:consists_of]->(b:itemlocation)
OPTIONAL MATCH q=(b)-[d:stored_at]-(e)
return to_json(p) as ppath, to_json(q) as qpath

Devido à direção da seta na tabela de arestas consists_of (Ingredient -> Finished), uma pesquisa que flui a montante gera links que isolam rapidamente materiais dependentes e locais de armazenamento.

Saída: Como navegar pela origem do frango

8. Caso de uso 2: análise de impacto

Cenário: uma nevasca fechou o centro de distribuição em Columbus, Ohio. Você precisa saber quais preparações ou itens acabados a jusante são afetados imediatamente.

Consulta de travessia

Você começa no location específico que representa o centro de distribuição, identifica o inventário armazenado lá e vê quais itens acabados precisam dele.

# @title Impact of a storm on a DC

%%bigquery  --project=$PROJECT_ID --graph
Graph restaurant.bombod
match path1=(z:itemlocation)-[m:stored_at]->(dc:location) where dc.locationKey like '%DC-Sysco-Columbus-OH%'
match path2=(z:itemlocation)-[c:consists_of]->(b:itemlocation)
match path3=(b:itemlocation)-[n:makes]->(item:item)
optional match path4=(b)-[p:stored_at]->(q:location)
return to_json(path1) as path1, to_json(path2) as path2,to_json(path3) as path3, to_json(path4) as path4

Saída: Impacto da tempestade

9. Caso de uso 3: recall downstream

Cenário: um fornecedor notifica você sobre um lote específico de produto contaminado: Tomates maduros no pé do fornecedor. Você precisa encontrar todos os itens de menu finais afetados nos cafés.

Consulta de travessia

Você procura o local da matéria-prima contaminada e faz uma travessia de caminho a jusante para encontrar os itens afetados.

%%bigquery  --project=$PROJECT_ID --graph
Graph restaurant.bombod
match path1=(a:itemlocation)-[c:consists_of]->(b:itemlocation)-[e:makes]->(f:item) where f.itemKey like '%Tomato%'
return to_json(path1) as result

Essa consulta localiza todos os itens que correspondem ao padrão "Tomate" e que estão interligados com a relação upstream, tornando-se um mapeamento eficiente que se propaga para descobrir quais itens do café precisam ser recolhidos.

Saída: Impacto hierárquico de tomates ruins

10. Limpeza

Exclua os recursos depois de concluir as etapas do tutorial para evitar cobranças residuais no seu espaço de trabalho.

DROP SCHEMA `restaurant` CASCADE;

11. Conclusão

Parabéns! Você modelou uma cadeia de suprimentos e executou uma análise de impacto usando o BigQuery Graph.

Conclusão

Você aprendeu a:

  1. Declarar relações relacionais centradas em gráficos com chaves primárias/externas.
  2. Crie um gráfico de propriedades unificado.
  3. Navegar pelas relações de vários nós de maneira eficiente usando a lógica de travessia de consultas de grafos.

Para ter mais insights sobre a arquitetura de gráficos, acesse a documentação do Google Cloud.