Referenz zu Data Quality Definition Language (DQDL)

Data Quality Definition Language (DQDL) ist eine domänenspezifische Sprache, mit der Sie Regeln für AWS Glue Data Quality definieren.

In diesem Handbuch werden wichtige DQDL-Konzepte vorgestellt, die Ihnen beim Verständnis der Sprache helfen. Es bietet auch eine Referenz für DQDL-Regeltypen mit Syntax und Beispielen. Bevor Sie dieses Handbuch verwenden, empfehlen wir Ihnen, sich mit AWS Glue Data Quality vertraut zu machen. Weitere Informationen finden Sie unter AWS Glue Qualität der Daten.

Anmerkung

DynamicRules werden nur in AWS Glue ETL unterstützt.

DQDL-Syntax

Ein DQDL-Dokument unterscheidet zwischen Groß- und Kleinschreibung und enthält einen Regelsatz, der einzelne Datenqualitätsregeln zusammenfasst. Um einen Regelsatz zu erstellen, müssen Sie eine Liste mit dem Namen Rules (groß geschrieben) erstellen, die durch ein Paar eckiger Klammern begrenzt ist. Die Liste sollte eine oder mehrere durch Kommas getrennte DQDL-Regeln wie im folgenden Beispiel enthalten.


Rules = [
   IsComplete "order-id",
   IsUnique "order-id"
]

Regelstruktur

Die Struktur einer DQDL-Regel hängt vom Regeltyp ab. Allerdings passen DQDL-Regeln im Allgemeinen in das folgende Format.


<RuleType> <Parameter> <Parameter> <Expression>

RuleType ist der zwischen Groß- und Kleinschreibung zu unterscheidende Name des Regeltyps, den Sie konfigurieren möchten. Beispiel: IsComplete, IsUnique oder CustomSql. Die Regelparameter unterscheiden sich für jeden Regeltyp. Eine vollständige Referenz der DQDL-Regeltypen und ihrer Parameter finden Sie unter DQDL-Regeltypreferenz.

Zusammengesetzte Regeln

DQDL unterstützt die folgenden logischen Operatoren, die Sie zum Kombinieren von Regeln verwenden können. Diese Regeln werden als zusammengesetzte Regeln bezeichnet.

und

Der logische and-Operator ergibt genau dann true, wenn die Regeln, die er verbindet, true sind. Andernfalls führt die kombinierte Regel zu false. Jede Regel, die Sie mit dem and-Operator verbinden, muss in runde Klammern eingeschlossen werden.

Im folgenden Beispiel wird der and-Operator zum Kombinieren zweier DQDL-Regeln verwendet.


(IsComplete "id") and (IsUnique "id")

oder

Der logische or-Operator ergibt genau dann true, wenn eine oder mehrere der Regeln, die er verbindet, true sind. Jede Regel, die Sie mit dem or-Operator verbinden, muss in runde Klammern eingeschlossen werden.

Im folgenden Beispiel wird der or-Operator zum Kombinieren zweier DQDL-Regeln verwendet.


(RowCount "id" > 100) or (IsPrimaryKey "id")

Sie können denselben Operator verwenden, um mehrere Regeln zu verbinden, daher ist die folgende Regelkombination zulässig.


(Mean "Star_Rating" > 3) and (Mean "Order_Total" > 500) and (IsComplete "Order_Id")

Sie können die logischen Operatoren zu einem einzigen Ausdruck kombinieren. Zum Beispiel:


(Mean "Star_Rating" > 3) and ((Mean "Order_Total" > 500) or (IsComplete "Order_Id"))

Sie können auch komplexere, verschachtelte Regeln erstellen.


(RowCount > 0) or ((IsComplete "colA") and (IsUnique "colA"))

So funktionieren zusammengesetzte Regeln

Standardmäßig werden zusammengesetzte Regeln als einzelne Regeln für den gesamten Datensatz oder die gesamte Tabelle ausgewertet und anschließend werden die Ergebnisse kombiniert. Mit anderen Worten: Es wird zuerst die gesamte Spalte ausgewertet und dann der Operator angewendet. Dieses Standardverhalten wird im Folgenden anhand eines Beispiels erklärt:


# Dataset

+------+------+
|myCol1|myCol2|
+------+------+
|     2|     1|
|     0|     3|
+------+------+

# Overall outcome

