Modellmåttvyer

Måttvyer skapar ett semantiskt lager för dina data och omvandlar tabeller och vyer till standardiserade affärsmått. De definierar vad som ska mätas, hur du aggregerar det och hur du segmenterar det. Därför rapporterar alla användare i organisationen samma värde för samma KPI, vilket eliminerar inkonsekvent rapportering och möjliggör flexibel analys i alla fält.

De viktigaste komponenterna som du definierar är källor, kopplingar, filter, fält och mått.

Ett fullständigt exempel med kopplingar, fält, mått och agentmetadata finns i Självstudie: skapa en måttvy med kopplingar och datamodellering.

Kärnkomponenter

En måttvy består av följande element:

Component	Description	Example
Source	Bastabellen, vyn eller SQL-frågan som innehåller datan.	samples.tpch.orders
Joins	Relationer mellan tabeller, vyer och måttvyer för att berika data.	Koppla orders tabell med customers tabell på customer_key
Filter	Villkor som tillämpas på källdata för att definiera omfång.	status = 'completed' order_date > '2024-01-01'
Fields	Kolumner som används för att gruppera, filtrera och aggregera mått. Innehåller kategoriska kolumner och oaggregerade numeriska kolumner. Kallas även dimensioner.	Produktkategori, Ordermånad, Enhetspris
Åtgärder	Kolumnaggregeringar som producerar mått.	COUNT(o_orderkey) som orderantal, SUM(o_totalprice) som totalintäkter

Definiera en källa

Du kan använda en tabellliknande tillgång eller en SQL-fråga som källa för din måttvy. Du måste ha minst SELECT behörighet för alla refererade tillgångar.

En tabellliknande tillgång är alla Unity Catalog-objekt som exponerar ett tabellschema och stöder SELECT frågeställningar, inklusive tabeller, vyer, materialiserade vyer, strömmande tabeller, utländska tabeller, systemtabeller och måttvyer.

Använda en tabellliknande tillgång som källa

Om du vill använda en tabellliknande tillgång som källa anger du det fullständigt kvalificerade namnet. Till exempel: samples.tpch.orders.

Använda en måttvy som källa

Du kan använda en befintlig måttvy som källa för en ny måttvy:

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

När du använder en måttvy som källa gäller samma sammansättningsregler för referensfält och mått. Se Komponerbarhet.

Använda en SQL-fråga som källa

Om du vill använda en SQL-fråga skriver du frågetexten direkt i 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)

Note

När du använder en SQL-fråga som källa med en JOIN sats anger du primär- och sekundärnyckelbegränsningar för underliggande tabeller och använder RELY alternativet för optimal frågeprestanda. Se Deklarera primärnyckel, sekundärnyckel och unika begränsningar och Frågeoptimering med primärnyckel och unika begränsningar.

Upplösa arrayer och kartor i källkoden

Fält, mått och skarvningar arbetar alla på platta, skalära kolumner. Om din källdata har ARRAY eller MAP typar kolumner, lös dem till platta kolumner i frågeformuläret source innan du refererar till dem någon annanstans i metrikvyn. Det finns två transformationsstrategier, beroende på om du vill ha en rad per arrayelement eller ett enda värde per källrad. Båda gäller oavsett om arrayen finns i den högsta källkoden eller i en tabell du ansluter till. Se Transformera komplexa datatyper för hela uppsättningen av transformationsfunktioner.

Ingen datamängd i katalogen samples har en arraykolumn, så exemplen i detta avsnitt använder en orders vy som har en line_items array av strukturer. Använd följande exempel för att skapa en vy med ett fält som är en array. Ersätt catalog.schema med katalogen och schemat du vill skriva efter. Du måste ha behörigheter för att skapa objekt i det schemat.

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;

Platta ut en matris i rader

För att analysera varje arrayelement som en egen rad, använd explode() i source frågan för att packa upp arrayen. Varje element blir en separat rad, och källradens övriga kolumner upprepas för varje element. Se Explodera nästlade element från en karta eller array.

