Vistas de métricas del modelo

Las vistas de métricas crean una capa semántica para los datos, transforman tablas y vistas en métricas empresariales estandarizadas. Definen qué medir, cómo agregarlo y cómo segmentarlo. Como resultado, todos los usuarios de toda la organización notifican el mismo valor para el mismo KPI, lo que elimina los informes incoherentes y permite el análisis flexible en todos los campos.

Los componentes principales que defina son orígenes, combinaciones, filtros, campos y medidas.

Para obtener un ejemplo completo con combinaciones, campos, medidas y metadatos del agente, consulte Tutorial: Compilación de una vista de métricas con combinaciones y modelado de datos.

Componentes principales

Una vista de métrica consta de los siguientes elementos:

Definición de un origen

Puede usar un recurso similar a una tabla o una consulta SQL como origen de la vista de métricas. Debe tener al menos SELECT privilegios en cualquier recurso al que se haga referencia.

Un recurso similar a una tabla es cualquier objeto del Catálogo de Unity que presenta un esquema tabular y admite consultas, incluidas las tablas, vistas, vistas materializadas, tablas de flujo, tablas externas, tablas del sistema y vistas de métricas.

Uso de un recurso similar a una tabla como origen

Para usar un recurso similar a una tabla como origen, especifique el nombre completo. Por ejemplo: samples.tpch.orders.

Uso de una vista de métrica como origen

Puede usar una vista de métrica existente como origen para una nueva vista de métrica:

version: 1.1

source: views.examples.source_metric_view

fields:
  - name: Order month
    expr: '`Order Month`'

measures:
  - name: Latest order month
    expr: MAX(`Order month`)
  - name: Latest order year
    expr: "DATE_TRUNC('year', MEASURE(`Latest order month`))"

Cuando se usa una vista de métrica como origen, se aplican las mismas reglas de composición para hacer referencia a campos y medidas. Consulte Composabilidad.

Uso de una consulta SQL como origen

Para usar una consulta SQL, escriba el texto de la consulta directamente en YAML:

version: 1.1

source: SELECT * FROM samples.tpch.orders o LEFT JOIN samples.tpch.customer c ON o.o_custkey
  = c.c_custkey

fields:
  - name: Order key
    expr: o_orderkey

measures:
  - name: Order Count
    expr: COUNT(o_orderkey)

Resolver arrays y mapas en el código fuente

Los campos, medidas y uniones operan todos sobre columnas planas y escalares. Si tus datos fuente tienen ARRAY o MAP escriben columnas, resuelve las columnas planas en la source consulta antes de referenciarlas en otro lugar de la vista métrica. Hay dos estrategias de transformación, dependiendo de si quieres una fila por elemento del array o un solo valor por fila fuente. Ambos se aplican tanto si el array está en la fuente de nivel superior como en una tabla a la que te unes. Consulta Transformar tipos complejos de datos para el conjunto completo de funciones de transformación.

Ningún conjunto de datos en el samples catálogo tiene una columna de array, por lo que los ejemplos de esta sección usan una orders vista que tiene un line_items array de estructuras. Utiliza el siguiente ejemplo para crear una vista con un campo que es un array. Sustituye catalog.schema por el catálogo y el esquema en los que quieras escribir. Debes tener permisos para crear objetos en ese esquema.

CREATE OR REPLACE VIEW catalog.schema.orders AS
SELECT
  o.o_orderkey,
  o.o_custkey,
  o.o_orderdate,
  o.o_orderstatus,
  collect_list(named_struct(
    'product_id', l.l_partkey,
    'quantity', cast(l.l_quantity as int)
  )) AS line_items
FROM samples.tpch.orders o
JOIN samples.tpch.lineitem l ON o.o_orderkey = l.l_orderkey
GROUP BY o.o_orderkey, o.o_custkey, o.o_orderdate, o.o_orderstatus;

Aplanar un array en filas

Para analizar cada elemento del array como una fila propia, utiliza explode() in la source consulta para descomprimir el array. Cada elemento se convierte en una fila separada, y las otras columnas de la fila fuente se repiten para cada elemento. Véase Explotar elementos anidados de un mapa o array.

El siguiente ejemplo descomprime el line_items array de modo que cada elemento se convierta en una fila:

version: 1.1
source: |
  SELECT o_orderkey, o_custkey, item.product_id, item.quantity
  FROM catalog.schema.orders
  LATERAL VIEW explode(line_items) AS item

fields:
  - name: Product
    expr: product_id

measures:
  - name: Total quantity
    expr: SUM(quantity)
  - name: Line item count
    expr: COUNT(1)

