1. Introduzione
In questo codelab imparerai a utilizzare BigQuery Graph per risolvere problemi complessi relativi alla catena di fornitura e alla logistica.
Modellerai una rete della catena di fornitura di un ristorante incentrata sulla sicurezza alimentare e sul controllo qualità. Quando si verifica un problema di sicurezza alimentare, ad esempio un ingrediente contaminato da un fornitore, il tempo è essenziale. Identificare il "raggio d'azione" ed eseguire rapidamente un richiamo mirato può far risparmiare sui costi e proteggere i clienti.

I modelli relazionali tradizionali richiedono operazioni JOIN complesse in più passaggi per tracciare gli articoli attraverso più fasi (Fornitore -> CD -> Mensa -> Negozio -> Articolo finito). Con BigQuery Graph, modelliamo queste connessioni direttamente, consentendo query intuitive e rapide utilizzando lo standard ISO GQL (Graph Query Language).
Obiettivi didattici
- Come definire un modello di grafo su tabelle BigQuery esistenti.
- Come creare un grafico delle proprietà in BigQuery.
- Come eseguire query di attraversamento per tracciare gli impatti upstream e downstream.
Che cosa ti serve
- Un progetto Google Cloud con la fatturazione abilitata.
- Google Cloud Shell.
Stima dei costi
Il costo previsto per questo lab è inferiore a 5 $ in tariffe di analisi di BigQuery, ampiamente entro le allocazioni del Livello senza costi per i nuovi utenti.
2. Configurazione e requisiti
Apri Cloud Shell
Svolgerai la maggior parte del lavoro in Cloud Shell, un ambiente completo che include tutto ciò di cui hai bisogno per utilizzare Google Cloud.
- Vai alla console Google Cloud.
- Fai clic sull'icona Attiva Cloud Shell nella barra degli strumenti in alto a destra.
- Se richiesto, fai clic su Continua.
Configura le variabili di ambiente
In Cloud Shell, imposta l'ID progetto per semplificare i comandi futuri.
export PROJECT_ID=$(gcloud config get-value project)
Abilita API
Esegui questo comando per abilitare l'API BigQuery richiesta:
gcloud services enable bigquery.googleapis.com
3. Creazione dello schema e delle tabelle
Creerai un set di dati e tabelle che rappresentano i componenti della tua catena di fornitura:
item: la definizione generica dell'articolo (ad es. pomodoro, pollo).location: strutture (fornitori, centri di distribuzione, bar).itemlocation: la tabella di intersezione che rappresenta le località dell'inventario.bom: distinta base (definisce le relazioni di peso, ad esempio l'articolo A va nell'articolo B).makes: mappaitemlocationinitem.stored_at: mappaitemlocationinlocation.
Crea set di dati
Puoi eseguire i comandi SQL in questo lab utilizzando Cloud Shell o la console BigQuery.
Per utilizzare la console BigQuery:
- Apri la console BigQuery in una nuova scheda.
- Incolla ogni snippet SQL di questo lab nell'editor, quindi fai clic sul pulsante Esegui per eseguirlo.

Esegui il comando seguente in Cloud Shell o utilizza la console BigQuery per creare lo schema. Utilizzerai le variabili dei nodi nel tuo SQL.

Nota: (1) per eseguire questa operazione in Google Colab, puoi anche utilizzare i comandi magici di BigQuery: %%bigquery Il seguente snippet crea lo schema del ristorante all'interno del tuo progetto per ospitare i dati del grafico. (2) Se esegui l'operazione da Google Colab, dovrai utilizzare %%bigquery –project <PROJECT_ID>. Assicurati che il campo PROJECT_ID sia mappato al progetto appropriato che intendi utilizzare: PROJECT_ID = "argolis-project-340214" # @param {"type":"string"} (3) Se utilizzi Colab, a seconda dei requisiti dovrai installare alcune librerie. Se utilizzerai la visualizzazione dei grafici, assicurati di installare la libreria tramite pip: spanner-graph-notebook==1.1.5