Följande exempel packar upp arrayen line_items så att varje objekt blir en rad:

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)

Att explodera arrayen i multiplicerar source källraderna, så en aggregering som COUNT(1) räknar arrayelementen, inte de ursprungliga raderna. För att också mäta de ursprungliga raderna utan utslag, modellera den exploderade tabellen som en one_to_many skarv istället. Se En-till-många-kopplingar.

Aggregera en array till ett enda värde

För att reducera en array till ett värde per källrad utan att ändra radantalet, applicera en skalär arrayfunktion i frågan source , såsom aggregate(), array_size(), eller reduce(). Varje källrad behåller sitt korn, och den beräknade kolumnen är tillgänglig för fält och mått.

Följande exempel beräknar antalet objekt och den totala mängden av arrayen line_items 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)

Eftersom källfrågan minskar arrayen innan metrikvyn bearbetar den, behåller källan en rad per order och mäter aggregerat över order som vanligt.

Lös en array i en sammanfogad tabell

Samma regel gäller när arrayen finns i en tabell du vill gå med i, inte i den högsta källkoden. En join arbetar på platta kolumner, så lös arrayen i den sammanfogade tabellens egen source delfråga innan joinen. Skriv join source som en SQL-fråga som plattar ut eller aggregerar arrayen, och join sedan på de resulterande kolumnerna. Se Joins i metriska vyer.

Följande exempel använder customer som källa och joinar vyn orders med cardinality: one_to_many. Joinen source aggregerar varje orders line_items array till en skalar total_quantity före joinen, så att mätvärdsvyn kan summera det per kund utan att duplicera kundrader:

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)

För att istället behandla varje arrayelement som en egen rad i den sammanfogade tabellen, platta ut matrisen med explode() i joinen source på samma sätt. Se Platta ut en array i rader.

Fält

Fält, även kallade dimensioner, är kolumner i måttvyn som du kan använda i satserna SELECT, WHERE och GROUP BY när frågan körs. Ett fält kan vara en kategorisk kolumn, till exempel region eller status, eller en oaggregerad numerisk kolumn, till exempel pris eller kvantitet, som du kan aggregera vid frågetillfället. Varje fältuttryck måste returnera ett skalärt värde. Den kan referera till kolumner från källdata eller fält som definierats tidigare i måttvyn. Varje fält består av två komponenter:

• name: Aliaset för kolumnen
• expr: Ett SQL-uttryck som refererar till källdata eller tidigare definierade fält i måttvyn

Varning

Strängliknande måttvyfält är alltid STRING, även när källkolumnen är CHAR eller VARCHAR. Eftersom CHAR(n) utfyllnad av utrymme går förlorad kan jämförelser returnera olika resultat. Matchar till exempel column = 'COLLEGE' ett CHAR(10) värde i källtabellen (som är blankstegsfyllt) men inte i måttvyfältet.

Åtgärder

Mått är uttryck som ger resultat utan en fördefinierad aggregeringsnivå. De måste uttryckas med hjälp av aggregerade funktioner. Om du vill referera till ett mått i en fråga använder du MEASURE funktionen. Mått kan referera till baskolumner i källdata, tidigare definierade fält eller tidigare definierade mått. Varje mått består av följande komponenter:

• name: Måttets alias
• expr: Ett aggregerat SQL-uttryck som kan innehålla SQL-mängdfunktioner

I följande exempel visas vanliga måttmönster för analys av order- och intäktsdata. I de här exemplen används tabellen TPC-H order, som innehåller försäljningstransaktionsdata, inklusive orderpriser (o_totalprice), kundidentifierare (o_custkey), ordernycklar (o_orderkey), orderdatum (o_orderdate) och prioritetsnivåer (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))

Se Mängdfunktioner för en lista över aggregerade funktioner.

Tillämpa filter