+----------------------------------------------------------+-------+
|Rule                                                      |Outcome|
+----------------------------------------------------------+-------+
|(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)|Failed |
+----------------------------------------------------------+-------+

Im obigen Beispiel wertet AWS Glue Data Quality zuerst (ColumnValues "myCol1" > 1) aus, was zu einem Fehler führt. Dann wird (ColumnValues "myCol2" > 2) bewertet, was ebenfalls fehlschlägt. Die Kombination beider Ergebnisse wird als FEHLGESCHLAGEN vermerkt.

Wenn Sie jedoch ein SQL-ähnliches Verhalten bevorzugen, bei dem die gesamte Zeile ausgewertet werden muss, müssen Sie den ruleEvaluation.scope-Parameter explizit festlegen, wie in additionalOptions im folgenden Codeausschnitt gezeigt.


object GlueApp {
  val datasource = glueContext.getCatalogSource(
    database="<db>",
    tableName="<table>",
    transformationContext="datasource"
  ).getDynamicFrame()

  val ruleset = """
    Rules = [
        (ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4)        
    ]
  """

  val dq_results = EvaluateDataQuality.processRows(
    frame=datasource,
    ruleset=ruleset,
    additionalOptions=JsonOptions("""
        {
          "compositeRuleEvaluation.method":"ROW"
        }
      """
    )
  )
}

In AWS Glue Data Catalog können Sie diese Option einfach in der Benutzeroberfläche konfigurieren, wie unten gezeigt.

Der Screenshot zeigt ein Einstellungsfenster für zusammengesetzte Regeln, in dem Sie die Konfiguration der Regelauswertung zwischen Zeile und Spalte auswählen können. Wenn Sie „Zeile“ wählen, verhalten sich die zusammengesetzten Regeln wie eine einzelne Regel, die die gesamte Zeile auswertet. Wenn Sie „Spalte“ wählen, werten die zusammengesetzten Regeln einzelne Regeln für den gesamten Datensatz aus und kombinieren die Ergebnisse.

Nach der Festlegung verhalten sich die zusammengesetzten Regeln wie eine einzelne Regel, die die gesamte Zeile auswertet. Das folgende Beispiel illustriert dieses Verhalten.




# Row Level outcome

+------+------+------------------------------------------------------------+---------------------------+
|myCol1|myCol2|DataQualityRulesPass                                        |DataQualityEvaluationResult|
+------+------+------------------------------------------------------------+---------------------------+
|2     |1     |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed                     |
|0     |3     |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed                     |
+------+------+------------------------------------------------------------+---------------------------+

Einige Regeln können in diesem Feature nicht unterstützt werden, da ihr Gesamtergebnis von Schwellenwerten oder Verhältnissen abhängt. Sie werden im Folgenden aufgelistet.

Regeln, die sich auf Verhältnisse stützen:

Vollständigkeit
DatasetMatch
ReferentialIntegrity
Eindeutigkeit

Regeln, die von Schwellenwerten abhängen:

Wenn die folgenden Regeln einen Schwellenwert enthalten, werden sie nicht unterstützt. Regeln, die with threshold nicht beinhalten, werden jedoch weiterhin unterstützt.

ColumnDataType
ColumnValues
CustomSQL

Ausdrücke

Wenn ein Regeltyp keine boolesche Antwort erzeugt, müssen Sie einen Ausdruck als Parameter angeben, um eine boolesche Antwort zu erstellen. Die folgende Regel prüft beispielsweise den Mittelwert (Durchschnitt) aller Werte in einer Spalte anhand eines Ausdrucks, um ein wahres oder falsches Ergebnis zurückzugeben.


Mean "colA" between 80 and 100

Einige Regeltypen wie IsUnique und IsComplete geben bereits eine boolesche Antwort zurück.

In der folgenden Tabelle sind Ausdrücke aufgeführt, die Sie in DQDL-Regeln verwenden können.

