1. Introducción
En este codelab, aprenderás a aprovechar BigQuery Graph para resolver problemas complejos de logística y cadena de suministro.
Modelarás una red de cadena de suministro de un restaurante que se enfoca en la seguridad alimentaria y el control de calidad. Cuando surge un problema de seguridad alimentaria, como un ingrediente contaminado de un proveedor, el tiempo es fundamental. Identificar el "radio de impacto" y ejecutar un retiro preciso con rapidez puede ahorrar costos y proteger a los clientes.

Los modelos relacionales tradicionales requieren operaciones JOIN complejas de varios pasos para rastrear los artículos a través de varias etapas (proveedor -> centro de distribución -> comisariato -> tienda -> artículo terminado). Con BigQuery Graph, modelamos estas conexiones directamente, lo que permite realizar consultas rápidas e intuitivas con el estándar ISO GQL (Graph Query Language).
Qué aprenderás
- Cómo definir un modelo de grafo sobre tablas de BigQuery existentes
- Cómo crear un grafo de propiedades en BigQuery
- Cómo ejecutar consultas de recorrido para rastrear los impactos ascendentes y descendentes
Requisitos
- Un proyecto de Google Cloud con facturación habilitada
- Google Cloud Shell
Estimación de costos
Se espera que este lab cueste menos de USD 5 en tarifas de análisis de BigQuery, lo que está dentro de las asignaciones del nivel gratuito para usuarios nuevos.
2. Configuración y requisitos
Abre Cloud Shell
Realizarás la mayor parte del trabajo en Cloud Shell, un entorno cargado que incluye todo lo que necesitas para usar Google Cloud.
- Ve a la consola de Google Cloud.
- Haz clic en el ícono Activar Cloud Shell en la barra de herramientas de la esquina superior derecha.
- Haz clic en Continuar si se te solicita hacerlo.
Configura las variables de entorno
En Cloud Shell, establece el ID del proyecto para simplificar los comandos futuros.
export PROJECT_ID=$(gcloud config get-value project)
Habilita las APIs
Ejecuta este comando para habilitar la API de BigQuery requerida:
gcloud services enable bigquery.googleapis.com
3. Crea el esquema y las tablas
Crearás un conjunto de datos y tablas que representen los componentes de tu cadena de suministro:
item: Es la definición genérica del elemento (p.ej., tomate, pollo).location: Instalaciones (proveedores, centros de distribución, cafeterías)itemlocation: Es la tabla de intersección que representa las ubicaciones del inventario.bom: Lista de materiales (define las relaciones de peso, p.ej., el artículo A va en el artículo B).makes: Asignaitemlocationaitem.stored_at: Asignaitemlocationalocation.
Crear conjunto de datos
Puedes ejecutar los comandos de SQL de este lab con Cloud Shell o la consola de BigQuery.
Para usar la consola de BigQuery, sigue estos pasos:
- Abre la consola de BigQuery en una pestaña nueva.
- Pega cada fragmento de SQL de este lab en el editor y, luego, haz clic en el botón Ejecutar para ejecutarlo.

Ejecuta el siguiente comando en Cloud Shell o usa la consola de BigQuery para crear el esquema. Usarás variables de nodo en tu SQL.

Nota: (1) Para ejecutar esto en Google Colab, también puedes usar los comandos mágicos de BigQuery: %%bigquery El siguiente fragmento crea el esquema de restaurante dentro de tu proyecto para alojar tus datos de grafo. (2) Deberás usar %%bigquery –project <PROJECT_ID> si ejecutas el código desde Google Colab. Asegúrate de que el campo PROJECT_ID esté asignado al proyecto adecuado que quieras usar: PROJECT_ID = "argolis-project-340214" # @param {"type":"string"} (3) Si usas Colab, según tus requisitos, deberás instalar algunas bibliotecas. Si vas a usar la visualización de grafos, asegúrate de instalar la biblioteca con pip: spanner-graph-notebook==1.1.5