Ett filter gäller för alla frågor som refererar till måttvyn. Information om hur du definierar ett filter i användargränssnittet finns i Steg 3: Definiera ett filter.

Om du vill definiera ett filter i YAML-definitionen skriver du ett booleskt uttryck. I följande exempel visas vanliga filtermönster:

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

Arbeta med sammanfogningar

Måttvyer stöder kopplingar för att utöka dina källdata med attribut från relaterade tabeller. Du kan modellera stjärnscheman (faktatabell ansluten till dimensionstabeller), snowflake-scheman (dimensionskopplingar på flera nivåer) och en-till-många-relationer (faktaexpansion från en dimensionell källa). Mer information om kopplingstyper, kardinalitet, schemamönster och begränsningar finns i Kopplingar i måttvyer.

Information om hur du definierar kopplingar i användargränssnittet finns i Steg 2: Lägg till en koppling. Om du vill definiera kopplingar i YAML-definitionen använder du mönstren i följande avsnitt.

Note

Sammanfogade tabeller kan inte inkludera ARRAY eller MAP typa kolumner. För att lösa arrayer eller avbildningar till platta kolumner innan sammanfogning, se Resolv-arrayer och kartor i källan.

Modellstjärnscheman

I ett stjärnschema är source faktatabellen, som kopplas till en eller flera dimensionstabeller med hjälp av en LEFT OUTER JOIN. Måttvyer kopplar ihop de fakta- och dimensionstabeller som behövs för den specifika frågan, baserat på de valda fälten och måtten.

Ange kopplingskolumner med antingen en on sats (booleskt uttryck) eller en using sats (delade kolumnnamn). Kopplingen måste följa en många-till-en-relation. Vid många-till-många väljer motorn den första matchande raden från den anslutna dimensionstabellen.

I följande exempel kopplas orders (faktatabell) till customer (dimensionstabell) och kundattribut exponeras som fält. Inställningen rely.at_most_one_match: true anger att sammanfogningen är många-till-en (varje beställning har exakt en kund), vilket gör det möjligt för motorn att optimera frågor som filtrerar på fält från den sammanfogade tabellen.

Varning

Ange at_most_one_match: true endast när relationen är många-till-en. Den här egenskapen verifieras inte vid körning. Om sammanfogningen ger upphov till en fan-out returnerar mätvärdena felaktiga resultat.

Se Optimera kopplingar med 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-syntax och formatering

Måttvydefinitioner följer yaml-standardsyntaxen för notering. Se YAML-syntaxreferens för måttvy för den syntax och formatering som krävs.

Metodtips

Använd följande riktlinjer när du modellerar måttvyer:

• Modellera atomiska mått: Börja med att definiera de enklaste måtten först (till exempel SUM(revenue), COUNT(DISTINCT customer_id)). Skapa komplexa mått med hjälp av komposabilitet.
• Standardisera fältvärden: Använd transformeringar (till exempel CASE instruktioner) för att konvertera databaskoder till tydliga företagsnamn (till exempel konvertera orderstatusen "O" till "Open" och "F" till "Fulfilled").
• Definiera omfång med filter: Om en måttvy endast ska innehålla slutförda beställningar definierar du det filtret i måttvyn så att användarna inte oavsiktligt kan inkludera ofullständiga data.
• Använd tydlig namngivning: Måttnamn ska vara igenkännliga för företagsanvändare (till exempel "Kundens livslängdsvärde" i stället cltv_agg_measureför ).
• Separata tidsfält: Inkludera detaljerade tidsfält (till exempel "Orderdatum") och trunkerade tidsfält (till exempel "Ordermånad" eller "Ordervecka") för att aktivera både detaljnivå- och trendanalys.

Ytterligare resurser

• Ansluter till måttvyer
• Avancerade tekniker för måttvyer
• Agentmetadata i måttvyer
• Materialisering för metriska vyer
• Yaml-syntaxreferens för måttvy