Unterstützte DQDL-Ausdrücke
Expression	Description	Beispiel
=`x`	Löst auf, `true` ob die Antwort vom Regeltyp gleich ist. `x`	`Completeness "colA" = "1.0", ColumnValues "colA" = "2022-06-30"`
!=`x`	x Wird als wahr aufgelöst, wenn die Regeltypantwort ungleich ist. `x`	`ColumnValues "colA" != "a", ColumnValues "colA" != "2022-06-30"`
> `x`	Löst den Wert auf, `true` wenn die Regeltypantwort größer als ist. `x`	`ColumnValues "colA" > 10`
< `x`	Löst das Problem auf, `true` wenn die Regeltypantwort kleiner als ist. `x`	`ColumnValues "colA" < 1000, ColumnValues "colA" < "2022-06-30"`
>= `x`	Löst auf, `true` ob die Regeltypantwort größer oder gleich ist. `x`	`ColumnValues "colA" >= 10`
<= `x`	Löst auf, `true` ob die Regeltypantwort kleiner oder gleich ist. `x`	`ColumnValues "colA" <= 1000`
zwischen und `x` `y`	Löst sich zu `true` auf, wenn die Antwort des Regeltyps in einen bestimmten Bereich fällt (exklusiv). Verwenden Sie diesen Ausdruckstyp nur für Zahlen- und Datumstypen.	`Mean "colA" between 8 and 100, ColumnValues "colA" between "2022-05-31" and "2022-06-30"`
nicht zwischen `x` und `y`	Löst sich zu „true“ auf, wenn die Antwort des Regeltyps nicht in einen bestimmten Bereich fällt (inklusive). Sie sollten diesen Ausdruckstyp nur für Zahlen- und Datumstypen verwenden.	`ColumnValues "colA" not between "2022-05-31" and "2022-06-30"`
in [`a, b, c, ...`]	Löst sich zu `true` auf, wenn die Antwort des Regeltyps in der angegebenen Menge enthalten ist.	`ColumnValues "colA" in [ 1, 2, 3 ], ColumnValues "colA" in [ "a", "b", "c" ]`
nicht in [`a, b, c, ...`]	Löst sich zu `true` auf, wenn die Antwort des Regeltyps nicht in der angegebenen Menge enthalten ist.	`ColumnValues "colA" not in [ 1, 2, 3 ], ColumnValues "colA" not in [ "a", "b", "c" ]`
Spiele `/ab+c/i`	Löst sich zu `true` auf, wenn die Antwort des Regeltyps mit einem regulären Ausdruck übereinstimmt.	`ColumnValues "colA" matches "[a-zA-Z]*"`
keine Spiele `/ab+c/i`	Löst sich zu `true` auf, wenn die Antwort des Regeltyps nicht mit einem regulären Ausdruck übereinstimmt.	`ColumnValues "colA" not matches "[a-zA-Z]*"`
`now()`	Funktioniert nur mit dem `ColumnValues`-Regeltyp zum Erstellen eines Datumsausdrucks.	`ColumnValues "load_date" > (now() - 3 days)`
matches/in […]/not matches/notin [...] `with threshold`	Gibt den Prozentsatz der Werte an, die den Regelbedingungen entsprechen. Funktioniert nur mit den `ColumnValues`-, `ColumnDataType`- und `CustomSQL`-Regeltypen.	`ColumnValues "colA" in ["A", "B"] with threshold > 0.8, ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9 ColumnDataType "colA" = "Timestamp" with threshold > 0.9`

Schlüsselwörter für NULL, EMPTY und WHITESPACES_ONLY

Wenn Sie überprüfen möchten, ob eine Zeichenfolgenspalte einen Nullwert, einen leeren Wert oder eine Zeichenfolge mit ausschließlich Leerzeichen enthält, können Sie die folgenden Schlüsselwörter verwenden:

NULL/null – Dieses Schlüsselwort wird für einen null-Wert in einer Zeichenfolgenspalte als „true“ aufgelöst.

ColumnValues "colA" != NULL with threshold > 0.5 würde „true“ zurückgeben, wenn mehr als 50 % Ihrer Daten keine Nullwerte enthalten.

(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5) würde für alle Zeilen, die entweder einen Nullwert oder eine Länge von > 5 haben, „true“ zurückgeben. Beachten Sie, dass hierfür die Option „compositeRuleEvaluation.method“ = „ROW“ verwendet werden muss.
EMPTY/empty – Dieses Schlüsselwort wird für einen leeren Zeichenfolgenwert („“) in einer Zeichenfolgenspalte als „true“ aufgelöst. Bei einigen Datenformaten werden Nullen in einer Zeichenfolgenspalte in leere Zeichenfolgen umgewandelt. Dieses Schlüsselwort hilft dabei, leere Zeichenfolgen in Ihren Daten herauszufiltern.