%%bigquery --project=$PROJECT_ID
CREATE SCHEMA IF NOT EXISTS restaurant ;
Crea tablas
Ejecuta el siguiente código de SQL para compilar las tablas.
%%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. Carga datos de muestra
Para que este lab sea completamente independiente, propagarás las tablas con datos de muestra usando sentencias de SQL LOAD DATA puras. Esto representa una red que comienza con un proveedor, pasa por un centro de distribución (CD) y una cocina central, y llega a una cafetería minorista.
Ejecuta las siguientes consultas en SQL para cargar los datos:

Nota: Puedes omitir %%bigquery si ejecutas la consulta directamente en 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. Agrega restricciones y define el gráfico
Antes de compilar el grafo, debes declarar las relaciones semánticas con las restricciones de clave primaria y clave externa de SQL estándar. Estas guían a BigQuery para que comprenda los identificadores de nodos y conecte las tablas de bordes a las tablas de nodos.
Crea un grafo de propiedades
Ahora, une estas tablas en una sola estructura de Graph cohesiva llamada restaurant.bombod.
Debes definir lo siguiente:
- Nodos:
item,location,itemlocation - Bordes:
makes,stored_atyconsists_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. Visualiza la cadena de suministro
Puedes ejecutar una consulta de recorrido de arriba hacia abajo para ver toda la red de la cadena de suministro. En un notebook o una IU estándar que lo admita (como %%bigquery --graph), se devuelve un mapa visual.
Usa consultas de grafos absolutos para configurar nodos y bordes.
Nota: Como se mencionó antes, para ejecutar esto en Google Colab o en los notebooks de Colab Enterprise, también puedes usar los comandos mágicos de BigQuery: %%bigquery. Además, para visualizar el gráfico en Google Colab o en los notebooks de Colab Enterprise, incluye la marca –graph de la siguiente manera: %%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
Resultado:

7. Caso de uso 1: Seguimiento de un reclamo upstream
Situación: Un cliente se queja de la calidad del pollo de su sándwich en la tienda de Nueva York. Debes rastrear el artículo terminado hacia atrás para ver sus etapas de ensamblaje inmediatas.
Consulta de recorrido
Ejecuta la consulta con el formato de consulta de recorrido de grafo. Esto analiza las aristas de consists_of que relacionan los ensamblajes descendentes con los ingredientes ascendentes.
%%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
Debido a la dirección de la flecha en la tabla de bordes de consists_of (Ingredient -> Finished), una búsqueda que fluye hacia arriba genera vínculos que aíslan rápidamente los materiales dependientes y las ubicaciones de almacenamiento.
Resultado: 
8. Caso de uso 2: Análisis de impacto
Situación: Una tormenta de nieve cerró el centro de distribución de Columbus, Ohio. Necesitas saber qué preparaciones o artículos terminados de la cadena de suministro se ven afectados de inmediato.
Consulta de recorrido
Comienzas en el location específico que representa el centro de distribución, identificas el inventario almacenado allí y ves qué artículos terminados lo requieren.
# @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
Resultado: 
9. Caso de uso 3: Recuperación downstream
Situación: Un proveedor te notifica sobre un lote específico de productos contaminados: Tomates madurados en la planta del proveedor. Debes encontrar todos los elementos finales del menú que se ven afectados en las cafeterías.
Consulta de recorrido
Buscas la ubicación de la materia prima contaminada y, luego, realizas un recorrido de ruta que fluye hacia abajo para encontrar los elementos afectados finales.
%%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
Esta consulta ubica todos los elementos que coinciden con el patrón "Tomato" y que están entrelazados con la relación ascendente, lo que la convierte en una asignación potente que se propaga para descubrir qué elementos de la cafetería se deben retirar.
Resultado: 
10. Limpieza
Borra los recursos una vez que completes los pasos de la explicación para evitar cargos residuales en tu espacio de trabajo.
DROP SCHEMA `restaurant` CASCADE;
11. Conclusión
¡Felicitaciones! Modelaste una cadena de suministro y ejecutaste un análisis de impacto con BigQuery Graph.
Conclusión
Aprendiste a hacer lo siguiente:
- Declara relaciones relacionales centradas en grafos con claves primarias y externas.
- Crea un gráfico de propiedades unificado.
- Navegar por relaciones de varios nodos de manera eficiente con la lógica de recorrido de Graph Query
Para obtener más información sobre la arquitectura de grafos, visita la documentación de Google Cloud.