Gegevenskwaliteit in gerealiseerde lakeweergaven

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_id geen 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:

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.

Screenshot van de Geavanceerde instellingen voor Nieuw schema maken met een dropdown Controles van gegevenskwaliteit ingesteld op Controleren na elke uitvoering.

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.

Schermafbeelding van de lineageweergave die een mislukt DataQuality-knooppunt toont dat zijn afhankelijke downstream-knooppunt blokkeert, dat wordt overgeslagen, terwijl naastliggende takken 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 Completeness van region).
  • 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.

Screenshot van het gegevenskwaliteitsdetailpaneel met berekende meetwaarden en verificatieresultaten met de pass/fail-status van elke constraint.

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

  1. Maak je MLV aan en noteer de volledig gekwalificeerde naam.
  2. In een aparte datakwaliteitscel registreer een suite met @fmlv.dq_suite(mlv_name=…).
  3. Voeg controles toe — stapel @fmlv.validate("<fn>", "FAIL"|"WARN") en/of @fmlv.analyze("<fn>") en schrijf de bijbehorende invoerfuncties die PyDeequ DataFrames teruggeven.
  4. Start het — op aanvraag vanuit het notebook, of zet de datakwaliteitsschakelaar aan bij het maken van een schema.
  5. Bekijk de resultaten op het tabblad Data quality in Lineage en in de rungeschiedenis.