Hacer explotar el array en el source multiplica las filas fuente, así que una agregación como COUNT(1) cuenta elementos del array, no las filas originales. Para medir también las filas originales sin abanos, modela la tabla explotada como una one_to_many unión en su lugar. Consulte Combinaciones de uno a varios.

Agregar un array en un solo valor

Para reducir un array a un valor por fila de origen sin cambiar el recuento de filas, aplica una función escalar de array en la source consulta, como aggregate(), array_size(), o reduce(). Cada fila fuente mantiene su grano, y la columna calculada está disponible para campos y medidas.

El siguiente ejemplo calcula el recuento de elementos y la cantidad total del line_items array por orden:

version: 1.1
source: |
  SELECT o_orderkey, o_custkey,
    array_size(line_items) AS item_count,
    aggregate(line_items, 0, (acc, x) -> acc + x.quantity) AS total_quantity
  FROM catalog.schema.orders

measures:
  - name: Total quantity
    expr: SUM(total_quantity)
  - name: Average items per order
    expr: AVG(item_count)

Como la consulta de código fuente reduce el array antes de que la vista de métrica lo procese, el código fuente mantiene una fila por orden y las medidas se agregan entre órdenes como de costumbre.

Resolver un array en una tabla unida

La misma regla se aplica cuando el array está en una tabla a la que quieres unirte, no en la fuente de nivel superior. Una unión opera sobre columnas planas, por lo que resuelve el array en la subconsulta propia source de la tabla unida antes de la unión. Escribe la unión source como una consulta SQL que aplana o agrega el array, y luego la join en las columnas resultantes. Ver Unirse en vistas métricas.

El siguiente ejemplo utiliza customer como fuente y une la orders vista con cardinality: one_to_many. La unión source agrega el array de line_items cada pedido a un escalar total_quantity antes de la unión, de modo que la vista métrica puede sumarlo por cliente sin duplicar filas de clientes:

version: 1.1
source: samples.tpch.customer

joins:
  - name: orders
    source: |
      SELECT o_orderkey, o_custkey,
        aggregate(line_items, 0, (acc, x) -> acc + x.quantity) AS total_quantity
      FROM catalog.schema.orders
    on: orders.o_custkey = source.c_custkey
    cardinality: one_to_many

fields:
  - name: Customer name
    expr: c_name

measures:
  - name: Total quantity
    expr: SUM(orders.total_quantity)
  - name: Order count
    expr: COUNT(orders.o_orderkey)

Para tratar cada elemento del array como su propia fila en la tabla unida, aplana el array con explode() en la unión source de la misma manera. Véase Aplanar un array en filas.

Campos

Los campos, también llamados dimensiones, son columnas de una vista de métricas que se pueden usar en las cláusulas SELECT, WHERE y GROUP BY al realizar una consulta. Un campo puede ser una columna de categorías, como región o estado, o una columna numérica no agregada, como el precio o la cantidad, que puede agregar en el momento de la consulta. Cada expresión de campo debe devolver un valor escalar. Puede hacer referencia a columnas de los datos de origen o a campos definidos anteriormente en la vista de métricas. Cada campo consta de dos componentes:

• name: alias de la columna
• expr: expresión SQL que hace referencia a los datos de origen o campos definidos previamente en la vista de métricas.

Medidas

Las medidas son expresiones que generan resultados sin un nivel de agregación determinado previamente. Deben expresarse mediante funciones de agregado. Para hacer referencia a una medida en una consulta, use la MEASURE función . Las medidas pueden hacer referencia a columnas base en los datos de origen, los campos definidos anteriormente o las medidas definidas anteriormente. Cada medida consta de los siguientes componentes:

• name: alias de la medida.
• expr: expresión SQL agregada que puede incluir funciones de agregado de SQL.

En el ejemplo siguiente se muestran patrones de medida comunes para analizar los datos de pedidos e ingresos. En estos ejemplos se usa la tabla TPC-H pedidos, que contiene datos de transacciones de ventas, incluidos los precios de pedido (o_totalprice), los identificadores de cliente (o_custkey), las claves de pedido (o_orderkey), las fechas de pedido (o_orderdate) y los niveles de prioridad (o_orderpriority):

measures:
  # Simple count measure
  - name: Order Count
    expr: COUNT(1)

  # Sum aggregation measure
  - name: Total Revenue
    expr: SUM(o_totalprice)

  # Distinct count measure
  - name: Unique Customers
    expr: COUNT(DISTINCT o_custkey)

  # Calculated measure combining multiple aggregations
  - name: Average Order Value
    expr: SUM(o_totalprice) / COUNT(DISTINCT o_orderkey)

  # Filtered measure with WHERE condition
  - name: High Priority Order Revenue
    expr: SUM(o_totalprice) FILTER (WHERE o_orderpriority = '1-URGENT')

  # Measure using a field
  - name: Average Revenue per Month
    expr: SUM(o_totalprice) / COUNT(DISTINCT DATE_TRUNC('MONTH', o_orderdate))