(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"]) würde „true“ zurückgeben, wenn eine Zeile entweder leer, „a“ oder „b“ ist. Beachten Sie, dass dies die Verwendung der Option „compositeRuleEvaluation.method“ = „ROW“ erfordert.
WHITESPACES_ONLY/whitespaces_only – Dieses Schlüsselwort wird für eine Zeichenfolge mit nur Leerzeichen („ “) in einer Zeichenfolgenspalte als „true“ aufgelöst.

ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY] würde „true“ zurückgeben, wenn eine Zeile weder „a“ oder „b“ noch nur Leerzeichen enthält.

Unterstützte Regeln:
- ColumnValues

Wenn Sie für einen numerischen oder datumsbasierten Ausdruck überprüfen möchten, ob eine Spalte eine Null enthält, können Sie die folgenden Schlüsselwörter verwenden.

NULL/null – Dieses Schlüsselwort wird für einen Nullwert in einer Zeichenfolgenspalte als „true“ aufgelöst.

ColumnValues "colA" in [NULL, "2023-01-01"] würde „true“ zurückgeben, wenn ein Datum in Ihrer Spalte entweder 2023-01-01 oder Null ist.

(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9) würde für alle Zeilen, die entweder einen Nullwert oder Werte zwischen 1 und 9 haben, „true“ zurückgeben. Beachten Sie, dass dafür die Option „compositeRuleEvaluation.method“ = „ROW“ verwendet werden muss.

Unterstützte Regeln:
- ColumnValues

Filterung mit der WHERE-Klausel

Anmerkung

Where Clause wird nur in AWS Glue 4.0 unterstützt.

Sie können Ihre Daten beim Erstellen von Regeln filtern. Dies ist hilfreich, wenn Sie bedingte Regeln anwenden möchten.


<DQDL Rule> where "<valid SparkSQL where clause> "

Der Filter muss mit dem where-Schlüsselwort angegeben werden, gefolgt von einer gültigen SparkSQL-Anweisung, die in Anführungszeichen ("") eingeschlossen ist.

Wenn Sie die WHERE-Klausel zu einer Regel mit einem Schwellenwert hinzufügen möchten, muss die WHERE-Klausel vor der Schwellenwertbedingung angegeben werden.


<DQDL Rule> where "valid SparkSQL statement>" with threshold <threshold condition>

Mit dieser Syntax können Sie Regeln wie die folgenden schreiben.


Completeness "colA" > 0.5 where "colB = 10"
ColumnValues "colB" in ["A", "B"] where "colC is not null" with threshold > 0.9
ColumnLength "colC" > 10 where "colD != Concat(colE, colF)"

Wir werden überprüfen, ob die SparkSQL-Anweisung gültig ist. Falls ungültig, schlägt die Regelauswertung fehl und wir geben eine IllegalArgumentException mit dem folgenden Format aus:


Rule <DQDL Rule> where "<invalid SparkSQL>" has provided an invalid where clause :
<SparkSQL Error>

Verhalten der WHERE-Klausel, wenn die Identifizierung von Fehlerdatensätzen auf Zeilenebene aktiviert ist

Mit AWS Glue Data Quality können Sie bestimmte Datensätze identifizieren, bei denen Fehler aufgetreten sind. Wenn wir eine WHERE-Klausel auf Regeln anwenden, die Ergebnisse auf Zeilenebene unterstützen, kennzeichnen wir die Zeilen, die durch die WHERE-Klausel herausgefiltert werden, als Passed.

Wenn Sie es vorziehen, die herausgefilterten Zeilen separat als SKIPPED zu kennzeichnen, können Sie die folgenden additionalOptions für den ETL-Auftrag festlegen.


object GlueApp {
  val datasource = glueContext.getCatalogSource(
    database="<db>",
    tableName="<table>",
    transformationContext="datasource"
  ).getDynamicFrame()

  val ruleset = """
    Rules = [
       IsComplete "att2" where "att1 = 'a'"        
    ]
  """

  val dq_results = EvaluateDataQuality.processRows(
    frame=datasource,
    ruleset=ruleset,
    additionalOptions=JsonOptions("""
        {
          "rowLevelConfiguration.filteredRowLabel":"SKIPPED"
        }
      """
    )
  )
}

Die folgende Regel und der folgende Datenrahmen werden als Beispiel verwendet:


