Kommentar
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
I medaljongarkitekturer måste du framtvinga datakvalitet i varje steg. Dålig datakvalitet kan leda till felaktiga insikter och driftineffektivitet.
Den här artikeln beskriver hur du implementerar datakvalitetskontroller i materialiserade lakevyer (MLV:er) i Microsoft Fabric.
Säkerställa datakvalitet
Radnivåbegränsningar validerar varje rad isolerat (till exempel "customerName är inte null på denna rad"). Många verkliga kvalitetsproblem är dock egenskaper hos en kolumn som helhet:
-
Unicitet — en primär- eller affärsnyckel som
order_idhar inga dubbletter. -
Fullständighet — en kritisk kolumn som inte innehåller
customer_idnullvärden. - Statistisk profil — medelvärdet, storleken eller fördelningen av en kolumn håller sig inom ett förväntat intervall.
Att upptäcka dessa problem vid uppdatering stoppar dålig data från att spridas nedströms genom din brons→silver→guldkedja och ger dig en granskabar kvalitetssignal vid varje körning.
Begränsningar för radnivådatakvalitet
I materialiserade lake views (MLV) i Fabric, upprätthåll datakvaliteten genom att definiera begränsningar för dina vyer. Utan tydliga kontroller kan mindre dataproblem öka bearbetningstiden eller leda till att pipelinen misslyckas.
När en rad bryter mot en begränsning kan du använda någon av följande åtgärder:
FAIL: Stoppar MLV-uppdateringen vid den första begränsningsöverträdelsen. Detta är standardbeteendet, även om du inte anger
FAIL.DROP: Fortsätter bearbetningen och tar bort poster som bryter mot villkoret. Släktträdsvisningen visar antalet förlorade poster.
Anmärkning
Om du definierar både DROP- och FAIL-åtgärder i en MLV har åtgärden FAIL företräde.
Definiera datakvalitetskontroller i en materialiserad sjövy
När du skapar en materialiserad sjövy kan du definiera begränsningar – datakvalitetsregler som verifierar varje rad under en uppdatering. En begränsning är ett booleskt uttryck som varje rad måste uppfylla. Rader som passerar skrivs till utdatatabellen. Rader som misslyckas hanteras enligt inställningen vid överträdelse: de tas antingen bort tyst eller gör att hela uppdateringen misslyckas.
I följande exempel definieras villkoret cust_blank, som kontrollerar om fältet customerName inte är null. Villkoret exkluderar rader med null customerName från bearbetning.
CREATE OR REPLACE MATERIALIZED LAKE VIEW IF NOT EXISTS silver.customers_enriched
(CONSTRAINT cust_blank CHECK (customerName is not null) on MISMATCH DROP)
AS
SELECT
c.customerID,
c.customerName,
c.contact,
CASE
WHEN COUNT(o.orderID) OVER (PARTITION BY c.customerID) > 0 THEN TRUE
ELSE FALSE
END AS has_orders
FROM bronze.customers c LEFT JOIN bronze.orders o
ON c.customerID = o.customerID;
Inbyggda systemfunktioner
Inbyggda Spark/SQL-funktioner som UPPER(), LOWER(), TRIM(), COALESCE(), INITCAP() och DATE_FORMAT() stöds fullt ut i alla MLV-kontexter för både CREATE- och LINEAGE-uppdatering.
CREATE MATERIALIZED LAKE VIEW sample_lakehouse.silver.names (
CONSTRAINT substring_check
CHECK (SUBSTRING(name, 1, 2) = 'Al') ON MISMATCH drop
) AS
SELECT id, name
FROM (VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Ann')) AS t(id, name)
Anmärkning
Systemfunktioner är det enklaste och mest tillförlitliga alternativet. De kräver ingen registrering, fungerar i alla kontexter och stöds fullt ut under LINEAGE-uppdateringen.
UDF:er – Definierade och registrerade i samma notebook
UDF:er som registrerats med spark.udf.register() i samma notebook-fil stöds för CREATE i alla kontexter. För LINEAGE-uppdatering stöds endast PySpark-kontexter eftersom UDF-definitionen körs som en del av den schemalagda notebook-körningen.
from pyspark.sql import SparkSession
from pyspark.sql.types import StringType
from pyspark.sql.functions import expr
spark = SparkSession.builder.getOrCreate()
# UDF: Extract domain from email
def extract_email_domain(email):
if email is None or '@' not in email:
return None
return email.split('@')[1]
# Registration
spark.udf.register(
"udf_email_domain",
extract_email_domain,
StringType()
)
@fmlv.materialized_lake_view(
name="udf_testing_silver.mlv_high_value_customers",
comment="High-value customers identified by UDF criteria",
table_properties={"delta.enableChangeDataFeed": "true"}
)
def mlv_high_value_customers():
return spark.sql("""
SELECT
c.customer_id,
c.name,
c.email,
udf_email_domain(c.email) as email_domain,
c.segment,
c.lifetime_value,
total_transactions.total_amount,
total_transactions.txn_count
FROM udf_testing_bronze.customers c
INNER JOIN (
SELECT
customer_id,
SUM(amount) as total_amount,
COUNT(*) as txn_count
FROM udf_testing_bronze.transactions
WHERE udf_is_positive(amount)
GROUP BY customer_id
HAVING SUM(amount) > 1000
) total_transactions ON c.customer_id = total_transactions.customer_id
WHERE udf_validate_customer(c.email, c.age)
AND c.segment IN ('premium', 'vip')
""")
print("✓ Created mlv_high_value_customers")
Tredjepartsbibliotek - Pandas UDFer
Bibliotek från tredje part som Pandas UDF:er tillåter att datakvalitetsregler implementeras med vektoriserad bearbetning. De möjliggör avancerade valideringar som anpassad affärslogik, statistiska kontroller eller mönsteridentifiering som inte är möjliga med inbyggda funktioner. Detta hjälper dig att skapa skalbara och återanvändbara datakvalitetsbegränsningar när MLV skapas och uppdateras.
import fmlv
from pyspark.sql.types import StructType, StructField, IntegerType, TimestampType, StringType, DoubleType, BooleanType
from datetime import datetime
import pandas as pd
from pyspark.sql.types import BooleanType
def pandas_check_impl(val):
# Reject if value < median of [100, 200, 300]
return val >= pd.Series([100, 200, 300]).median()
spark.udf.register("pandas_check", pandas_check_impl, BooleanType())
@fmlv.materialized_lake_view(
name="silver.pyspark_from_two_sqlmlv_inner_pandas",
comment="PySpark MLV INNER JOIN using pandas-based constraint and DROP violations"
)
@fmlv.check(
name="dq_pandas_check",
condition="pandas_check(l3)",
action="DROP"
)
def pyspark_from_two_sqlmlv_inner_pandas():
# Define the function
# Register the function as a Spark UDF
# Read source tables
df1 = spark.table("silver.base_sqlmlv")
df2 = spark.table("silver.base_sqlmlv")
# Rename columns for unique join
df_left = df1.select([df1[col].alias(f"l{i+1}") for i, col in enumerate(df1.columns)])
df_right = df2.select([df2[col].alias(f"r{i+1}") for i, col in enumerate(df2.columns)])
# Perform INNER JOIN
df = df_left.join(df_right, df_left.l1 == df_right.r1, "inner")
return df
df = spark.table("silver.pyspark_from_two_sqlmlv_inner_pandas")
# All amounts should be >= median (200)
assert all(df.select("l3").rdd.map(lambda r: r[0] >= 200).collect()), "Unexpected low-value rows found"
print("PySpark MLV INNER JOIN with pandas-based DQ DROP passed")
Anpassade bibliotek – Python wheel (.whl)
Funktioner som paketeras som jar-filer eller hjulfiler kan installeras i Infrastrukturklustret (via miljöinställningar) och användas i MLV-definitioner. CREATE och LINEAGE REFRESH stöds för PySpark-kontexter. Mer information finns i Hantera anpassade bibliotek i Fabric-miljöer.
%%pyspark
import fmlv
from pyspark.sql.types import StructType, StructField, IntegerType, TimestampType, StringType, DoubleType, BooleanType
from datetime import datetime
from pyspark.sql.types import BooleanType
from custom_dq_lib import threshold_check
def custom_check_impl(val):
return threshold_check(val, threshold=200)
spark.udf.register("custom_check", custom_check_impl, BooleanType())
@fmlv.materialized_lake_view(
name="silver.pyspark_from_two_sqlmlv_inner_custom_whl",
comment="PySpark MLV INNER JOIN using custom DQ library and DROP violations",
replace=True
)
@fmlv.check(
name="dq_custom_check",
condition="custom_check(l3)",
action="DROP"
)
def pyspark_from_two_sqlmlv_inner_custom():
# Wrap the custom function as Spark UDF
# Read source tables
df1 = spark.table("silver.base_sqlmlv")
df2 = spark.table("silver.base_sqlmlv")
# Rename columns for unique join
df_left = df1.select([df1[col].alias(f"l{i+1}") for i, col in enumerate(df1.columns)])
df_right = df2.select([df2[col].alias(f"r{i+1}") for i, col in enumerate(df2.columns)])
# Perform INNER JOIN
df = df_left.join(df_right, df_left.l1 == df_right.r1, "inner")
return df
df = spark.table("silver.pyspark_from_two_sqlmlv_inner_custom_whl")
# All amounts should be >= threshold (200)
assert all(df.select("l3").rdd.map(lambda r: r[0] >= 200).collect()), "Unexpected low-value rows found"
print("PySpark MLV INNER JOIN with custom DQ library passed")
Fabric-användardatafunktioner
Användardatafunktioner i Fabric (UDF) definieras och hanteras centralt i Fabric-arbetsytan. De är tillgängliga för alla notebooks eller pipelines utan att behöva registreras om per session, vilket gör dem idealiska för MLV-pipelines för produktion. Den här funktionen stöds endast i PySpark-kontexter för både CREATE- och LINEAGE-uppdatering. Läs mer om Användardatafunktioner här. För mer information, se Översikt över Fabric-användardatafunktioner.
%%pyspark
import fmlv
from pyspark.sql import functions as F
from notebookutils import udf
myFuncs = udf.getFunctions("UserDataFunction_1")
def add_greeting_column(df):
pdf = df.toPandas()
pdf["greeting"] = pdf["name"].apply(lambda n: myFuncs.hello_fabric(n))
return spark.createDataFrame(pdf)
import fmlv
from pyspark.sql.types import StructType, StructField, IntegerType, StringType, DoubleType
# -------------------------------------------------------------
# Define base PySpark MLV (no SQL)
# -------------------------------------------------------------
@fmlv.materialized_lake_view(
name="silver.base_pysparkmlv",
comment="Base MLV created using PySpark",
replace=True
)
def base_pysparkmlv():
schema = StructType([
StructField("id", IntegerType(), True),
StructField("name", StringType(), True),
StructField("amount", DoubleType(), True),
StructField("country", StringType(), True)
])
data = [
(1, "Alice", 100.0, "US"),
(2, "Bob", 200.0, "UK"),
(3, "Charlie", 300.0, "UK")
]
return spark.createDataFrame(data, schema)
@fmlv.materialized_lake_view(
name="silver.mlv_udfn_null_test",
replace=False
)
@fmlv.check(
name="null_check",
condition="greeting IS NOT NULL",
action="FAIL"
)
def mlv_udfn_null_test():
df = spark.table("silver.base_pysparkmlv")
return add_greeting_column(df)
Kolumnnivå-kvalitetskontroller av data
Så här fungerar det
Definiera kolumnnivå-datakvalitetskontroller (DQ) med tre Python-dekoratorer som du placerar i en notebook-cell, separat från MLV-definitionen:
| Decorator | Purpose |
|---|---|
@fmlv.dq_suite(mlv_name=…) |
Registrerar en datakvalitetssvit mot en namngiven, befintlig MLV och laddar dess data för att kontrollerna ska köras på. |
@fmlv.validate("<fn>", "FAIL"\|"WARN") |
Kör en valideringskontroll med ett godkänt/underkänt resultat och en vald åtgärd (se Kontrollera utfallet nedan). |
@fmlv.analyze("<fn>") |
Kör en profileringskörning som beräknar kolumnmetrik (storlek, fullständighet, medelvärde, ...). Producerar bara mätvärden – det gör aldrig att körningen misslyckas. |
Eftersom sviten riktar in sig på en MLV via namn kan datakvalitet ägas, köras och schemaläggas oberoende av MLV-definitionen – och du kan köra kontroller utan att utlösa en uppdatering.
Steg 1: Ställ in körmiljön
Konfigurera beroendena för din Fabric-runtimeversion innan du definierar kvalitetskontroller på kolumnnivå.
Fabric runtimes tidigare än 2.0
Ladda ner PyDeequ 1.7.0-wheelen och ladda upp det som ett eget bibliotek i din Fabric-miljö. För instruktioner, se Ladda upp anpassade bibliotek.
Fabric runtime 2.0 eller senare
Lägg till följande Spark-egenskaper:
| Spark-egenskap | Value |
|---|---|
spark.driver.extraClassPath |
/opt/deequ/jars/* |
spark.executor.extraClassPath |
/opt/deequ/jars/* |
Du kan lägga till dessa egenskaper antingen i en miljö eller i en anteckningsbok:
- Miljö: Lägg till egenskaperna under Spark Compute>Spark-egenskaper, spara och publicera sedan miljön. För instruktioner, se Lägg till Spark-konfigurationer i en anpassad miljö.
-
Anteckningsbok: Lägg till egenskaperna i
conf-objektet i ett%%configure-kommando i den första kodcellen innan du startar Spark-sessionen. För instruktioner, se magiskt kommando för Spark-sessionskonfiguration.
Steg 2: Definiera kontroller på kolumnnivå
I detta exempel definierar du kvalitetskontroller på kolumnnivå för den sales_db.daily_orders materialiserade lake-vyn, specificerad av mlv_name i @fmlv.dq_suite.
Placera svitregistreringen och dess inträdesfunktioner i en enda datakvalitetscell. Följande exempel kör två kontroller i ett valideringspass — customer_id måste vara komplett (inga nullvärden) och order_id måste vara unikt:
import os
os.environ["SPARK_VERSION"] = "3.5" # works on both 3.5 and 4.1
import fmlv
# Entry function — returns a PyDeequ VerificationResult DataFrame
def completeness_and_uniqueness(df):
from pydeequ.checks import Check, CheckLevel
from pydeequ.verification import VerificationSuite, VerificationResult
check = Check(spark, CheckLevel.Error, "Completeness & Uniqueness")
result = (
VerificationSuite(spark)
.onData(df)
.addCheck(
check.isComplete("customer_id") # check 1: no nulls
.isUnique("order_id") # check 2: no duplicates
)
.run()
)
return VerificationResult.checkResultsAsDataFrame(spark, result)
# Data quality cell — separate from the MLV definition
@fmlv.dq_suite(mlv_name="sales_db.daily_orders", replace=True)
@fmlv.validate("completeness_and_uniqueness", "FAIL")
def daily_orders_dq():
pass
Lägg till mätvärden utan att misslyckas med körningen. Stapla ett @fmlv.analyze pass för att beräkna kolumnmetrik (storlek, fullständighet, medelvärde, ...) för observabilitet. Analysresultat registreras alltid och blockerar aldrig en körning – användbart medan valideringsreglerna fortfarande utvecklas.
import os
os.environ["SPARK_VERSION"] = "3.5" # works on both 3.5 and 4.1
import fmlv
# Entry function — returns a PyDeequ AnalyzerContext metrics DataFrame
def column_profiling(df):
from pydeequ.analyzers import AnalysisRunner, AnalyzerContext, Size, Completeness, Mean
result = (
AnalysisRunner(spark)
.onData(df)
.addAnalyzer(Size())
.addAnalyzer(Completeness("customer_id"))
.addAnalyzer(Mean("amount"))
.run()
)
return AnalyzerContext.successMetricsAsDataFrame(spark, result)
# Data quality cell — separate from the MLV definition
@fmlv.dq_suite(mlv_name="sales_db.daily_orders", replace=True)
@fmlv.validate("completeness_and_uniqueness", "FAIL")
@fmlv.analyze("column_profiling")
def daily_orders_dq():
pass
Kontrollera resultatet: FAIL vs. WARN
Åtgärden på @fmlv.validate avgör vad som händer när en kontroll misslyckas:
-
FAIL— kontrollfelet gör att datakvalitetskörningen misslyckas och blockerar de nedströms MLV:er som är beroende av det. Använd det för strikta kontrakt som primärnycklar och obligatoriska fält. -
WARN— misslyckandet loggas men körningen lyckas ändå och nedströms MLV:er blockeras inte . Använd det för mjuka eller rådgivande regler.
Steg 3: Aktivera datakvalitetskontroller enligt ett schema
Välj om kolumnnivåkontroller körs som en del av ett uppdateringsschema. I de avancerade inställningarna i upplevelsen Skapa nytt schema erbjuder listrutan Datakvalitetskontroller två alternativ:
- Kontrollera efter varje körning — datakvalitetssviten körs automatiskt efter varje MLV-uppdatering i det schemat har slutförts.
- Inga kontroller — datakvaliteten hoppas över för det schemat; MLV uppdateras fortfarande på sin rytm.
Datakvalitetskontroller-inställningen i schemats avancerade inställningar — välj Kontrollera efter varje körning eller Inga kontroller.
Hur en misslyckad kontroll påverkar pipelinen
I linjevyn definierades datakvalitetskontrollen på gold.daily_dq_reportusage med FAIL och underkändes. Som ett resultat är den nedströms beroende grenen, gold.monthly_dq_report…, automatiskt överhoppad, medan oberoende grenar (gold.expected_regions, gold.region_mlv_dq_rep…) slutförs normalt.
En FAIL datakvalitetskontroll stoppar flödet — den misslyckade nodens nedströms beroende hoppas över, men oberoende grenar fortsätter.
Körordning. När en svit har båda typerna körs alla @fmlv.validate funktioner först (i definitionsordning), sedan alla @fmlv.analyze funktioner. En misslyckad kontroll registreras och utförandet fortsätter; det övergripande resultatet avgörs efter att alla kontroller är klara — körningen misslyckas endast om en FAIL-åtgärdskontroll misslyckades.
Steg 4: Se och analysera datakvalitetsrapporten
Körhistoriken visar om datakvaliteten var på eller av vid varje körning. Du kan också köra en svit på begäran från dess notebook när som helst, oberoende av någon uppdatering.
Välj en MLV-nod i linjevyn och öppna fliken Datakvalitet i detaljpanelen för att se resultatet av den körningen:
-
Beräknade mätvärden — de kolumnnivå-aggregatmetriker som beräknas av Deequ-analysatorerna (till exempel
Completenessavregion). - Verifieringsresultat — en sammanfattning av totala kontroller, totalt antal godkända och totalt antal underkända, följt av varje begränsning och dess godkänd/underkänd status, så att du kan se exakt vilken regel som godkändes eller misslyckades.
Fliken Datakvalitet visar beräknade mätvärden och verifieringsresultat per begränsning för den valda MLV-körningen.
MLV-körhistoriken visar också en datakvalitetsstatus för varje körning — Lyckad, Misslyckad eller ingen indikator när ingen svit kördes — så att du kan upptäcka problemkörningar direkt utan att öppna varje nod.
Kontroller och analysverktyg som stöds
Eftersom kolumnnivå-DQ drivs av det öppna Deequ-biblioteket kan du använda alla Deequs kontroller och analysatorer i dina entry-funktioner.
Valideringskontroller (använda med @fmlv.validate) är Check begränsningar som ger ett godkänt/underkänt resultat; analysatorer (använda med @fmlv.analyze) beräknar en metrik utan godkänt/underkänt-resultat. De vanligaste listas i följande tabeller.
Valideringskontroller — @fmlv.validate
| Check | Description | Example |
|---|---|---|
hasSize |
Antalet rader i vyn uppfyller ett villkor. | .hasSize(lambda s: s == 5) |
isComplete |
Kolumnen innehåller inga nullvärden. | .isComplete("customer_id") |
hasCompleteness |
Andelen icke-nullvärden når en tröskel. | .hasCompleteness("email", lambda c: c >= 0.9) |
isUnique |
Kolumnen har inga dubblettvärden. | .isUnique("order_id") |
hasUniqueness |
Andelen unika värden uppfyller ett villkor. | .hasUniqueness(["brand"], lambda u: u == 1.0) |
hasDistinctness |
Andelen av olika värden uppfyller ett villkor. | .hasDistinctness(["title"], lambda d: d > 0.5) |
isPrimaryKey |
Kolumnen (eller kolumnuppsättningen) identifierar entydigt varje rad. | .isPrimaryKey("order_id") |
isContainedIn |
Alla värden faller inom en tillåten mängd. | .isContainedIn("priority", ["high", "low"]) |
isNonNegative / isPositive |
Kolumnen innehåller inga negativa / endast strikt positiva värden. | .isNonNegative("num_views") |
isLessThan / isGreaterThan |
En kolumn är konsekvent mindre / större än en annan. | .isLessThan("discount", "price") |
hasMin / hasMax |
Kolumnens minimum/maximum uppfyller ett villkor. | .hasMax("age", lambda v: v <= 120) |
hasMean / hasSum |
Kolumnens medelvärde / summa uppfyller ett villkor. | .hasSum("total_votes", lambda v: v > 0) |
hasStandardDeviation |
Kolumnens standardavvikelse uppfyller ett villkor. | .hasStandardDeviation("amount", lambda v: v < 5) |
hasApproxQuantile |
En approximativ kvantil (till exempel median) uppfyller ett villkor. | .hasApproxQuantile("num_views", 0.5, lambda v: v <= 10) |
hasCorrelation |
Pearson-korrelationen mellan två kolumner uppfyller ett villkor. | .hasCorrelation("a", "b", lambda c: c > 0.8) |
hasNumberOfDistinctValues |
Antalet olika värden uppfyller ett villkor. | .hasNumberOfDistinctValues("locale", lambda n: n == 5) |
hasEntropy |
Informationsinnehållet (entropin) i kolumnen uppfyller ett villkor. | .hasEntropy("locale", lambda e: e > 2.0) |
hasDataType |
Värdena överensstämmer med en förväntad datatyp. | .hasDataType("id", ConstrainableDataTypes.Integral) |
hasPattern / containsURL / containsEmail |
Andelen av värden som matchar ett regex / URL / e-postmönster uppfyller ett villkor. | .containsURL("description", lambda c: c >= 0.5) |
containsCreditCardNumber / containsSocialSecurityNumber |
Andelen värden som matchar ett kreditkorts- eller personnummermönster uppfyller ett villkor. | .containsCreditCardNumber("notes", lambda c: c == 0) |
satisfies |
Andelen rader som uppfyller ett anpassat SQL-predikat uppfyller ett krav. | .satisfies("age >= 18", "adults", lambda c: c == 1.0) |
analysverktyg / mätvärden — @fmlv.analyze
| Metric | Description | Example |
|---|---|---|
ApproxCountDistinct |
Ungefärligt antal olika värden, beräknat med HyperLogLog++-skisser. | ApproxCountDistinct("product_id") |
ApproxQuantile |
Approximativt kvantilvärde för en fördelning. | ApproxQuantile("locale_encoded", 0.5) |
ApproxQuantiles |
Flera ungefärliga kvantiler av en fördelning. | ApproxQuantiles("locale_encoded", [0.1, 0.5, 0.9]) |
Completeness |
Andel icke-nullvärden i en kolumn. | Completeness("product_id") |
Compliance |
Andelen rader som uppfyller en given kolumnbegränsning. | Compliance("locale", "locale in ('es','jp','us')") |
Correlation |
Pearson-korrelation mellan två kolumner, i intervallet [-1, 1]. | Correlation("title", "brand") |
CountDistinct |
Antal olika värden. | CountDistinct("locale") |
DataType |
Fördelning av datatyper (boolesk, fraktionell, integral, sträng). | DataType("locale") |
Distinctness |
Andelen unika värden av det totala antalet värden. | Distinctness("title") |
Entropy |
Informationsinnehållet i en kolumns värdefördelning, mätt i nats. | Entropy("locale_encoded") |
Maximum / Minimum |
Maximalt/minimalt värde för en kolumn. | Maximum("locale_encoded") |
Mean |
Medelvärde; nullvärden exkluderas. | Mean("locale_encoded") |
MutualInformation |
Hur mycket information om en kolumn kan härledas från en annan; symmetrisk och icke-negativ. | MutualInformation(["title", "brand"]) |
PatternMatch |
Andelen rader som följer ett givet reguljärt uttryck. | PatternMatch("locale", r"\w{2}") |
Size |
Antal rader i DataFrame. | Size() |
Sum |
Summan av alla värden i en kolumn. | Sum("total_votes") |
UniqueValueRatio |
Andelen unika värden över antalet alla distinkta värden. | UniqueValueRatio(["brand"]) |
Uniqueness |
Andelen unika värden av antalet av alla värden. | Uniqueness(["brand"]) |
Det öppna Deequ-biblioteket tillhandahåller dessa kontroller och analysatorer. För den kompletta och auktoritativa listan, se Deequ-projektet på github.com/awslabs/deequ.
Summary
- Skapa din MLV och notera dess fullt kvalificerade namn.
-
I en separat datakvalitetscell, registrera en svit med
@fmlv.dq_suite(mlv_name=…). -
Lägg till kontroller — stapla
@fmlv.validate("<fn>", "FAIL"|"WARN")och/eller@fmlv.analyze("<fn>")och skriv matchande inmatningsfunktioner som returnerar PyDeequ DataFrames. - Kör det — på begäran från notebooken, eller slå på växeln för datakvalitet när du skapar ett schema.
- Granska resultaten i datahärkomstfliken Datakvalitet och i körhistoriken.
Relaterat innehåll
- Datakvalitet i Materialized Lake Views — Microsoft Learn
- Översikt över materialiserade Lake-vyer — Microsoft Learn
- DeeQu-dokumentation