",
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.
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}} | Gibt an, true ob die Antwort des Regeltyps gleich ist. {{x}} | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \!={{x}} | x wird als wahr aufgelöst, wenn die Antwort des Regeltyps ungleich ist. {{x}} | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > {{x}} | Gibt an, true ob die Antwort des Regeltyps größer als ist. {{x}} | ColumnValues "colA" > 10
|
| < {{x}} | Löst sich auf, true wenn die Antwort des Regeltyps kleiner als ist. {{x}} | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= {{x}} | Gibt an, true ob die Antwort des Regeltyps größer oder gleich ist. {{x}} | ColumnValues "colA" >= 10
|
| <= {{x}} | Gibt an, true ob die Antwort des Regeltyps 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" ]
|
| Streichhölzer {{/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 Streichhölzer {{/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 [...] /nicht matches/not in [...] 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 hierfür die Option „compositeRuleEvaluation.method“ = „ROW“ erforderlich ist. *
+ 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](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-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 hierfür die Option „compositeRuleEvaluation.method“ = „ROW“ verwendet werden muss. *
Unterstützte Regeln:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-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.
```
where " "
```
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.
```
where "valid SparkSQL statement>" with threshold
```
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 where "" has provided an invalid where clause :
```
**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 ein Fehler aufgetreten ist. 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="",
tableName="",
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 | Row-level Ergebnisse (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 sie im gesamten Skript referenzieren. Auf diese Weise können Probleme im Zusammenhang mit Größenbeschränkungen für Abfragen vermieden werden, z. B. wenn Sie mit großen SQL-Anweisungen arbeiten, die zulässige Grenzen überschreiten könnten. Indem Sie diese Werte Konstanten zuweisen, können Sie Ihre 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 zugewiesen`mySql`, auf die dann in der Regel mithilfe des `$` Präfixes verwiesen wird.
### Labels
Labels bieten eine effektive Möglichkeit, Datenqualitätsergebnisse zu organisieren und zu analysieren. Sie können Ergebnisse anhand bestimmter Bezeichnungen abfragen, um fehlerhafte Regeln innerhalb bestimmter Kategorien zu identifizieren, Regelergebnisse nach Team oder Bereich zu zählen und zielgerichtete Berichte für verschiedene Stakeholder zu erstellen.
Sie können beispielsweise alle Regeln, die das Finanzteam betreffen, mit einer Bezeichnung 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 kennzeichnen, um Korrekturmaßnahmen `"criticality=high"` zu priorisieren. Labels können als Teil der DQDL erstellt werden. Sie können die Labels als Teil von Regelergebnissen, Ergebnissen auf Zeilenebene und API-Antworten abfragen, was die Integration in Ihre bestehenden Überwachungs- und Berichtsabläufe erleichtert.
**Anmerkung**
Labels sind nur in AWS Glue ETL verfügbar und nicht in Data Quality, die auf AWS Glue Data Catalog basiert.
#### Syntax für DQDL-Labels
DQDL unterstützt sowohl Standard- als auch regelspezifische Bezeichnungen. Standardbezeichnungen werden auf Regelsatzebene definiert und gelten automatisch für alle Regeln innerhalb dieses Regelsatzes. Einzelne Regeln können auch ihre eigenen Bezeichnungen haben. Da Bezeichnungen als Schlüssel-Wert-Paare implementiert sind, können regelspezifische Bezeichnungen die Standardbezeichnungen überschreiben, wenn derselbe Schlüssel verwendet wird.
Das folgende Beispiel zeigt, wie Standard- und regelspezifische Bezeichnungen 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"]
RowCount > 0 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
ColumnValues "colA" in ["A", "B"] with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(isComplete "col" AND RowCount > 0) labels=["foo"="bar]
]
```
Das folgende Beispiel zeigt eine ungültige Syntax mit Bezeichnungen und zusammengesetzten Regeln:
```
(isComplete "colA") AND (RowCount > 0) labels=["foo"="bar"]
(isComplete "colA" labels=["foo"="bar"]) AND (RowCount > 0)
isComplete "col" AND RowCount > 0 labels=["foo"="bar]
```
##### Einschränkungen bei Beschriftungen
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 beim 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 der Regel
DQDL-Bezeichnungen sind in den Regelergebnissen immer sichtbar. Es ist keine zusätzliche Konfiguration erforderlich, um sie zu aktivieren.
##### Row-level Ergebnisse
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 Bezeichnungen 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 werden im AWS Glue Data Catalog nicht unterstützt.
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.
**Beispiele für Ausdrü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](#dqdl-analyzers-table) 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“, 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.
### 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 der aktuelle Datensatz mehr als fünf Zeilen enthält.
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 |
| Distribution | Berechnet die Häufigkeitsverteilung einer Spalte. Erzeugt bei numerischen Spalten ein Histogramm mit Unterteilungen. Erzeugt für Zeichenketten- und Datumsspalten eine Wertverteilung, die in absteigender Reihenfolge nach Häufigkeit sortiert ist. |
| 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 |
#### Verteilungsanalysator
Der `Distribution` Analyzer berechnet Häufigkeitsverteilungen für Spalten in Ihrem Datensatz. Verwenden Sie den `Distribution` Analyzer, um zu verstehen, wie Ihre Daten im Laufe der Zeit verteilt sind, und um Verschiebungen der Datenbereiche zwischen Auswertungsläufen zu erkennen.
Hinweise zur DQDL-Syntax und grundlegende Anwendungsbeispiele finden Sie unter[Distribution](dqdl-rule-types-Distribution.md).
##### Numerisches und kategoriales Verhalten
+ **Numerische Spalten ** — Der Analysator unterteilt den Wertebereich der Spalte in Intervalle gleicher Breite (Bins). Jeder Abschnitt wird durch eine untere und eine obere Grenze definiert. Das Ergebnis zählt, wie viele Werte in jeden Abschnitt fallen.
+ **Kategoriale Spalten ** (Zeichenfolge, Datum, boolescher Wert) — Der Analyzer zählt die Häufigkeit jedes einzelnen Werts und gibt die 20 häufigsten Werte in absteigender Reihenfolge nach Häufigkeit sortiert zurück.
Der `Distribution` Analyzer schließt NULL-Werte in der Zielspalte aus der Verteilungsberechnung für beide Spaltentypen aus.
##### Ausgabeformat
Die `Distribution` Statistik gibt ein strukturiertes `DistributionValue` Objekt zurück, das die folgenden Felder enthält:
+ `BinEdges`— Ein Array, das die Abteilungsgrenzen (numerisch) oder die eindeutigen Werte (kategorial) definiert
+ `Count`— Eine Reihe von Häufigkeitszählungen, die jedem Abschnitt oder Wert entsprechen
+ `DataType`— Der Datentyp der Spalte (z. B.`LongType`,`StringType`)
##### Eingefrorene Behälterränder
Wenn Sie den `Distribution` Analyzer zum ersten Mal auf einer Spalte ausführen, berechnet der Analyzer die Abschnittskanten auf der Grundlage des aktuellen Wertebereichs der Spalte. Bei nachfolgenden Durchläufen für dieselbe Statistik (gleiche Spalte, gleiche Bin-Anzahl) verwendet der Analyzer die Kanten des ersten Durchlaufs erneut. Dieses Verhalten wird als * gefrorene Kanten bezeichnet. *
Gefrorene Kanten ermöglichen aussagekräftige Vergleiche zwischen Durchläufen, da die Abschnitte im Laufe der Zeit konsistent bleiben. Ohne eingefrorene Kanten würden sich die Abschnittsgrenzen bei jedem Lauf verschieben, wenn sich der Datenbereich ändert.
##### Überlaufbeobachtungen
Wenn Datenwerte außerhalb der Grenzen der gefrorenen Abschnitte liegen, zählt das Analyzer sie im ersten oder letzten Abschnitt (den Überlauffächern). Wenn mehr als 2% der Werte in den Überlauffächern landen, generiert AWS Glue Data Quality eine Informationsbeobachtung. Wenn mehr als 5% der Werte einen Überlauf aufweisen, generiert AWS Glue Data Quality eine genauere Beobachtung und verfolgt aufeinanderfolgende Überlaufläufe. Nach 3 aufeinanderfolgenden Durchläufen mit einer Überschreitung von 5% wird das automatische Rebinning ausgelöst.
##### Automatisches Rebinning
Wenn bei 3 aufeinanderfolgenden Testläufen ein Überlauf von mehr als 5% auftritt, berechnet AWS Glue Data Quality die Behälterkanten automatisch neu. Die neuen Kanten basieren auf dem aktuellen Datenbereich. Nach dem erneuten Binning werden die neuen Kanten zu den eingefrorenen Kanten für nachfolgende Durchläufe.
Nach dem automatischen Rebinning passen sich Ihre Histogramme ohne manuelles Eingreifen an anhaltende Änderungen des Datenbereichs an. Die Bin-Ränder bleiben auch bei vorübergehenden Schwankungen stabil.
Sie können das automatische Rebinning deaktivieren, indem Sie den `rebin` Parameter `false` in Ihrem DQDL-Regelsatz auf Folgendes setzen:
```
Analyzers = [
Distribution "Salary" with bins = 20, rebin = false
]
```
Wenn das automatische Rebinning deaktiviert ist, bleiben die Bin-Ränder unabhängig von der Überlaufhäufigkeit auf unbestimmte Zeit eingefroren. AWS Glue Data Quality generiert weiterhin Überlaufbeobachtungen.
### 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
]
```