IsComplete att2 where "att1 = 'a'"

id	att1	att2	Ergebnisse auf Zeilenebene (Standard)	Ergebnisse auf Zeilenebene (Option übersprungen)	Kommentare
1	a	f	PASSED	PASSED
2	b	d	PASSED	SKIPPED	Die Zeile ist herausgefiltert, da `att1` nicht `"a"` ist.
3	a	Null	FEHLGESCHLAGEN	FEHLGESCHLAGEN
4	a	f	PASSED	PASSED
5	b	Null	PASSED	SKIPPED	Die Zeile ist herausgefiltert, da `att1` nicht `"a"` ist.
6	a	f	PASSED	PASSED

Konstanten

In DQDL können Sie konstante Werte definieren und in Ihrem gesamten Skript auf sie verweisen. Auf diese Weise können Probleme im Zusammenhang mit Größenbeschränkungen für Abfragen vermieden werden, z. B. bei der Arbeit mit umfangreichen SQL-Anweisungen, die die zulässigen Grenzen überschreiten könnten. Indem Sie diese Werte Constants zuweisen, können Sie Ihren DQDL vereinfachen und vermeiden, dass diese Grenzwerte überschritten werden.

Das folgende Beispiel zeigt, wie eine Konstante definiert und verwendet wird:


mySql = "select count(*) from primary"

Rules = [
    CustomSql $mySql between 0 and 100
]

In diesem Beispiel wird die SQL-Abfrage der Konstante zugewiesenmySql, auf die dann in der Regel mit dem $ Präfix verwiesen wird.

Labels

Beschriftungen bieten eine effektive Möglichkeit, Datenqualitätsergebnisse zu organisieren und zu analysieren. Sie können Ergebnisse anhand bestimmter Labels abfragen, um fehlerhafte Regeln innerhalb bestimmter Kategorien zu identifizieren, die Regelergebnisse nach Team oder Domäne zu zählen und gezielte Berichte für verschiedene Beteiligte zu erstellen.

Sie können beispielsweise alle Regeln, die sich auf das Finanzteam beziehen, mit einem Label versehen "team=finance" und einen maßgeschneiderten Bericht erstellen, in dem die für das Finanzteam spezifischen Qualitätskennzahlen dargestellt werden. Sie können Regeln mit hoher Priorität mit kennzeichnen, um Abhilfemaßnahmen "criticality=high" zu priorisieren. Labels können als Teil der DQDL verfasst werden. Sie können die Labels als Teil von Regelergebnissen, Ergebnissen auf Zeilenebene und API-Antworten abfragen, sodass sie problemlos in Ihre bestehenden Überwachungs- und Berichtsworkflows integriert werden können.

Anmerkung

Etiketten sind nur in AWS Glue ETL und nicht in AWS Glue Data Catalog Based Data Quality verfügbar.

Syntax für DQDL-Labels

DQDL unterstützt sowohl Standard- als auch regelspezifische Labels. Standardbezeichnungen werden auf Regelsatzebene definiert und gelten automatisch für alle Regeln innerhalb dieses Regelsatzes. Einzelne Regeln können auch ihre eigenen Beschriftungen haben, und da Beschriftungen als Schlüssel-Wert-Paare implementiert werden, können regelspezifische Beschriftungen die Standardbezeichnungen überschreiben, wenn derselbe Schlüssel verwendet wird.

Das folgende Beispiel zeigt, wie standardmäßige und regelspezifische Labels verwendet werden:


DefaultLabels=["frequency"="monthly"]

Rules = [
    // Auto includes the default label ["frequency"="monthly"]
    ColumnValues "col" > 21,
    // Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
    Rule 1 with threshold > 0.8 labels=["foo"="bar"],
    // Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
    Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
]

Einschränkungen bei der Bezeichnung

Für Beschriftungen gelten die folgenden Einschränkungen:

Maximal 10 Labels pro DQDL-Regel.
Labels werden als Liste von Schlüssel-Wert-Paaren angegeben.
Beim Labelschlüssel und Labelwert wird zwischen Groß- und Kleinschreibung unterschieden.
Die maximale Länge des Labelschlüssels beträgt 128 Zeichen. Der Labelschlüssel darf nicht leer oder null sein.
Die maximale Länge des Labelwerts beträgt 256 Zeichen. Der Labelwert kann leer oder Null sein.

DQDL-Labels werden abgerufen