%%bigquery --project=$PROJECT_ID
CREATE SCHEMA IF NOT EXISTS restaurant ;
Crea tabelle
Esegui il seguente codice SQL per creare le tabelle.
%%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. Caricamento dei dati campionati in corso…
Per rendere questo lab completamente autonomo, compilerai le tabelle con dati campionati utilizzando istruzioni SQL LOAD DATA pure. Rappresenta una rete che inizia con un fornitore, attraversa un centro di distribuzione (DC) e una cucina centrale e arriva a un bar di vendita al dettaglio.
Esegui le seguenti query SQL per caricare i dati:

Nota: puoi omettere %%bigquery se esegui il codice direttamente in 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. Aggiunta di vincoli e definizione del grafico
Prima di creare il grafico, dichiari le relazioni semantiche utilizzando i vincoli di chiave primaria e chiave esterna SQL standard. Questi attributi aiutano BigQuery a comprendere gli identificatori dei nodi e a collegare le tabelle degli archi alle tabelle dei nodi.
Crea grafico delle proprietà
Ora unisci queste tabelle in un'unica struttura Graph coesa chiamata restaurant.bombod.
Definisci:
- Nodi:
item,location,itemlocation - Archi:
makes,stored_ateconsists_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. Visualizzazione della catena di fornitura
Puoi eseguire una query di attraversamento top-down per visualizzare l'intera rete della catena di fornitura. In un notebook standard o in un'interfaccia utente che lo supporta (come %%bigquery --graph), viene restituita una mappa visiva.
Utilizza query assolute sul grafo per configurare nodi e archi.
Nota: come accennato in precedenza, per eseguire questa operazione in Google Colab o nei notebook di Colab Enterprise, puoi anche utilizzare i comandi magici di BigQuery: %%bigquery Inoltre, per visualizzare il grafico in Google Colab o nei notebook di Colab Enterprise, includi il flag –graph come: %%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
Output:

7. Caso d'uso 1: tracciamento di un reclamo upstream
Scenario: un cliente si lamenta della qualità del pollo nel suo panino presso il negozio di New York. Devi risalire all'articolo finito per vedere le fasi di assemblaggio immediate.
Query di attraversamento
Esegui la query utilizzando il formato di query di attraversamento del grafo. Vengono esaminati gli archi consists_of che collegano gli assembly downstream agli ingredienti 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
A causa della direzione della freccia nella tabella degli archi consists_of (Ingredient -> Finished), una ricerca che procede a monte produce link che isolano rapidamente i materiali e le posizioni di archiviazione dipendenti.
Output: 
8. Caso d'uso 2: analisi dell'impatto
Scenario: una tempesta di neve ha bloccato il centro di distribuzione di Columbus, Ohio. Devi sapere quali preparazioni o articoli finiti a valle sono interessati immediatamente.
Query di attraversamento
Inizi dalla location specifica che rappresenta il centro di distribuzione, identifichi l'inventario archiviato lì e vedi quali articoli finiti lo richiedono.
# @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
Output: 
9. Caso d'uso 3: richiamo downstream
Scenario: un fornitore ti informa di un lotto specifico di prodotto contaminato: Pomodori maturati sulla pianta del fornitore. Devi trovare tutte le voci di menu finali interessate nei bar.
Query di attraversamento
Cerchi la posizione della materia prima contaminata, quindi esegui un attraversamento del percorso a valle per trovare gli articoli finali interessati.
%%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
Questa query individua tutti gli elementi che corrispondono al pattern "Tomato" e che sono intrecciati con la relazione upstream, rendendola una mappatura efficace che si propaga per scoprire quali elementi del bar devono essere richiamati.
Output: 
10. Elimina
Elimina le risorse una volta completati i passaggi della procedura dettagliata per evitare addebiti residui nel tuo workspace.
DROP SCHEMA `restaurant` CASCADE;
11. Conclusione
Complimenti! Hai modellato una catena di fornitura ed eseguito l'analisi dell'impatto utilizzando BigQuery Graph.
Conclusione
Hai imparato a:
- Dichiara relazioni relazionali incentrate sui grafi con chiavi primarie/esterne.
- Crea un grafo delle proprietà unificato.
- Naviga in modo efficiente nelle relazioni tra più nodi utilizzando la logica di attraversamento delle query del grafo.
Per saperne di più sull'architettura dei grafi, consulta la documentazione di Google Cloud.