Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
In medaillonarchitecturen moet u in elke fase de gegevenskwaliteit waarborgen. Slechte gegevenskwaliteit kan leiden tot onjuiste inzichten en operationele inefficiënties.
In dit artikel wordt uitgelegd hoe u controles van gegevenskwaliteit implementeert in gerealiseerde LAKE-weergaven (MLV's) in Microsoft Fabric.
Gegevenskwaliteit implementeren
Beperkingen op rijniveau valideren elke rij geïsoleerd (bijvoorbeeld, "customerName is niet NULL op deze rij"). Veel echte kwaliteitsproblemen zijn echter eigenschappen van een kolom als geheel:
-
Uniekheid — een primaire of businesssleutel zoals
order_id, heeft geen duplicaten. -
Volledigheid — een kritische kolom zoals
customer_idgeen nullen bevat. - Statistische verdeling — het gemiddelde, de grootte of de verdeling van een kolom blijft binnen een verwacht bereik.
Het opsporen van deze problemen op het moment van verversen voorkomt dat slechte data stroomafwaarts via je bronze→silver→gold-ketting doorgaat en geeft je bij elke run een controleerbaar kwaliteitssignaal.
Datakwaliteitsbeperkingen op rijniveau
In gematerialiseerde lakeviews (MLV's) in Fabric behoud je de datakwaliteit door beperkingen op je weergaven te definiëren. Zonder expliciete controles kunnen kleine gegevensproblemen de verwerkingstijd verhogen of de pijplijn mislukken.
Wanneer een rij een beperking schendt, kunt u een van deze acties gebruiken:
FAIL: Hiermee wordt MLV-vernieuwing gestopt bij de eerste schending van de restrictie. Dit is het standaardgedrag, zelfs wanneer u niet opgeeft
FAIL.DROP: Hiermee wordt de verwerking voortgezet en worden records verwijderd die de beperking schenden. In de afstammingsweergave ziet u het aantal verwijderde records.
Opmerking
Als u zowel DROP- als FAIL-acties in een MLV definieert, heeft de FAIL-actie voorrang.
Gegevenskwaliteitscontroles definiëren in een gerealiseerde lakeweergave
Wanneer u een gematerialiseerde lake-weergave maakt, kunt u beperkingen definiëren: regels voor gegevenskwaliteit die elke rij tijdens een vernieuwing valideren. Een beperking is een Boole-expressie waaraan elke rij moet voldoen. Rijen die worden doorgegeven, worden naar de uitvoertabel geschreven. Rijen die mislukken, worden verwerkt volgens de schendingsinstelling: ze worden stilletjes verwijderd of zorgen ervoor dat het hele vernieuwingsproces mislukt.
In het volgende voorbeeld wordt de beperking cust_blankgedefinieerd, waarmee wordt gecontroleerd of het customerName veld niet null is. De beperking sluit rijen met een null customerName uit van verwerking.
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;
door het systeem ingebouwde functies
Ingebouwde Spark-/SQL-functies zoals UPPER(), LOWER(), TRIM(), COALESCE(), INITCAP() en DATE_FORMAT() worden volledig ondersteund in alle MLV-contexten voor zowel CREATE- als LINEAGE-vernieuwing.
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)
Opmerking
Systeemfuncties zijn de eenvoudigste en meest betrouwbare optie. Ze vereisen geen registratie, werken in alle contexten en worden volledig ondersteund tijdens de verversing van de LINEAGE.
UDF's – Gedefinieerd en geregistreerd in dezelfde notebook
UDF's die zijn geregistreerd bij spark.udf.register() in hetzelfde notebook, worden ondersteund voor CREATE in alle contexten. Voor LINEAGE-vernieuwing worden alleen PySpark-contexten ondersteund omdat de UDF-definitie wordt uitgevoerd als onderdeel van de geplande uitvoering van het notebook.
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")
Bibliotheken van derden - Pandas UDFs
Bibliotheken van derden, zoals Pandas UDF's, maken het mogelijk om regels voor gegevenskwaliteit te implementeren met gevectoriseerde verwerking. Ze maken geavanceerde validaties mogelijk, zoals aangepaste bedrijfslogica, statistische controles of patroondetectie die niet mogelijk zijn met ingebouwde functies. Dit helpt bij het bouwen van schaalbare en herbruikbare beperkingen voor gegevenskwaliteit tijdens het maken en vernieuwen van MLV.
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")
Aangepaste bibliotheken – Python wheel (.whl)
Functies die zijn verpakt als JAR-bestanden of wheel-bestanden kunnen worden geïnstalleerd op het Fabric-cluster (via omgevingsinstellingen) en worden gebruikt in MLV-definities. CREATE en LINEAGE REFRESH worden ondersteund voor PySpark-contexten. Zie Aangepaste bibliotheken beheren in Fabric-omgevingen voor meer informatie.
%%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-functies voor gebruikersgegevens
UDF's (Fabric User Data Functions) zijn centraal gedefinieerd en beheerd in de werkruimte Fabric. Ze zijn beschikbaar voor elke notebook of pijplijn zonder dat ze opnieuw moeten worden geregistreerd per sessie, waardoor ze ideaal zijn voor productie-MLV-pijplijnen. Deze functie wordt alleen ondersteund in PySpark-contexten voor zowel CREATE- als LINEAGE-vernieuwing. Meer informatie over gebruikersgegevensfuncties vindt u hier. Zie overzicht van Fabric User Data Functions voor meer informatie.
%%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)
Kolomniveau-kwaliteitscontroles van gegevens
Hoe werkt het?
Definieer kolomniveau datakwaliteitscontroles (DQ) met drie Python-decorators die je in een notebookcel plaatst, los van de MLV-definitie:
| Decorator | Purpose |
|---|---|
@fmlv.dq_suite(mlv_name=…) |
Registreert een datakwaliteitssuite aan een benoemde, bestaande MLV en laadt de gegevens ervan zodat de controles kunnen worden uitgevoerd. |
@fmlv.validate("<fn>", "FAIL"\|"WARN") |
Voert een validatiecheck uit met een goed-/afkeurresultaat en een gekozen actie (zie Controle van de uitkomst hieronder). |
@fmlv.analyze("<fn>") |
Voert een profileringspass uit die kolomstatistieken berekent (grootte, volledigheid, gemiddelde, ...). Levert alleen meetwaarden — het laat de uitvoering nooit mislukken. |
Omdat de suite een MLV op basis van de naam target, kan datakwaliteit onafhankelijk van de MLV-definitie worden beheerd, uitgevoerd en gepland — en je kunt controles uitvoeren zonder een vernieuwing te activeren.
Stap 1: Stel de runtime in
Configureer de afhankelijkheden voor je Fabric-runtimeversie voordat je kolomniveau-datakwaliteitscontroles definieert.
Fabric-runtimes vóór 2.0
Download het PyDeequ 1.7.0 wheel en upload het als een aangepaste bibliotheek in je Fabric-omgeving. Voor instructies, zie Aangepaste bibliotheken uploaden.
Fabric runtime 2.0 of hoger
Voeg de volgende Spark-eigenschappen toe:
| Spark-eigenschap | Value |
|---|---|
spark.driver.extraClassPath |
/opt/deequ/jars/* |
spark.executor.extraClassPath |
/opt/deequ/jars/* |
Je kunt deze eigenschappen toevoegen aan een omgeving of een notitieboek:
- Omgeving: Voeg de eigenschappen toe onder Spark Compute>Spark-eigenschappen, sla vervolgens de omgeving op en publiceer deze. Voor instructies, zie Spark-configuraties toevoegen aan een aangepaste omgeving.
-
Notitieboek: Voeg de eigenschappen toe in het
confobject van een%%configurecommando in de eerste codecel, voordat je de Spark-sessie start. Voor instructies, zie de magic command voor Spark-sessieconfiguratie.
Stap 2: Definieer kolomniveaucontroles
In dit voorbeeld definieer kolomniveau gegevenskwaliteitscontroles voor de sales_db.daily_orders gematerialiseerde lake view, gespecificeerd door mlv_name in @fmlv.dq_suite.
Plaats de registratie van de suite en de entryfuncties in één enkele datakwaliteitscel. Het volgende voorbeeld voert twee controles uit in één validatieronde — customer_id moet volledig zijn (geen null-waarden) en order_id moet uniek zijn:
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
Voeg meetwaarden toe zonder dat de run mislukt. Voer een @fmlv.analyze-pass uit om kolommetrieken te berekenen (grootte, volledigheid, gemiddelde, ...) voor observabiliteit. Analyseresultaten worden altijd geregistreerd en blokkeren nooit een run — nuttig zolang validatieregels nog in ontwikkeling zijn.
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
Beheers de uitkomst: FAIL vs. WARN
De actie op @fmlv.validate bepaalt wat er gebeurt als een check faalt:
-
FAIL— de mislukte controle zorgt ervoor dat de datakwaliteitsrun mislukt en blokkeert de downstream MLV's die ervan afhankelijk zijn. Gebruik het voor harde contracten zoals primaire sleutels en verplichte velden. -
WARN— de mislukking wordt geregistreerd, maar de run slaagt nog steeds en downstream MLV's worden niet geblokkeerd. Gebruik het voor niet-afdwingbare of adviserende regels.
Stap 3: Schakel datakwaliteitscontroles in in een schema in
Kies of kolomniveaucontroles als onderdeel van een verversingsschema worden uitgevoerd. In de Geavanceerde instellingen van de Nieuwe planning maken-ervaring biedt de vervolgkeuzelijst Controles voor gegevenskwaliteit twee opties:
- Controleer na elke run — de datakwaliteitssuite draait automatisch nadat elke MLV-verversing in dat schema is voltooid.
- Geen controles — de datakwaliteit wordt voor dat schema overgeslagen; de MLV ververst nog steeds op zijn ritme.
De instelling voor gegevenskwaliteitscontroles in de Geavanceerde instellingen van een schema — kies Controleren na elke run of Geen controles.
Hoe een mislukte controle de pipeline beïnvloedt
In de gegevensafstammingsweergave werd de gegevenskwaliteitscontrole op gold.daily_dq_reportusage gedefinieerd met FAIL en is deze mislukt. Als gevolg hiervan wordt de downstream-afhankelijke, gold.monthly_dq_report…, automatisch overgeslagen, terwijl onafhankelijke takken (gold.expected_regions, gold.region_mlv_dq_rep…) normaal worden voltooid.
Een FAIL gegevenskwaliteitscontrole stopt de keten — het afhankelijke vervolgknooppunt van de mislukte node wordt overgeslagen, maar onafhankelijke takken blijven doorgaan.
Uitvoeringsvolgorde. Wanneer een suite beide types heeft, draaien eerst alle @fmlv.validate functies (in definitievolgorde), daarna alle @fmlv.analyze functies. Een mislukte controle wordt geregistreerd en de uitvoering gaat verder; het uiteindelijke resultaat wordt bepaald nadat alle controles zijn voltooid — de run faalt alleen als een FAIL-actie-controle faalt.
Stap 4: Bekijk en analyseer het datakwaliteitsrapport
De uitvoeringsgeschiedenis geeft aan of de datakwaliteit aan of uit was voor elke uitvoering. Je kunt ook op elk moment een suite on-demand vanuit het notebook draaien, onafhankelijk van een verversing.
Selecteer een willekeurige MLV-node in de afstammingsweergave en open het tabblad Gegevenskwaliteit in het detailpaneel om de resultaten van die run te zien:
-
Berekende metrics — de geaggregeerde metrieken op kolomniveau die worden berekend door de Deequ-analyzers (bijvoorbeeld
Completenessvanregion). - Verificatieresultaten — een samenvatting van het totaal aantal controles, het totaal aantal geslaagde en het totaal aantal mislukte controles, gevolgd door elke beperking en de Status geslaagd/mislukt, zodat je precies kunt zien welke regel is geslaagd of mislukt.
Het tabblad Gegevenskwaliteit toont berekende metrics en per-constraint verificatieresultaten voor de geselecteerde MLV-run.
De MLV-rungeschiedenis toont ook een datakwaliteitsstatus voor elke run — Succes, Mislukt, of geen indicator wanneer er geen suite draaide — zodat je probleemruns in één oogopslag kunt herkennen zonder elke node te openen.
Ondersteunde controles en analyzers
Omdat DQ op kolomniveau wordt aangedreven door de open-source Deequ-bibliotheek, kun je alle controles en analyzers van Deequ gebruiken binnen je entryfuncties.
Validatiecontroles (gebruikt met @fmlv.validate) zijn Check beperkingen die een geslaagd/onvoldoende resultaat opleveren; analyzers (gebruikt met @fmlv.analyze) berekenen een metriek zonder geslaagd/gezakt. De meest voorkomende worden vermeld in de volgende tabellen.
Validatiecontroles — @fmlv.validate
| Controle | Description | Example |
|---|---|---|
hasSize |
Het aantal rijen van de weergave voldoet aan een voorwaarde. | .hasSize(lambda s: s == 5) |
isComplete |
De kolom bevat geen nullwaarden. | .isComplete("customer_id") |
hasCompleteness |
Het aandeel van niet-nullwaarden bereikt een drempel. | .hasCompleteness("email", lambda c: c >= 0.9) |
isUnique |
De kolom heeft geen dubbele waarden. | .isUnique("order_id") |
hasUniqueness |
De fractie van unieke waarden voldoet aan een voorwaarde. | .hasUniqueness(["brand"], lambda u: u == 1.0) |
hasDistinctness |
Het aandeel van unieke waarden voldoet aan een voorwaarde. | .hasDistinctness(["title"], lambda d: d > 0.5) |
isPrimaryKey |
De kolom (of een verzameling kolommen) identificeert elke rij uniek. | .isPrimaryKey("order_id") |
isContainedIn |
Alle waarden vallen binnen een toegestane verzameling. | .isContainedIn("priority", ["high", "low"]) |
isNonNegative / isPositive |
De kolom bevat geen negatieve / alleen strikt positieve waarden. | .isNonNegative("num_views") |
isLessThan / isGreaterThan |
De ene kolom is consequent kleiner / groter dan de andere. | .isLessThan("discount", "price") |
hasMin / hasMax |
De minimum-/maximumwaarde van de kolom voldoet aan een voorwaarde. | .hasMax("age", lambda v: v <= 120) |
hasMean / hasSum |
Het kolomgemiddelde of de kolomsom voldoet aan een voorwaarde. | .hasSum("total_votes", lambda v: v > 0) |
hasStandardDeviation |
De kolomstandaarddeviatie voldoet aan een voorwaarde. | .hasStandardDeviation("amount", lambda v: v < 5) |
hasApproxQuantile |
Een benaderend kwantiel (bijvoorbeeld mediaan) voldoet aan een voorwaarde. | .hasApproxQuantile("num_views", 0.5, lambda v: v <= 10) |
hasCorrelation |
De Pearson-correlatie tussen twee kolommen voldoet aan een voorwaarde. | .hasCorrelation("a", "b", lambda c: c > 0.8) |
hasNumberOfDistinctValues |
Het aantal verschillende waarden voldoet aan een voorwaarde. | .hasNumberOfDistinctValues("locale", lambda n: n == 5) |
hasEntropy |
De informatie-inhoud (entropie) van de kolom voldoet aan de voorwaarde. | .hasEntropy("locale", lambda e: e > 2.0) |
hasDataType |
Waarden voldoen aan een verwacht datatype. | .hasDataType("id", ConstrainableDataTypes.Integral) |
hasPattern / containsURL / containsEmail |
Het aandeel waarden dat overeenkomt met een regex / URL / e-mailpatroon voldoet aan een voorwaarde. | .containsURL("description", lambda c: c >= 0.5) |
containsCreditCardNumber / containsSocialSecurityNumber |
Het aandeel waarden dat overeenkomt met een creditcard-/SSN-patroon voldoet aan een voorwaarde. | .containsCreditCardNumber("notes", lambda c: c == 0) |
satisfies |
Het aandeel rijen dat voldoet aan een aangepaste SQL-predicaat voldoet aan een voorwaarde. | .satisfies("age >= 18", "adults", lambda c: c == 1.0) |
Analyzers / metrics — @fmlv.analyze
| Metric | Description | Example |
|---|---|---|
ApproxCountDistinct |
Geschatte hoeveelheid verschillende waarden, berekend met HyperLogLog++ schetsen. | ApproxCountDistinct("product_id") |
ApproxQuantile |
Geschatte quantiel van een verdeling. | ApproxQuantile("locale_encoded", 0.5) |
ApproxQuantiles |
Verschillende benaderende kwantielen van een verdeling. | ApproxQuantiles("locale_encoded", [0.1, 0.5, 0.9]) |
Completeness |
Fractie van niet-nulwaarden in een kolom. | Completeness("product_id") |
Compliance |
Fractie van rijen die voldoet aan een gegeven kolombeperking. | Compliance("locale", "locale in ('es','jp','us')") |
Correlation |
Pearson-correlatie tussen twee kolommen, in het bereik [-1, 1]. | Correlation("title", "brand") |
CountDistinct |
Aantal verschillende waarden. | CountDistinct("locale") |
DataType |
Verdeling van datatypen (Booleaans, Fractioneel, Integraal, String). | DataType("locale") |
Distinctness |
Fractie van verschillende waarden over het totale aantal waarden. | Distinctness("title") |
Entropy |
Informatie-inhoud van de waardeverdeling van een kolom, gemeten in nats. | Entropy("locale_encoded") |
Maximum / Minimum |
Maximum- / minimumwaarde van een kolom. | Maximum("locale_encoded") |
Mean |
Gemiddelde waarde; nulwaarden worden uitgesloten. | Mean("locale_encoded") |
MutualInformation |
Hoeveel informatie over de ene kolom kan worden afgeleid uit een andere; symmetrisch en niet-negatief. | MutualInformation(["title", "brand"]) |
PatternMatch |
Aandeel van rijen die voldoen aan een gegeven reguliere expressie. | PatternMatch("locale", r"\w{2}") |
Size |
Aantal rijen in het DataFrame. | Size() |
Sum |
Som van alle waarden van een kolom. | Sum("total_votes") |
UniqueValueRatio |
Percentage van unieke waarden over het aantal van alle verschillende waarden. | UniqueValueRatio(["brand"]) |
Uniqueness |
Fractie van unieke waarden over het aantal van alle waarden. | Uniqueness(["brand"]) |
De open-source Deequ-bibliotheek levert deze controles en analyzers. Voor de volledige en gezaghebbende lijst, zie het Deequ-project op github.com/awslabs/deequ.
Summary
- Maak je MLV aan en noteer de volledig gekwalificeerde naam.
-
In een aparte datakwaliteitscel registreer een suite met
@fmlv.dq_suite(mlv_name=…). -
Voeg controles toe — stapel
@fmlv.validate("<fn>", "FAIL"|"WARN")en/of@fmlv.analyze("<fn>")en schrijf de bijbehorende invoerfuncties die PyDeequ DataFrames teruggeven. - Start het — op aanvraag vanuit het notebook, of zet de datakwaliteitsschakelaar aan bij het maken van een schema.
- Bekijk de resultaten op het tabblad Data quality in Lineage en in de rungeschiedenis.
Verwante inhoud
- Datakwaliteit in Materialized Lake Views — Microsoft Learn
- Overzicht van gematerialiseerde Lake Views — Microsoft Learn
- DeeQu-documentatie