Sie können DQDL-Labels aus Regelergebnissen, Ergebnissen auf Zeilenebene und API-Antworten abrufen.

Ergebnisse von Regeln

DQDL-Labels sind in Regelergebnissen immer sichtbar. Es ist keine zusätzliche Konfiguration erforderlich, um sie zu aktivieren.

Ergebnisse auf Zeilenebene

DQDL-Labels sind in Ergebnissen auf Zeilenebene standardmäßig deaktiviert, können aber mit in aktiviert werden. AdditionalOptions EvaluateDataQuality

Das folgende Beispiel zeigt, wie Labels in Ergebnissen auf Zeilenebene aktiviert werden:


val evaluateResult = EvaluateDataQuality.processRows(
    frame=AmazonS3_node1754591511068,
    ruleset=example_ruleset,
    publishingOptions=JsonOptions("""{
        "dataQualityEvaluationContext": "evaluateResult",
        "enableDataQualityCloudWatchMetrics": "true",
        "enableDataQualityResultsPublishing": "true"
    }"""),
    additionalOptions=JsonOptions("""{
        "performanceTuning.caching":"CACHE_NOTHING",
        "observations.scope":"ALL",
        "rowLevelConfiguration.ruleWithLabels":"ENABLED"
    }""")
)

Wenn diese Option aktiviert ist, enthält der Ergebnisdatenrahmen auf Zeilenebene Beschriftungen für jede Regel in den Spalten, und. DataQualityRulesPass DataQualityRulesFail DataQualityRulesSkip

API-Antwort

DQDL-Labels sind in API-Antworten immer unter einem neuen Feld Labels im RuleResults Objekt sichtbar.

Das folgende Beispiel zeigt Labels in einer API-Antwort:


{
    "ResultId": "dqresult-example",
    "ProfileId": "dqprofile-example",
    "Score": 0.6666666666666666,
    "RulesetName": "EvaluateDataQuality_node1754591514205",
    "EvaluationContext": "EvaluateDataQuality_node1754591514205",
    "StartedOn": "2025-08-22T19:36:10.448000+00:00",
    "CompletedOn": "2025-08-22T19:36:16.368000+00:00",
    "JobName": "anniezc-test-labels",
    "JobRunId": "jr_068f6d7a45074d9105d14e4dee09db12c3b95664b45f6ee44fa29ed7e5619ba8",
    "RuleResults": [
        {
            "Name": "Rule_0",
            "Description": "IsComplete colA",
            "EvaluationMessage": "Input data does not include column colA!",
            "Result": "FAIL",
            "EvaluatedMetrics": {},
            "EvaluatedRule": "IsComplete colA",
            "Labels": {
                "frequency": "monthly"
            }
        },
        {
            "Name": "Rule_1",
            "Description": "Rule 1 with threshold > 0.8",
            "Result": "PASS",
            "EvaluatedMetrics": {},
            "EvaluatedRule": "Rule 1 with threshold > 0.8",
            "Labels": {
                "frequency": "monthly",
                "foo": "bar"
            }
        },
        {
            "Name": "Rule_3",
            "Description": "Rule 2 with threshold > 0.8",
            "Result": "PASS",
            "EvaluatedMetrics": {},
            "EvaluatedRule": "Rule 2 with threshold > 0.8",
            "Labels": {
                "frequency": "daily",
                "foo": "bar"
            }
        }
    ]
}

Dynamische Regeln

Anmerkung

Dynamische Regeln werden nur in AWS Glue ETL unterstützt und nicht im AWS Glue Data Catalog.

Sie können jetzt dynamische Regeln erstellen, um aktuelle Metriken, die anhand Ihrer Regeln erstellt wurden, mit ihren historischen Werten zu vergleichen. Diese historischen Vergleiche werden durch die Verwendung des Operators last() in Ausdrücken ermöglicht. Beispielsweise ist die Regel RowCount > last() erfolgreich, wenn die Anzahl der Zeilen im aktuellen Durchlauf größer ist als die letzte vorherige Anzahl der Zeilen im selben Datensatz. last() verwendet ein optionales Argument mit einer natürlichen Zahl, das beschreibt, wie viele vorherige Metriken berücksichtigt werden sollen. Bei last(k) verweist k >= 1 auf die letzten k Metriken.

