Modelmetrische weergaven

Metrische weergaven maken een semantische laag voor uw gegevens, het transformeren van tabellen en weergaven in gestandaardiseerde zakelijke metrische gegevens. Ze definiëren wat moet worden gemeten, hoe het geaggregeerd moet worden en hoe het gesegmenteerd moet worden. Als gevolg hiervan rapporteert elke gebruiker in de hele organisatie dezelfde waarde voor dezelfde KPI, waardoor inconsistente rapportage wordt geëlimineerd en flexibele analyse mogelijk is voor alle velden.

De belangrijkste onderdelen die u definieert, zijn bronnen, joins, filters, velden en metingen.

Zie Zelfstudie: een metrische weergave maken met joins, velden, metingen en agentmetagegevens voor een volledig voorbeeld met joins, velden, metingen en agentmetagegevens.

Kernonderdelen

Een metrische weergave bestaat uit de volgende elementen:

Een bron definiëren

U kunt een tabelachtige asset of een SQL-query gebruiken als de bron voor uw metrische weergave. U moet ten minste SELECT bevoegdheden hebben voor een asset waarnaar wordt verwezen.

Een tabelachtige asset is een Unity Catalog-object dat een tabellair schema beschikbaar maakt en query's ondersteuntSELECT, waaronder tabellen, weergaven, gematerialiseerde weergaven, streamingtabellen, refererende tabellen, systeemtabellen en metrische weergaven.

Een tabelachtige asset als bron gebruiken

Als u een tabelachtige asset als bron wilt gebruiken, geeft u de volledig gekwalificeerde naam op. Bijvoorbeeld: samples.tpch.orders.

Een metrische weergave gebruiken als bron