Consulte Funciones de agregado para obtener una lista de funciones de agregado.

Aplicar filtros

Un filtro se aplica a todas las consultas que hacen referencia a la vista de métricas. Para definir un filtro en la interfaz de usuario, consulte Paso 3: Definir un filtro.

Para definir un filtro en la definición de YAML, escriba una expresión booleana. En el ejemplo siguiente se muestran patrones de filtro comunes:

# Single condition
filter: o_orderdate > '2024-01-01'

# Multiple conditions
filter: o_orderdate > '2024-01-01' AND o_orderstatus = 'F'

# IN clause
filter: o_orderstatus IN ('F', 'P') AND o_orderdate >= '2024-01-01'

Trabajar con combinaciones

Las vistas de métricas admiten combinaciones para enriquecer los datos de origen con atributos de tablas relacionadas. Puede modelar esquemas de estrella (tabla de hechos unida a tablas de dimensiones), esquemas de copo de nieve (combinaciones de dimensiones de varios niveles) y relaciones uno a varios (expansión de hechos de un origen dimensional). Para más información sobre los tipos de combinación, la cardinalidad, los patrones de esquema y las restricciones, consulte Combinaciones en vistas de métricas.

Para definir combinaciones en la interfaz de usuario, consulte Paso 2: Agregar una combinación. Para definir combinaciones en la definición de YAML, use los patrones de las secciones siguientes.

Esquemas de estrella modelo

En un esquema de estrella, source es la tabla de hechos y combina con una o varias tablas de dimensiones mediante .LEFT OUTER JOIN Las vistas de métricas unen las tablas de hechos y dimensiones necesarias para la consulta específica, en función de los campos y medidas seleccionados.

Especifique las columnas de unión mediante la cláusula on (expresión booleana) o la cláusula using (nombres de columnas compartidos). La unión debe basarse en una relación de varios a uno. En los casos de muchos a muchos, el motor selecciona la primera fila que coincida de la tabla de dimensiones combinada.

En el ejemplo siguiente se unen orders (tabla de hechos) a customer (tabla de dimensiones) y se exponen atributos de cliente como campos. La configuración rely.at_most_one_match: true declara que la combinación es de varios a uno (cada pedido tiene exactamente un cliente), lo que permite al motor optimizar las consultas que filtran por campos de la tabla combinada.

Consulte Optimización de combinaciones con rely.

version: 1.1
source: samples.tpch.orders

joins:
  - name: customer
    source: samples.tpch.customer
    on: source.o_custkey = customer.c_custkey

fields:
  - name: Customer name
    expr: customer.c_name

measures:
  - name: Total revenue
    expr: SUM(o_totalprice)

Sintaxis y formato de YAML

Las definiciones de la vista métrica siguen la sintaxis de notación YAML estándar. Consulte Referencia de sintaxis de YAML de la vista métrica para obtener la sintaxis y el formato necesarios.

Procedimientos recomendados

Use las instrucciones siguientes al modelar vistas de métricas:

• Medidas atómicas del modelo: comience definiendo primero las medidas más sencillas (por ejemplo, SUM(revenue), COUNT(DISTINCT customer_id)). Crear medidas complejas usando la composabilidad.
• Estandarizar valores de campo: use transformaciones (como CASE instrucciones) para convertir códigos de base de datos en nombres de negocio claros (por ejemplo, convertir el estado de pedido "O" a "Abrir" y "F" a "Cumplido").
• Definir el ámbito con filtros: si una vista de métrica solo debe incluir pedidos completados, defina ese filtro en la vista de métricas para que los usuarios no puedan incluir datos incompletos accidentalmente.
• Use nombres claros: los nombres de las métricas deben ser reconocibles para los usuarios empresariales (por ejemplo, "Valor del Tiempo de Vida del Cliente" en lugar de cltv_agg_measure).
• Campos de hora independientes: incluya campos de hora pormenorizados (como "Fecha de pedido") y campos de hora truncados (como "Mes de pedido" o "Semana de pedido") para habilitar el análisis de tendencias y el nivel de detalle.

Recursos adicionales

• Combinaciones en vistas de métricas
• Técnicas avanzadas para vistas de métricas
• Metadatos del agente en vistas de métricas
• Materialización de vistas de métricas
• Referencia de sintaxis de YAML de la vista de métricas