Wenn keine Datenpunkte verfügbar sind, gibt last(k) den Standardwert 0,0 zurück.
Wenn weniger als k Metriken verfügbar sind, gibt last(k) alle vorherigen Metriken zurück.

Verwenden Sie zur Bildung von Ausdrücken last(k), wobei k > 1 eine Aggregationsfunktion erfordert, um mehrere historische Ergebnisse auf eine einzelne Zahl zu reduzieren. Beispielsweise prüft RowCount > avg(last(5)), ob die aktuelle Zeilenanzahl des Datensatzes grundsätzlich höher ist als der Durchschnitt der letzten fünf Zeilenanzahlen desselben Datensatzes. RowCount > last(5) gibt einen Fehler aus, weil die aktuelle Zeilenanzahl des Datensatzes nicht aussagekräftig mit einer Liste verglichen werden kann.

Unterstützte Aggregationsfunktionen:

avg
median
max
min
sum
std (Standardabweichung)
abs (absoluter Wert)
index(last(k), i) ermöglicht die Auswahl des i.-letzten Werts der letzten k. i hat einen Nullindex, index(last(3), 0) gibt also den neuesten Datenpunkt zurück und index(last(3), 3) führt zu einem Fehler, da es nur drei Datenpunkte gibt und wir versuchen, den viertletzten zu indizieren.

Beispielausdrücke

ColumnCorrelation

ColumnCorrelation "colA" "colB" < avg(last(10))

DistinctValuesCount

DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1

Die meisten Regeltypen mit numerischen Bedingungen oder Schwellenwerten unterstützen dynamische Regeln. In der bereitgestellten Tabelle Analysatoren und Regeln können Sie ermitteln, ob Ihr Regeltyp dynamische Regeln unterstützt.

Ausschließen von Statistiken aus dynamischen Regeln

Manchmal müssen Sie Datenstatistiken von Ihrer Berechnung der dynamischen Regeln ausschließen. Nehmen wir an, Sie haben historische Daten geladen und möchten nicht, dass sich dies auf Ihre Durchschnittswerte auswirkt. Öffnen Sie dazu den Job in AWS Glue ETL und wählen Sie die Registerkarte Datenqualität. Wählen Sie dann Statistik und wählen Sie die Statistiken aus, die Sie ausschließen möchten. Es wird ein Trenddiagramm zusammen mit einer Statistiktabelle angezeigt. Wählen Sie die Werte aus, die Sie ausschließen möchten, und wählen Sie dann Statistiken ausschließen aus. Die ausgeschlossenen Statistiken werden jetzt nicht in die Berechnung der dynamischen Regeln aufgenommen.

Der Screenshot zeigt die Option zum Ausschließen oder Einschließen von Statistiken aus dem Dropdown-Menü nach Auswahl einer Statistik.

Analysatoren

Anmerkung

Analysatoren werden im AWS Glue Data Catalog nicht unterstützt.

DQDL-Regeln verwenden Funktionen, die als Analysatoren bezeichnet werden, um Informationen über Ihre Daten zu sammeln. Diese Informationen werden vom booleschen Ausdruck einer Regel verwendet, um zu bestimmen, ob die Regel erfolgreich sein oder fehlschlagen soll. Die RowCount Regel RowCount > 5 verwendet beispielsweise einen Analysator für die Zeilenanzahl, um die Anzahl der Zeilen in Ihrem Datensatz zu ermitteln und diese Anzahl mit dem Ausdruck > 5 zu vergleichen, um zu überprüfen, ob im aktuellen Datensatz mehr als fünf Zeilen vorhanden sind.

Manchmal empfehlen wir, anstelle von Regeln Analysatoren zu erstellen und diese dann Statistiken generieren zu lassen, anhand derer Anomalien erkannt werden können. In solchen Fällen können Sie Analysatoren erstellen. Analysatoren unterscheiden sich folgendermaßen von Regeln.

Merkmal	Analysatoren	Regeln
Teil des Regelsatzes	Ja	Ja
Generiert Statistiken	Ja	Ja
Generiert Beobachtungen	Ja	Ja
Kann eine Bedingung bewerten und durchsetzen	Nein	Ja
Aktionen wie das Stoppen von Aufträgen bei einem Fehler oder die Fortsetzung der Auftragsverarbeitung können konfiguriert werden	Nein	Ja

Analysatoren können unabhängig voneinander ohne Regeln existieren, sodass Sie sie schnell konfigurieren und schrittweise Regeln für die Datenqualität erstellen können.