U kunt een bestaande metrische weergave gebruiken als bron voor een nieuwe metrische weergave:

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`))"

Wanneer u een metrische weergave als bron gebruikt, zijn dezelfde regels voor composabiliteit van toepassing op het verwijzen naar velden en metingen. Zie Composability.

Een SQL-query als bron gebruiken

Als u een SQL-query wilt gebruiken, schrijft u de querytekst rechtstreeks in de 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)

Resolveer arrays en afbeeldingen in de bron

Velden, maten en joins werken allemaal op vlakke, scalaire kolommen. Als je brondata kolommen heeft ARRAY of MAP typeert, los ze dan op in vlakke kolommen in de source query voordat je ze elders in de metriekweergave raadpleegt. Er zijn twee transformatiestrategieën, afhankelijk van of je één rij per array-element wilt of één waarde per bronrij. Beide zijn van toepassing of de array nu in de top-level source zit of in een tabel waar je mee kunt koppelen. Zie Transformeer complexe datatypes voor de volledige set transformatiefuncties.

Geen enkele dataset in de samples catalogus heeft een arraykolom, dus de voorbeelden in deze sectie gebruiken een orders weergave met een line_items array van structs. Gebruik het volgende voorbeeld om een weergave te maken met een veld dat een array is. Vervang catalog.schema het door de catalogus en het schema waar je naartoe wilt schrijven. Je moet rechten hebben om objecten in dat schema te maken.

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;

Plat een array in rijen

Om elk array-element als een eigen rij te analyseren, gebruik explode() je in de source query om de array uit te pakken. Elk element wordt een aparte rij, en de andere kolommen van de bronrij worden herhaald voor elk element. Zie Exploderen geneste elementen uit een kaart of array.

Het volgende voorbeeld haalt de line_items array uit zodat elk item een rij wordt:

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)

Het exploderen van de array in de source vermenigvuldigt de bronrijen, dus een aggregatie zoals COUNT(1) telt array-elementen, niet de oorspronkelijke rijen. Om ook de oorspronkelijke rijen zonder fan-out te meten, modelleer je de geëngplodeerde tafel als een one_to_many verbinding. Bekijk een-op-veel-joins.

Een array samenvoegen tot één enkele waarde

Om een array te reduceren tot één waarde per bronrij zonder het aantal rijen te wijzigen, pas je een scalair arrayfunctie toe in de source query, zoals aggregate(), array_size(), of reduce(). Elke bronrij behoudt zijn korrel, en de berekende kolom is beschikbaar voor velden en maten.

Het volgende voorbeeld berekent het aantal items en de totale hoeveelheid van de line_items array per order:

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)

Omdat de bronquery de array verkleint voordat de metriekweergave deze verwerkt, houdt de bron één rij per order en meet zoals gewoonlijk de aggregatie over de volgordes heen.

Resolve een array op in een gekoppelde tabel

Dezelfde regel geldt wanneer de array in een tabel staat waar je aan wilt werken, niet in de top-level broncode. Een join werkt op vlakke kolommen, dus los de array op in de eigen source subquery van de gekoppelde tabel vóór de join. Schrijf de join source als een SQL-query die de array afvlakt of aggregeert, en join vervolgens op de resulterende kolommen. Zie Joins in metrische weergaven.

Het volgende voorbeeld gebruikt customer als bron en voegt de weergave ordersaan met cardinality: one_to_many . De join source aggregeert de line_items array van elke order tot een scalar total_quantity vóór de join, zodat het metriek-overzicht het per klant kan optellen zonder klantrijen te dupliceren:

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)

Om in plaats daarvan elk array-element als een eigen rij in de jointabel te behandelen, vlak je de array met explode() in de join source op dezelfde manier af. Zie Vlak een array in rijen op.

Velden

Velden, ook wel dimensies genoemd, zijn kolommen van metrische weergaven die u tijdens het uitvoeren van query’s in de clausules SELECT, WHERE en GROUP BY kunt gebruiken. Een veld kan een categorische kolom zijn, zoals regio of status, of een niet-geaggregeerde numerieke kolom, zoals prijs of hoeveelheid, die u tijdens de query kunt aggregeren. Elke veldexpressie moet een scalaire waarde retourneren. Het kan verwijzen naar kolommen uit de brongegevens of velden die eerder zijn gedefinieerd in de metrische weergave. Elk veld bestaat uit twee onderdelen:

• name: De alias van de kolom
• expr: Een SQL-expressie die verwijst naar de brongegevens of eerder gedefinieerde velden in de metrische weergave

Maatregelen

Metingen zijn expressies die resultaten produceren zonder vooraf bepaald aggregatieniveau. Ze moeten worden uitgedrukt met behulp van statistische functies. Als u wilt verwijzen naar een meting in een query, gebruikt u de MEASURE functie. Metingen kunnen verwijzen naar basiskolommen in de brongegevens, eerder gedefinieerde velden of eerder gedefinieerde metingen. Elke meting bestaat uit de volgende onderdelen:

• name: De alias van de meting
• expr: Een aggregatie-SQL-uitdrukking die SQL-aggregatiefuncties kan bevatten

In het volgende voorbeeld ziet u algemene meetpatronen voor het analyseren van order- en omzetgegevens. In deze voorbeelden wordt de tabel TPC-H orders gebruikt, die verkooptransactiegegevens bevat, waaronder orderprijzen (o_totalprice), klant-id's (o_custkey), ordersleutels (o_orderkey), orderdatums (o_orderdate) en prioriteitsniveaus (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))

Zie Statistische functies voor een lijst met statistische functies.

Filters toepassen

Een filter is van toepassing op alle query's die verwijzen naar de metrische weergave. Zie stap 3: Een filter definiëren om een filter in de gebruikersinterface te definiëren.

Als u een filter in de YAML-definitie wilt definiëren, schrijft u een Boole-expressie. In het volgende voorbeeld ziet u algemene filterpatronen:

# 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'

Werken met joins

Metrische weergaven ondersteunen joins om uw brongegevens te verrijken met kenmerken uit gerelateerde tabellen. U kunt stervormige schema's modelleren (feitentabel gekoppeld aan dimensietabellen), snowflake-schema's (dimensiedeelnames op meerdere niveaus) en een-op-veel-relaties (feitenuitbreiding van een dimensionale bron). Zie Joins in metrische weergaven voor meer informatie over jointypen, kardinaliteit, schemapatronen en beperkingen.

Zie stap 2: Een join toevoegen om joins in de gebruikersinterface te definiëren. Als u joins in de YAML-definitie wilt definiëren, gebruikt u de patronen in de volgende secties.

Model ster-schema's

In een stervormig schema is de source feitentabel en wordt samengevoegd met een of meer dimensietabellen met behulp van een LEFT OUTER JOIN. Metrische weergaven voegen de feiten- en dimensietabellen toe die nodig zijn voor de specifieke query, op basis van de geselecteerde velden en metingen.

Geef joinkolommen op met behulp van een on component (Booleaanse expressie) of een using component (gedeelde kolomnamen). De join moet gebaseerd zijn op een many-to-one-relatie. Bij veel-op-veel-relaties selecteert de engine de eerste overeenkomende rij uit de samengevoegde dimensietabel.

In het volgende voorbeeld wordt orders (feitentabel) samengevoegd met customer (dimensietabel) en worden klantattributen beschikbaar gesteld als velden. Door de instelling rely.at_most_one_match: true wordt aangegeven dat de join veel-op-een is (elke bestelling precies één klant heeft), waarmee de engine query's kan optimaliseren die filteren op velden uit de gekoppelde tabel.

Zie Joins optimaliseren met 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)

YAML-syntaxis en -opmaak

Definities van metrische weergave volgen de standaard syntaxis van YAML-notatie. Zie de YAML-syntaxisreferentie voor de metrische weergave voor de vereiste syntaxis en opmaak.

Beste praktijken

Gebruik de volgende richtlijnen bij het modelleren van metrische weergaven:

• Atomische metingen model: begin met het definiëren van de eenvoudigste metingen eerst (bijvoorbeeld SUM(revenue), COUNT(DISTINCT customer_id)). Bouw complexe metingen met behulp van composabiliteit.
• Veldwaarden standaardiseren: Gebruik transformaties (zoals CASE instructies) om databasecodes te converteren naar duidelijke bedrijfsnamen (bijvoorbeeld orderstatus 'O' converteren naar 'Openen' en 'F' naar 'Voltooid').
• Bereik definiëren met filters: als een metrische weergave alleen voltooide orders mag bevatten, definieert u dat filter in de metrische weergave, zodat gebruikers niet per ongeluk onvolledige gegevens kunnen opnemen.
• Gebruik duidelijke naamgeving: metrische namen moeten herkenbaar zijn voor zakelijke gebruikers (bijvoorbeeld 'Klantlevenswaarde' in plaats van cltv_agg_measure).
• Afzonderlijke tijdvelden: gebruik gedetailleerde tijdvelden (zoals 'Orderdatum') en afgekapte tijdvelden (zoals 'Ordermaand' of 'Orderweek') om zowel detail- als trendanalyse in te schakelen.

Aanvullende informatiebronnen

• Koppelingen in metrische weergaven
• Geavanceerde technieken voor metrische weergaven
• Metagegevens van agents in metrische weergaven
• Materialisatie voor metrische weergaven
• Naslaginformatie over YAML-syntaxis voor metrische weergave