Einige Regeltypen können in den Analyzers-Block Ihres Regelsatzes eingegeben werden, um die für Analysatoren erforderlichen Regeln auszuführen und Informationen zu sammeln, ohne auf Bedingungen zu prüfen. Einige Analysatoren sind nicht mit Regeln verknüpft und können nur in den Analyzers-Block eingegeben werden. Die folgende Tabelle gibt an, ob einzelne Elemente als Regel oder als eigenständige Analysatoren unterstützt werden und enthält zusätzliche Details zu jedem Regeltyp.

Beispiel für einen Regelsatz mit Analyzer

Der folgende Regelsatz verwendet

eine dynamische Regel, mit der überprüft wird, ob ein Datensatz den Durchschnitt seiner letzten drei Auftragsausführungen überschreitet;
einen DistinctValuesCount-Analysator, um die Anzahl unterschiedlicher Werte in der Spalte Name des Datensatzes zu erfassen;
einen ColumnLength-Analysator, um die minimale und maximale Größe des Name im Laufe der Zeit nachzuverfolgen.

Die Ergebnisse der Analysatormetriken können auf der Registerkarte „Datenqualität“ der Auftragsausführung eingesehen werden.


Rules = [
   RowCount > avg(last(3))
]
Analyzers = [
   DistinctValuesCount "Name",
   ColumnLength "Name"
]

AWS Glue Data Quality unterstützt die folgenden Analysatoren.

Name des Analysators	Funktionalität
`RowCount`	Berechnet die Zeilenanzahl für einen Datensatz
`Completeness`	Berechnet den Vollständigkeitsgrad einer Spalte in Prozent
`Uniqueness`	Berechnet den Eindeutigkeitsprozentsatz einer Spalte
`Mean`	Berechnet den Mittelwert einer numerischen Spalte
`Sum`	Berechnet die Summe einer numerischen Spalte
`StandardDeviation`	Berechnet die Standardabweichung einer numerischen Spalte
`Entropy`	Berechnet die Entropie einer numerischen Spalte
`DistinctValuesCount`	Berechnet die Anzahl der unterschiedlichen Werte in einer Spalte
`UniqueValueRatio`	Berechnet das Verhältnis der Einzelwerte in einer Spalte
`ColumnCount`	Berechnet die Anzahl der Spalten in einem Datensatz
`ColumnLength`	Berechnet die Länge einer Spalte
`ColumnValues`	Berechnet das Minimum und Maximum für numerische Spalten. Berechnet Minimum ColumnLength und Maximum ColumnLength für nicht numerische Spalten
`ColumnCorrelation`	Berechnet Spaltenkorrelationen für gegebene Spalten
`CustomSql`	Berechnet Statistiken, die von CustomSQL zurückgegeben werden
`AllStatistics`	Berechnet die folgenden Statistiken: RowCount, ColumnCount Jede Spalte: Vollständigkeit, Eindeutigkeit Numerisch: Minimum, Maximum, Entropie, Mittelwert, Standardwert, Summe Zeichenfolge:, MinLength MaxLength

Kommentare

Sie können das Zeichen „#“ verwenden, um Ihrem DQDL-Dokument einen Kommentar hinzuzufügen. Alles nach dem Zeichen „#“ und bis zum Ende der Zeile wird von DQDL ignoriert.


Rules = [
    # More items should generally mean a higher price, so correlation should be positive
    ColumnCorrelation "price" "num_items" > 0
]

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Datenqualität für ETL-Jobs in AWS Glue Studio-Notebooks

Regeltypreferenz

Referenz zu Data Quality Definition Language (DQDL)

Anmerkung

Inhalt

DQDL-Syntax

Regelstruktur

Zusammengesetzte Regeln

So funktionieren zusammengesetzte Regeln

Ausdrücke

Schlüsselwörter für NULL, EMPTY und WHITESPACES_ONLY

Filterung mit der WHERE-Klausel

Anmerkung

Konstanten

Labels

Anmerkung

Syntax für DQDL-Labels

Einschränkungen bei der Bezeichnung

DQDL-Labels werden abgerufen

Ergebnisse von Regeln

Ergebnisse auf Zeilenebene

API-Antwort

Dynamische Regeln

Anmerkung

Analysatoren

Anmerkung

Kommentare