Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # DQDL-Regeltypreferenz Dieser Abschnitt enthält eine Referenz für jeden Regeltyp, den AWS Glue Data Quality unterstützt. **Anmerkung** DQDL unterstützt derzeit keine verschachtelten oder listenförmigen Spaltendaten. Die Werte in Klammern in der folgenden Tabelle werden durch die in den Regelargumenten angegebenen Informationen ersetzt. Regeln erfordern normalerweise ein zusätzliches Argument für den Ausdruck | Regeltyp | Description | Argumente | Gemeldete Metriken | Als Regel unterstützt? | Als Analysator unterstützt? | Gibt Ergebnisse auf Zeilenebene zurück? | Unterstützung dynamischer Regeln? | Generiert Beobachtungen | Wird die Syntax der Where-Klausel unterstützt? | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | AggregateMatch | Überprüft, ob zwei Datensätze übereinstimmen, indem zusammenfassende Metriken wie der Gesamtumsatz verglichen werden. Nützlich für Finanzunternehmen, um zu vergleichen, ob alle Daten aus Quellsystemen übernommen werden. | Eine oder mehrere Aggregationen | Wenn die Namen der ersten und zweiten Aggregationsspalte übereinstimmen: `Column.[Column].AggregateMatch` Wenn die Namen der ersten und zweiten Aggregationsspalte nicht übereinstimmen: `Column.[Column1,Column2].AggregateMatch` | Ja | Nein | Nein | Nein | Nein | Nein | | AllStatistics | Eigenständiger Analyzer zur Erfassung mehrerer Metriken für die angegebene Spalte in einem Datensatz. | Ein einzelner Spaltenname | Für Spalten jedes Typs: `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Zusätzliche Metriken für Spalten mit Zeichenfolgewerten: `ColumnLength metrics` Zusätzliche Metriken für Spalten mit numerischen Werten: `ColumnValues metrics` | Nein | Ja | Nein | Nein | Nein | Nein | | ColumnCorrelation | Überprüft, wie gut zwei Spalten korreliert sind. | Genau zwei Spaltennamen | Multicolumn.[Column1,Column2].ColumnCorrelation | Ja | Ja | Nein | Ja | Nein | Ja | | ColumnCount | Prüft, ob Spalten gelöscht wurden. | Keine | Dataset.\$1.ColumnCount | Ja | Ja | Nein | Ja | Ja | Nein | | ColumnDataType | Prüft, ob eine Spalte einem Datentyp entspricht. | Genau ein Spaltenname | Column.[Column].ColumnDataType.Compliance | Ja | Nein | Nein | Ja, im Schwellenwertausdruck auf Zeilenebene | Nein | Ja | | ColumnExists | Prüft, ob Spalten in einem Datensatz vorhanden sind. Dadurch können Kunden Self-Service-Datenplattformen erstellen, um sicherzustellen, dass bestimmte Spalten verfügbar sind. | Genau ein Spaltenname | – | Ja | Nein | Nein | Nein | Nein | Nein | | ColumnLength | Prüft, ob die Datenlänge konsistent ist. | Genau ein Spaltenname | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Zusätzliche Metrik, wenn ein Schwellenwert auf Zeilenebene angegeben ist: `Column.[Column].ColumnValues.Compliance` | Ja | Ja | Ja, wenn ein Schwellenwert auf Zeilenebene angegeben ist | Nein | Ja. Generiert Beobachtungen nur durch die Analyse der Mindest- und Maximallänge | Ja | | ColumnNamesMatchPattern | Prüft, ob die Spaltennamen mit den definierten Mustern übereinstimmen. Nützlich für Governance-Teams, um die Konsistenz der Spaltennamen durchzusetzen. | Ein regulärer Ausdruck für Spaltennamen | Dataset.\$1.ColumnNamesPatternMatchRatio | Ja | Nein | Nein | Nein | Nein | Nein | | ColumnValues | Prüft, ob die Daten gemäß den definierten Werten konsistent sind. Diese Regel unterstützt reguläre Ausdrücke. | Genau ein Spaltenname | `Column.[Column].Maximum` `Column.[Column].Minimum` Zusätzliche Metrik, wenn ein Schwellenwert auf Zeilenebene angegeben ist: `Column.[Column].ColumnValues.Compliance` | Ja | Ja | Ja, wenn ein Schwellenwert auf Zeilenebene angegeben ist | Nein | Ja. Generiert Beobachtungen nur durch die Analyse der Mindest- und Maximalwerte | Ja | | Vollständigkeit | Prüft, ob Daten leer sind oder NULLs sich darin befinden. | Genau ein Spaltenname | `Column.[Column].Completeness` | Ja | Ja | Ja | Ja | Ja | Ja | | CustomSql | Kunden können nahezu jede Art von Datenqualitätsprüfungen in SQL implementieren. | Eine SQL-Anweisung (Optional) Ein Schwellenwert auf Zeilenebene | `Dataset.*.CustomSQL` Zusätzliche Metrik, wenn ein Schwellenwert auf Zeilenebene angegeben ist: `Dataset.*.CustomSQL.Compliance` | Ja | Nein | Ja, wenn ein Schwellenwert auf Zeilenebene angegeben ist | Ja | Nein | Nein | | DataFreshness | Prüft, ob die Daten aktuell sind. | Genau ein Spaltenname | Column.[Column].DataFreshness.Compliance | Ja | Nein | Ja | Nein | Nein | Ja | | DatasetMatch | Vergleicht zwei Datensätze und stellt fest, ob sie synchron sind. | Name eines Referenzdatensatzes Eine Spaltenzuweisung (Optional) Nach Übereinstimmungen zu durchsuchende Spalten | Dataset.[ReferenceDatasetAlias].DatasetMatch | Ja | Nein | Ja | Ja | Nein | Nein | | DistinctValuesCount | Prüft auf doppelte Werte. | Genau ein Spaltenname | Column.[Column].DistinctValuesCount | Ja | Ja | Ja | Ja | Ja | Ja | | DetectAnomalies | Überprüft die gemeldeten Metriken eines anderen Regeltyps auf Anomalien. | Ein Regeltyp | Metrik(en), die vom Regeltypargument gemeldet wurden | Ja | Nein | Nein | Nein | Nein | Nein | | Entropie | Prüft die Daten auf Entropie. | Genau ein Spaltenname | Column.[Column].Entropy | Ja | Ja | Nein | Ja | Nein | Ja | | IsComplete | Prüft, ob 100 % der Daten vollständig sind. | Genau ein Spaltenname | Column.[Column].Completeness | Ja | Nein | Ja | Nein | Nein | Ja | | IsPrimaryKey | Prüft, ob es sich bei einer Spalte um einen Primärschlüssel handelt (nicht NULL und eindeutig). | Genau ein Spaltenname | Für einzelne Spalte: `Column.[Column].Uniqueness` Für mehrere Spalten: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Ja | Nein | Ja | Nein | Nein | Ja | | IsUnique | Prüft, ob 100 % der Daten eindeutig sind. | Genau ein Spaltenname | Column.[Column].Uniqueness | Ja | Nein | Ja | Nein | Nein | Ja | | Mean | Prüft, ob der Mittelwert dem eingestellten Schwellenwert entspricht. | Genau ein Spaltenname | Column.[Column].Mean | Ja | Ja | Ja | Ja | Nein | Ja | | ReferentialIntegrity | Prüft, ob zwei Datensätze referenzielle Integrität aufweisen. | Ein oder mehrere Spaltennamen aus dem Datensatz Ein oder mehrere Spaltennamen aus dem Referenzdatensatz | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Ja | Nein | Ja | Ja | Nein | Nein | | RowCount | Prüft, ob die Anzahl der Datensätze einem Schwellenwert entspricht. | Keine | Dataset.\$1.RowCount | Ja | Ja | Nein | Ja | Ja | Ja | | RowCountMatch | Prüft, ob die Datensatzanzahl zwischen zwei Datensätzen übereinstimmt. | Alias des Referenzdatensatzes | Dataset.[ReferenceDatasetAlias].RowCountMatch | Ja | Nein | Nein | Ja | Nein | Nein | | StandardDeviation | Prüft, ob die Standardabweichung dem Schwellenwert entspricht. | Genau ein Spaltenname | Column.[Column].StandardDeviation | Ja | Ja | Ja | Ja | Nein | Ja | | SchemaMatch | Prüft, ob das Schema zwischen zwei Datensätzen übereinstimmt. | Alias des Referenzdatensatzes | Dataset.[ReferenceDatasetAlias].SchemaMatch | Ja | Nein | Nein | Ja | Nein | Nein | | Summe | Prüft, ob die Summe einem festgelegten Schwellenwert entspricht. | Genau ein Spaltenname | Column.[Column].Sum | Ja | Ja | Nein | Ja | Nein | Ja | | Eindeutigkeit | Prüft, ob die Eindeutigkeit des Datensatzes dem Schwellenwert entspricht. | Genau ein Spaltenname | Column.[Column].Uniqueness | Ja | Ja | Ja | Ja | Nein | Ja | | UniqueValueRatio | Prüft, ob das Verhältnis des Einzelwerts dem Schwellenwert entspricht. | Genau ein Spaltenname | Column.[Column].UniqueValueRatio | Ja | Ja | Ja | Ja | Nein | Ja | | FileFreshness | Überprüft, ob Dateien in Amazon S3 aktuell sind. | Datei- oder Ordnerpfad und ein Schwellenwert. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Ja | Nein | Nein | Nein | Nein | Nein | | FileMatch | Überprüft, ob der Inhalt der Datei mit einer Prüfsumme oder einer anderen Datei übereinstimmt. Diese Regel verwendet Prüfsummen, um zu überprüfen, ob zwei Dateien identisch sind. | Quelldatei- oder Ordnerpfad und Zieldatei- oder -ordnerpfad. | Es werden keine Statistiken generiert. | Ja | Nein | Nein | Nein | Nein | Nein | | FileSize | Überprüft, ob die Größe einer Datei einer angegebenen Bedingung entspricht. | Datei- oder Ordnerpfad und Schwellenwert. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Ja | Nein | Nein | Nein | Nein | Nein | | FileUniqueness | Überprüft anhand von Prüfsummen, ob Dateien eindeutig sind. | Datei- oder Ordnerpfad und Schwellenwert. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Ja | Nein | Nein | Nein | Nein | Nein | **Topics** + [AggregateMatch](dqdl-rule-types-AggregateMatch.md) + [ColumnCorrelation](dqdl-rule-types-ColumnCorrelation.md) + [ColumnCount](dqdl-rule-types-ColumnCount.md) + [ColumnDataType](dqdl-rule-types-ColumnDataType.md) + [ColumnExists](dqdl-rule-types-ColumnExists.md) + [ColumnLength](dqdl-rule-types-ColumnLength.md) + [ColumnNamesMatchPattern](dqdl-rule-types-ColumnNamesMatchPattern.md) + [ColumnValues](dqdl-rule-types-ColumnValues.md) + [Vollständigkeit](dqdl-rule-types-Completeness.md) + [CustomSQL](dqdl-rule-types-CustomSql.md) + [DataFreshness](dqdl-rule-types-DataFreshness.md) + [DatasetMatch](dqdl-rule-types-DatasetMatch.md) + [DistinctValuesCount](dqdl-rule-types-DistinctValuesCount.md) + [Entropie](dqdl-rule-types-Entropy.md) + [IsComplete](dqdl-rule-types-IsComplete.md) + [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md) + [IsUnique](dqdl-rule-types-IsUnique.md) + [Mean](dqdl-rule-types-Mean.md) + [ReferentialIntegrity](dqdl-rule-types-ReferentialIntegrity.md) + [RowCount](dqdl-rule-types-RowCount.md) + [RowCountMatch](dqdl-rule-types-RowCountMatch.md) + [StandardDeviation](dqdl-rule-types-StandardDeviation.md) + [Summe](dqdl-rule-types-Sum.md) + [SchemaMatch](dqdl-rule-types-SchemaMatch.md) + [Eindeutigkeit](dqdl-rule-types-Uniqueness.md) + [UniqueValueRatio](dqdl-rule-types-UniqueValueRatio.md) + [DetectAnomalies](dqdl-rule-types-DetectAnomalies.md) + [FileFreshness](dqdl-rule-types-FileFreshness.md) + [FileMatch](dqdl-rule-types-FileMatch.md) + [FileUniqueness](dqdl-rule-types-FileUniqueness.md) + [FileSize](dqdl-rule-types-FileSize.md) # AggregateMatch Überprüft das Verhältnis zweier Spaltenaggregationen anhand eines bestimmten Ausdrucks. Dieser Regeltyp funktioniert für mehrere Datensätze. Die beiden Spaltenaggregationen werden ausgewertet und ein Quotient wird gebildet, indem das Ergebnis der ersten Spaltenaggregation durch das Ergebnis der zweiten Spaltenaggregation dividiert wird. Das Verhältnis wird mit dem bereitgestellten Ausdruck verglichen, um eine boolesche Antwort zu erzeugen. **Syntax** **Spaltenaggregation** ``` AggregateMatch (.) ``` + **AGG\$1OPERATION** – Der für die Aggregation zu verwendende Vorgang. Derzeit werden `sum` und `avg` unterstützt. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **OPTIONAL\$1REFERENCE\$1ALIAS** – Dieser Parameter muss angegeben werden, wenn die Spalte aus einem Referenzdatensatz und nicht aus dem primären Datensatz stammt. Wenn Sie diese Regel im AWS Glue-Datenkatalog verwenden, muss Ihr Referenzalias das Format "haben. . **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **COL\$1NAME** – Der Name der Spalte, die aggregiert werden soll. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz **Beispiel: Durchschnitt** ``` "avg(rating)" ``` **Beispiel: Summe** ``` "sum(amount)" ``` **Beispiel: Durchschnitt der Spalte im Referenzdatensatz** ``` "avg(reference.rating)" ``` **Regel** ``` AggregateMatch ``` + **AGG\$1EXP\$11** – Die Aggregation der ersten Spalte. Unterstützte Spaltentypen: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AGG\$1EXP\$12** – Die Aggregation der zweiten Spalte. Unterstützte Spaltentypen: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Aggregieren einer Übereinstimmung mithilfe von Summe** Die folgende Beispielregel prüft, ob die Summe der Werte in der `amount`-Spalte genau der Summe der Werte in der `total_amount`-Spalte entspricht. ``` AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0 ``` **Beispiel: Aggregieren einer Übereinstimmung mithilfe des Durchschnitts** Die folgende Beispielregel prüft, ob der Durchschnitt der Werte in der `ratings`-Spalte mindestens 90 % des Durchschnitts der Werte in der `ratings`-Spalte im `reference`-Datensatz entspricht. Der Referenzdatensatz wird als zusätzliche Datenquelle im ETL- oder Data-Catalog-Erlebnis bereitgestellt. In AWS Glue ETL können Sie Folgendes verwenden: ``` AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9 ``` Im AWS Glue-Datenkatalog können Sie Folgendes verwenden: ``` AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9 ``` **Nullverhalten** Die `AggregateMatch`-Regel ignoriert Zeilen mit NULL-Werten bei der Berechnung der Aggregationsmethoden (Summe/Mittelwert). Beispiel: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` Der Mittelwert der Spalte `units` ist (0 \$1 20 \$1 40)/3 = 20. Die Zeilen 101 und 103 werden bei dieser Berechnung nicht berücksichtigt. # ColumnCorrelation Prüft die *Korrelation* zwischen zwei Spalten anhand eines bestimmten Ausdrucks. AWS Glue Data Quality verwendet den Korrelationskoeffizienten von Pearson, um die lineare Korrelation zwischen zwei Spalten zu messen. Das Ergebnis ist eine Zahl zwischen -1 und 1, die die Stärke und Richtung der Beziehung misst. **Syntax** ``` ColumnCorrelation ``` + **COL\$11\$1NAME** – Der Name der ersten Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **COL\$12\$1NAME** – Der Name der zweiten Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Spaltenkorrelation** Die folgende Beispielregel prüft, ob der Korrelationskoeffizient zwischen den Spalten `height` und `weight` stark positiv korreliert ist (Koeffizientenwert größer als 0,8). ``` ColumnCorrelation "height" "weight" > 0.8 ``` ``` ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40" ``` **Beispiel für dynamische Regeln** + `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))` + `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))` **Nullverhalten** Die `ColumnCorrelation`-Regel ignoriert Zeilen mit `NULL`-Werten bei der Berechnung der Korrelation. Beispiel: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` Die Zeilen 101 und 103 werden ignoriert und `ColumnCorrelation` hat den Wert 1,0. # ColumnCount Überprüft die Spaltenanzahl des primären Datensatzes anhand eines bestimmten Ausdrucks. Im Ausdruck können Sie die Anzahl der Spalten oder einen Spaltenbereich mithilfe von Operatoren wie `>` und `<` angeben. **Syntax** ``` ColumnCount ``` + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Numerische Überprüfung der Spaltenanzahl** Die folgende Beispielregel prüft, ob die Spaltenanzahl innerhalb eines bestimmten Bereichs liegt. ``` ColumnCount between 10 and 20 ``` **Beispiel für dynamische Regeln** + `ColumnCount >= avg(last(10))` + `ColumnCount between min(last(10))-1 and max(last(10))+1` # ColumnDataType Überprüft, ob die Werte in einer bestimmten Spalte in Apache Spark in den bereitgestellten Typ umgewandelt werden können. Akzeptiert einen `with threshold`-Ausdruck zur Prüfung auf eine Teilmenge der Werte in der Spalte. **Syntax** ``` ColumnDataType = ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. Unterstützte Spaltentypen: Zeichenfolgentyp **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **EXPECTED\$1TYPE** – Der erwartete Typ der Werte in der Spalte. Unterstützte Werte: Boolean, Date, Timestamp, Integer, Double, Float, Long **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **EXPRESSION** – Ein optionaler Ausdruck zur Angabe des Prozentsatzes der Werte, die vom erwarteten Typ sein sollen. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz **Beispiel: Spaltendatentyp-Ganzzahlen als Zeichenfolgen** Die folgende Beispielregel prüft, ob die Werte in der angegebenen Spalte, die vom Typ Zeichenfolge ist, in Ganzzahlen umgewandelt werden können. ``` ColumnDataType "colA" = "INTEGER" ``` **Beispiel: Spaltendatentyp-Ganzzahlen als Zeichenfolgen prüfen, ob eine Teilmenge der Werte vorhanden ist** Die folgende Beispielregel prüft, ob mehr als 90 % der Werte in der angegebenen Spalte, die vom Typ Zeichenfolge ist, in Ganzzahlen umgewandelt werden können. ``` ColumnDataType "colA" = "INTEGER" with threshold > 0.9 ``` # ColumnExists Prüft, ob eine Spalte vorhanden ist. **Syntax** ``` ColumnExists ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp **Beispiel: Spalte ist vorhanden** Die folgende Beispielregel prüft, ob die Spalte mit dem Namen `Middle_Name` vorhanden ist. ``` ColumnExists "Middle_Name" ``` # ColumnLength Prüft, ob die Länge jeder Zeile in einer Spalte einem bestimmten Ausdruck entspricht. **Syntax** ``` ColumnLength ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Zeichenfolge + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Länge der Spaltenzeile** Die folgende Beispielregel prüft, ob der Wert in jeder Zeile in der Spalte mit dem Namen `Postal_Code` 5 Zeichen lang ist. ``` ColumnLength "Postal_Code" = 5 ColumnLength "weightinkgs" = 2 where "weightinkgs > 10" ``` **Nullverhalten** Die `ColumnLength`-Regel behandelt `NULL`-Werte als Zeichenfolgen mit einer Länge von 0. Für eine `NULL`-Zeile: ``` ColumnLength "Postal_Code" > 4 # this will fail ``` ``` ColumnLength "Postal_Code" < 6 # this will succeed ``` Die folgende zusammengesetzte Beispielregel bietet eine Möglichkeit, `NULL`-Werte explizit als falsch einzustufen: ``` (ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL) ``` # ColumnNamesMatchPattern Überprüft, ob die Namen aller Spalten im primären Datensatz mit dem angegebenen regulären Ausdruck übereinstimmen. **Syntax** ``` ColumnNamesMatchPattern ``` + **PATTERN** – Das Muster, anhand dessen Sie die Datenqualitätsregel bewerten möchten. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz **Beispiel: Spaltennamen stimmen mit dem Muster überein** Die folgende Beispielregel prüft, ob alle Spalten mit dem Präfix „aws\$1“ beginnen ``` ColumnNamesMatchPattern "aws_.*" ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10" ``` # ColumnValues Führt einen Ausdruck für die Werte in einer Spalte aus. **Syntax** ``` ColumnValues ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Zulässige Werte** Die folgende Beispielregel prüft, ob jeder Wert in der angegebenen Spalte in einer Gruppe zulässiger Werte enthalten ist (einschließlich Null, leer und Zeichenfolgen, die nur Leerzeichen enthalten). ``` ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ] ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10" ``` **Beispiel: Regulärer Ausdruck** Die folgende Beispielregel prüft die Werte in einer Spalte anhand eines regulären Ausdrucks. ``` ColumnValues "First_Name" matches "[a-zA-Z]*" ``` **Beispiel: Datumswerte** Die folgende Beispielregel prüft die Werte in einer Datumsspalte anhand eines Datumsausdrucks. ``` ColumnValues "Load_Date" > (now() - 3 days) ``` **Beispiel: Numerische Werte** Die folgende Beispielregel prüft, ob die Spaltenwerte mit einer bestimmten numerischen Einschränkung übereinstimmen. ``` ColumnValues "Customer_ID" between 1 and 2000 ``` **Nullverhalten** Für alle `ColumnValues`-Regeln (außer `!=` und `NOT IN`) gilt, dass `NULL`-Zeilen die Regel nicht erfüllen. Wenn die Regel aufgrund eines Nullwerts nicht erfüllt ist, wird die Fehlerursache wie folgt angezeigt: ``` Value: NULL does not meet the constraint requirement! ``` Die folgende zusammengesetzte Beispielregel bietet eine Möglichkeit, `NULL`-Werte explizit zuzulassen: ``` (ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL) ``` Negierte ColumnValues Regeln, die die `not in` Syntax `!=` und verwenden, gelten für `NULL` Zeilen. Beispiel: ``` ColumnValues "Age" != 21 ``` ``` ColumnValues "Age" not in [21, 22, 23] ``` Die folgenden Beispiele bieten eine Möglichkeit, `NULL`-Werte explizit als falsch zu definieren. ``` (ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL) ``` ``` ColumnValues "Age" not in [21, 22, 23, NULL] ``` # Vollständigkeit Prüft den Prozentsatz vollständiger (nicht null) Werte in einer Spalte anhand eines bestimmten Ausdrucks. **Syntax** ``` Completeness ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Prozentualer Nullwert** Die folgenden Beispielregeln prüfen, ob mehr als 95 Prozent der Werte in einer Spalte vollständig sind. ``` Completeness "First_Name" > 0.95 Completeness "First_Name" > 0.95 where "weightinkgs > 10" ``` **Beispiel für dynamische Regeln** + `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1` + `Completeness "colA" <= avg(last(10))` **Nullverhalten** Hinweis zu CSV-Datenformaten: Leere Zeilen in CSV-Spalten können unterschiedliche Verhaltensweisen aufweisen. + Wenn eine Spalte vom Typ `String` ist, wird die leere Zeile als leere Zeichenfolge erkannt und verstößt nicht gegen die `Completeness`-Regel. + Wenn eine Spalte einen anderen Datentyp wie beispielsweise `Int` hat, wird die leere Zeile als `NULL` erkannt und verstößt gegen die `Completeness`-Regel. # CustomSQL Dieser Regeltyp wurde erweitert, um zwei Anwendungsfälle zu unterstützen: + Führen Sie eine benutzerdefinierte SQL-Anweisung für einen Datensatz aus und prüfen Sie den Rückgabewert anhand eines bestimmten Ausdrucks. + Führen Sie eine benutzerdefinierte SQL-Anweisung aus, in der Sie in Ihrer SELECT-Anweisung einen Spaltennamen angeben, den Sie mit einer Bedingung vergleichen, um Ergebnisse auf Zeilenebene zu erhalten. **Syntax** ``` CustomSql ``` + **SQL\$1STATEMENT** – Eine SQL-Anweisung, die einen einzelnen numerischen Wert zurückgibt, der von doppelten Anführungszeichen umgeben ist. + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Benutzerdefiniertes SQL zum Abrufen eines Gesamtregelergebnisses** Diese Beispielregel verwendet eine SQL-Anweisung, um die Datensatzanzahl für einen Datensatz abzurufen. Die Regel prüft dann, ob die Datensatzanzahl zwischen 10 und 20 liegt. ``` CustomSql "select count(*) from primary" between 10 and 20 ``` **Beispiel: Benutzerdefiniertes SQL zum Abrufen von Ergebnissen auf Zeilenebene** Diese Beispielregel verwendet eine SQL-Anweisung, bei der Sie in Ihrer SELECT-Anweisung einen Spaltennamen angeben, den Sie mit einer Bedingung vergleichen, um Ergebnisse auf Zeilenebene zu erhalten. Ein Ausdruck für eine Schwellenwertbedingung definiert einen Schwellenwert dafür, wie viele Datensätze fehlschlagen sollten, damit die gesamte Regel fehlschlägt. Beachten Sie, dass eine Regel nicht gleichzeitig eine Bedingung und ein Schlüsselwort enthalten darf. ``` CustomSql "select Name from primary where Age > 18" ``` oder ``` CustomSql "select Name from primary where Age > 18" with threshold > 3 ``` **Wichtig** Der `primary`-Alias steht stellvertretend für den Namen des Datensatzes, den Sie auswerten möchten. Wenn Sie mit visuellen ETL-Aufträgen in der Konsole arbeiten, steht `primary` immer für das `DynamicFrame`, das an die `EvaluateDataQuality.apply()`-Transformation übergeben wird. Wenn Sie den AWS Glue-Datenkatalog verwenden, um Datenqualitätsaufgaben für eine Tabelle auszuführen, `primary` stellt dies die Tabelle dar. Wenn Sie sich im AWS Glue Data Catalog befinden, können Sie auch die tatsächlichen Tabellennamen verwenden: ``` CustomSql "select count(*) from database.table" between 10 and 20 ``` Sie können auch mehrere Tabellen miteinander verbinden, um verschiedene Datenelemente zu vergleichen: ``` CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20 ``` In AWS Glue ETL kann CustomSQL Datensätze identifizieren, die die Datenqualitätsprüfungen nicht bestanden haben. Damit dies funktioniert, müssen Sie Datensätze zurückgeben, die Teil der Primärtabelle sind, deren Datenqualität Sie auswerten. Datensätze, die im Rahmen der Abfrage zurückgegeben werden, gelten als erfolgreich und Datensätze, die nicht zurückgegeben werden, gelten als fehlgeschlagen. Dies funktioniert, indem das Ergebnis Ihrer CustomSQL-Abfrage mit dem ursprünglichen Datensatz verknüpft wird. Aufgrund der Komplexität Ihrer SQL-Abfrage kann es zu Leistungseinbußen kommen. So gehen Sie vor: + Sie müssen mindestens eine Spalte aus Ihrer Primärtabelle auswählen. + `select count(*) from primary` ist eine gültige Abfrage für die gesamte CustomSQL-DQ-Regel, aber nicht für CustomSQL auf Zeilenebene. + Diese Regel löst bei der Auswertung einen Fehler aus: `The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but the columns from the SQL result are not present in the Input Dataset. Ensure that matching columns are returned from the SQL.` + Wählen Sie in Ihrer SQL-Abfrage einen `Primärschlüssel` aus Ihrer Tabelle oder wählen Sie eine Gruppe von Spalten aus, die einen zusammengesetzten Schlüssel bilden. Andernfalls kann es aufgrund der Übereinstimmung doppelter Zeilen zu inkonsistenten Ergebnissen und einer verminderten Leistung kommen. + Wählen Sie NUR Schlüssel aus Ihrer Primärtabelle und nicht aus Ihren Referenztabellen aus. Die folgende Regel stellt sicher, dass Datensätze mit einem Alter von weniger als 100 Jahre als erfolgreich identifiziert werden und Datensätze darüber als fehlgeschlagen markiert werden. ``` CustomSql "select id from primary where age < 100" ``` Diese CustomSQL-Regel wird bestanden, wenn 50 % der Datensätze älter als 10 Jahre sind, und identifiziert auch Datensätze, die fehlgeschlagen sind. Die von diesem CustomSQL zurückgegebenen Datensätze gelten als bestanden, während die nicht zurückgegebenen Datensätze als fehlgeschlagen gelten. ``` CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5 ``` Hinweis: Die CustomSQL-Regel schlägt fehl, wenn Sie Datensätze zurückgeben, die im Datensatz nicht verfügbar sind. # DataFreshness Prüft die Aktualität der Daten in einer Spalte, indem die Differenz zwischen der aktuellen Uhrzeit und den Werten einer Datumsspalte ausgewertet wird. Sie können einen zeitbasierten Ausdruck für diesen Regeltyp angeben, um sicherzustellen, dass die Spaltenwerte aktuell sind. **Syntax** ``` DataFreshness ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Datum + **AUSDRUCK** – Ein numerischer Ausdruck in Stunden oder Tagen. Sie müssen die Zeiteinheit in Ihrem Ausdruck angeben. **Beispiel: Datenaktualität** Die folgenden Beispielregeln prüfen die Datenaktualität. ``` DataFreshness "Order_Date" <= 24 hours DataFreshness "Order_Date" between 2 days and 5 days ``` **Nullverhalten** Die `DataFreshness`-Regeln schlagen bei Zeilen mit `NULL`-Werten fehl. Wenn die Regel aufgrund eines Nullwerts nicht erfüllt ist, wird die Fehlerursache wie folgt angezeigt: ``` 80.00 % of rows passed the threshold ``` wobei 20 % der fehlgeschlagenen Zeilen die Zeilen mit `NULL` enthalten. Die folgende zusammengesetzte Beispielregel bietet eine Möglichkeit, `NULL`-Werte explizit zuzulassen: ``` (DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL) ``` **Datenaktualität für Amazon-S3-Objekte** Manchmal müssen Sie die Aktualität der Daten anhand der Erstellungszeit der Amazon-S3-Datei überprüfen. Dazu können Sie den folgenden Code verwenden, um den Zeitstempel abzurufen und ihn Ihrem Datenrahmen hinzuzufügen. Anschließend können Sie Datenaktualisierungsprüfungen durchführen. ``` df = glueContext.create_data_frame.from_catalog(database = "default", table_name = "mytable") df = df.withColumn("file_ts", df["_metadata.file_modification_time"]) Rules = [ DataFreshness "file_ts" < 24 hours ] ``` # DatasetMatch Prüft, ob die Daten im Primärdatensatz mit den Daten in einem Referenzdatensatz übereinstimmen. Die beiden Datensätze werden mithilfe der bereitgestellten Schlüsselspaltenzuordnungen verbunden. Wenn Sie die Gleichheit der Daten nur in diesen Spalten prüfen möchten, können zusätzliche Spaltenzuordnungen bereitgestellt werden. Beachten Sie, dass Ihre Join-Schlüssel eindeutig sein müssen und nicht NULL sein sollten (müssen ein Primärschlüssel sein), **DataSetMatch**damit sie funktionieren. Wenn Sie diese Bedingungen nicht erfüllen, erhalten Sie die Fehlermeldung „Die bereitgestellte Schlüsselkarte ist für bestimmte Datenrahmen nicht geeignet“. In Fällen, in denen Sie keine eindeutigen Schlüssel verknüpft haben können, sollten Sie die Verwendung anderer Regeltypen in Betracht ziehen, z. B. **AggregateMatch**den Abgleich bei Übersichtsdaten. **Syntax** ``` DatasetMatch ``` + **REFERENCE\$1DATASET\$1ALIAS** – Der Alias des Referenzdatensatzes, mit dem Sie Daten aus dem Primärdatensatz vergleichen. + **KEY\$1COLUMN\$1MAPPINGS** – Eine durch Kommas getrennte Liste von Spaltennamen, die einen Schlüssel in den Datensätzen bilden. Wenn die Spaltennamen in beiden Datensätzen nicht identisch sind, müssen Sie sie durch einen `->` trennen + **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS** – Sie können diesen Parameter angeben, wenn Sie nur in bestimmten Spalten nach übereinstimmenden Daten suchen möchten. Es verwendet dieselbe Syntax wie die Schlüsselspaltenzuordnungen. Wenn dieser Parameter nicht angegeben wird, werden die Daten in allen verbleibenden Spalten abgeglichen. Die verbleibenden Nicht-Schlüsselspalten müssen in beiden Datensätzen dieselben Namen aufweisen. + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Zuordnen von Set-Datensätzen mithilfe der ID-Spalte** Die folgende Beispielregel prüft, ob mehr als 90 % des primären Datensatzes mit dem Referenzdatensatz übereinstimmt, und verwendet dabei die Spalte „ID“, um die beiden Datensätze zu verbinden. In diesem Fall werden alle Spalten verglichen. ``` DatasetMatch "reference" "ID" >= 0.9 ``` **Beispiel: Festlegen von Datensätzen mithilfe mehrerer Schlüsselspalten** Im folgenden Beispiel haben der Primärdatensatz und der Referenzdatensatz unterschiedliche Namen für die Schlüsselspalten. `ID_1` und `ID_2` bilden zusammen einen zusammengesetzten Schlüssel im Primärdatensatz. `ID_ref1` und `ID_ref2` bilden zusammen einen zusammengesetzten Schlüssel im Referenzdatensatz. In diesem Szenario können Sie die spezielle Syntax zur Bereitstellung der Spaltennamen verwenden. ``` DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9 ``` **Beispiel: Festlegung von Datensätzen mithilfe mehrerer Schlüsselspalten und Überprüfung der Übereinstimmung bestimmter Spalten** Dieses Beispiel basiert auf dem vorherigen Beispiel. Wir möchten überprüfen, ob nur die Spalte mit den Beträgen übereinstimmt. Diese Spalte ist im Primärdatensatz `Amount1` benannt und im Referenzdatensatz `Amount2` benannt. Sie möchten eine exakte Übereinstimmung. ``` DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9 ``` # DistinctValuesCount Prüft die Anzahl unterschiedlicher Werte in einer Spalte anhand eines bestimmten Ausdrucks. **Syntax** ``` DistinctValuesCount ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Anzahl eindeutiger Spaltenwerte** Die folgende Beispielregel prüft, ob die Spalte mit dem Namen `State` mehr als 3 unterschiedliche Werte enthält. ``` DistinctValuesCount "State" > 3 DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** + `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1` + `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))` # Entropie Prüft, ob der *Entropie*-Wert einer Spalte mit einem bestimmten Ausdruck übereinstimmt. Die Entropie misst den Informationsgehalt, der in einer Nachricht enthalten ist. Bei gegebener Wahrscheinlichkeitsverteilung über Werte in einer Spalte beschreibt die Entropie, wie viele Bits benötigt werden, um einen Wert zu identifizieren. **Syntax** ``` Entropy ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Spaltenentropie** Die folgende Beispielregel prüft, ob die Spalte mit dem Namen `Feedback` einen Entropiewert größer als eins hat. ``` Entropy "Star_Rating" > 1 Entropy "First_Name" > 1 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** + `Entropy "colA" < max(last(10))` + `Entropy "colA" between min(last(10)) and max(last(10))` # IsComplete Prüft, ob alle Werte in einer Spalte vollständig (nicht null) sind. **Syntax** ``` IsComplete ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp **Beispiel: Nullwerte** Das folgende Beispiel prüft, ob alle Werte in einer Spalte mit dem Namen `email` nicht null sind. ``` IsComplete "email" IsComplete "Email" where "Customer_ID between 1 and 50" IsComplete "Customer_ID" where "Customer_ID < 16 and Customer_ID != 12" IsComplete "passenger_count" where "payment_type<>0" ``` **Nullverhalten** Hinweis zu CSV-Datenformaten: Leere Zeilen in CSV-Spalten können unterschiedliche Verhaltensweisen aufweisen. + Wenn eine Spalte vom Typ `String` ist, wird die leere Zeile als leere Zeichenfolge erkannt und verstößt nicht gegen die `Completeness`-Regel. + Wenn eine Spalte einen anderen Datentyp wie beispielsweise `Int` hat, wird die leere Zeile als `NULL` erkannt und verstößt gegen die `Completeness`-Regel. # IsPrimaryKey Prüft, ob eine Spalte einen Primärschlüssel enthält. Eine Spalte enthält einen Primärschlüssel, wenn alle Werte in der Spalte eindeutig und vollständig (nicht null) sind. Sie können auch nach Primärschlüsseln mit mehreren Spalten suchen. **Syntax** ``` IsPrimaryKey ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp **Beispiel: Primärschlüssel** Die folgende Beispielregel prüft, ob die Spalte mit dem Namen `Customer_ID` einen Primärschlüssel enthält. ``` IsPrimaryKey "Customer_ID" IsPrimaryKey "Customer_ID" where "Customer_ID < 10" ``` **Beispiel: Primärschlüssel mit mehreren Spalten. Alle folgenden Beispiele sind gültig.** ``` IsPrimaryKey "colA" "colB" IsPrimaryKey "colA" "colB" "colC" IsPrimaryKey colA "colB" "colC" ``` # IsUnique Prüft, ob alle Werte in einer Spalte eindeutig sind, und gibt einen Booleschen Wert zurück. **Syntax** ``` IsUnique ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp **Beispiele** Die folgende Beispielregel prüft, ob alle Werte in einer Spalte mit dem Namen `email` eindeutig sind. ``` IsUnique "email" IsUnique "Customer_ID" where "Customer_ID < 10"] ``` Die folgende Beispielregel überprüft mehrere Spalten. ``` IsUnique "vendorid" "tpep_pickup_datetime" ``` # Mean Prüft, ob der Mittelwert (Durchschnitt) aller Werte in einer Spalte mit einem bestimmten Ausdruck übereinstimmt. **Syntax** ``` Mean ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Durchschnittswert** Die folgende Beispielregel prüft, ob der Durchschnitt aller Werte in einer Spalte einen Schwellenwert überschreitet. ``` Mean "Star_Rating" > 3 Mean "Salary" < 6200 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** + `Mean "colA" > avg(last(10)) + std(last(2))` + `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1` **Nullverhalten** Die `Mean`-Regel ignoriert Zeilen mit `NULL`-Werten bei der Berechnung des Mittelwerts. Beispiel: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` Der Mittelwert der Spalte `units` ist (0 \$1 20 \$1 40)/3 = 20. Die Zeilen 101 und 103 werden bei dieser Berechnung nicht berücksichtigt. # ReferentialIntegrity Überprüft, inwieweit die Werte einer Spaltengruppe im Primärdatensatz eine Teilmenge der Werte einer Spaltengruppe in einem Referenzdatensatz sind. **Syntax** ``` ReferentialIntegrity ``` + **PRIMARY\$1COLS** – Eine durch Kommas getrennte Liste von Spaltennamen im primären Datensatz. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **REFERENCE\$1DATASET\$1COLS** – Dieser Parameter besteht aus zwei durch einen Punkt getrennten Teilen. Der erste Teil ist der Alias des Referenzdatensatzes. Der zweite Teil ist die durch Kommas getrennte Liste der Spaltennamen im Referenzdatensatz in geschweiften Klammern. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Überprüfung der referenziellen Integrität einer PLZ-Spalte** Die folgende Beispielregel prüft, ob mehr als 90 % der Werte in der `zipcode`-Spalte im Primärdatensatz in der `zipcode`-Spalte im `reference`-Datensatz vorhanden sind. ``` ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9 ``` **Beispiel: Überprüfung der referenziellen Integrität der Spalten „Stadt“ und „Bundesland“** Im folgenden Beispiel sind im Primärdatensatz und im Referenzdatensatz Spalten mit Stadt- und Bundeslandinformationen vorhanden. Die Namen der Spalten sind in beiden Datensätzen unterschiedlich. Die Regel prüft, ob die Wertemenge der Spalten im Primärdatensatz genau mit der Wertemenge der Spalten im Referenzdatensatz übereinstimmt. ``` ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0 ``` **Beispiel für dynamische Regeln** + `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" > avg(last(10))` + `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" between min(last(10)) - 1 and max(last(10)) + 1` # RowCount Prüft die Zeilenzahl eines Datensatzes anhand eines bestimmten Ausdrucks. Im Ausdruck können Sie mit Operatoren wie `>` und `<` die Anzahl der Zeilen oder einen Zeilenbereich angeben. **Syntax** ``` RowCount ``` + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Numerische Überprüfung der Zeilenanzahl** Die folgende Beispielregel prüft, ob die Zeilenanzahl innerhalb eines bestimmten Bereichs liegt. ``` RowCount between 10 and 100 RowCount between 1 and 50 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** ``` RowCount > avg(last(10)) *0.8 ``` # RowCountMatch Überprüft das Verhältnis der Zeilenanzahl des Primärdatensatzes und der Zeilenanzahl eines Referenzdatensatzes anhand des angegebenen Ausdrucks. **Syntax** ``` RowCountMatch ``` + **REFERENCE\$1DATASET\$1ALIAS** – Der Alias des Referenzdatensatzes, mit dem die Zeilenanzahl verglichen werden soll. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Überprüfung der Zeilenanzahl anhand eines Referenzdatensatzes** Die folgende Beispielregel überprüft, ob die Zeilenanzahl des Primärdatensatzes mindestens 90 % der Zeilenanzahl des Referenzdatensatzes beträgt. ``` RowCountMatch "reference" >= 0.9 ``` # StandardDeviation Prüft die Standardabweichung aller Werte in einer Spalte anhand eines bestimmten Ausdrucks. **Syntax** ``` StandardDeviation ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Example: Standardabweichung** Die folgende Beispielregel prüft, ob die Standardabweichung der Werte in einer Spalte mit dem Namen `colA` kleiner als ein bestimmter Wert ist. ``` StandardDeviation "Star_Rating" < 1.5 StandardDeviation "Salary" < 3500 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** + `StandardDeviation "colA" > avg(last(10) + 0.1` + `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1` **Nullverhalten** Die `StandardDeviation`-Regel ignoriert Zeilen mit `NULL`-Werten bei der Berechnung der Standardabweichung. Beispiel: ``` +---+-----------+-----------+ |id |units1 |units2 | +---+-----------+-----------+ |100|0 |0 | |101|null |0 | |102|20 |20 | |103|null |0 | |104|40 |40 | +---+-----------+-----------+ ``` Bei der Standardabweichung von Spalte `units1` werden die Zeilen 101 und 103 nicht berücksichtigt und das Ergebnis ist 16,33. Die Standardabweichung für Spalte `units2` ist 16. # Summe Prüft die Summe aller Werte in einer Spalte anhand eines bestimmten Ausdrucks. **Syntax** ``` Sum ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Summe** Die folgende Beispielregel prüft, ob die Summe aller Werte in einer Spalte einen bestimmten Schwellenwert überschreitet. ``` Sum "transaction_total" > 500000 Sum "Salary" < 55600 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** + `Sum "ColA" > avg(last(10))` + `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1` **Nullverhalten** Die `Sum`-Regel ignoriert Zeilen mit `NULL`-Werten bei der Berechnung der Summe. Beispiel: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` Bei der Summe der Spalte `units` werden die Zeilen 101 und 103 nicht berücksichtigt und das Ergebnis ist (0 \$1 20 \$1 40) = 60. # SchemaMatch Überprüft, ob das Schema des primären Datensatzes mit dem Schema eines Referenzdatensatzes übereinstimmt. Die Schemaprüfung erfolgt spaltenweise. Das Schema zweier Spalten stimmt überein, wenn die Namen identisch sind und die Typen identisch sind. Die Reihenfolge der Spalten spielt keine Rolle. **Syntax** ``` SchemaMatch ``` + **REFERENCE\$1DATASET\$1ALIAS** – Der Alias des Referenzdatensatzes, mit dem Schemas verglichen werden sollen. **Unterstützte Spaltentypen**: Byte, Dezimal, Doppelt, Gleitkommazahl, Ganzzahl, Lang, Kurz + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: SchemaMatch** Die folgende Beispielregel prüft, ob das Schema des Primärdatensatzes genau mit dem Schema eines Referenzdatensatzes übereinstimmt. ``` SchemaMatch "reference" = 1.0 ``` # Eindeutigkeit Prüft den Prozentsatz eindeutiger Werte in einer Spalte anhand eines bestimmten Ausdrucks. Eindeutige Werte treten genau einmal auf. **Syntax** ``` Uniqueness ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel** Die folgende Beispielregel prüft, ob der Prozentsatz eindeutiger Werte in einer Spalte bestimmten numerischen Kriterien entspricht. ``` Uniqueness "email" = 1.0 Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10" ``` Die folgende Beispielregel überprüft mehrere Spalten. ``` Uniqueness "vendorid" "tpep_pickup_datetime" = 1 ``` **Beispiel für dynamische Regeln** + `Uniqueness "colA" between min(last(10)) and max(last(10))` + `Uniqueness "colA" >= avg(last(10))` # UniqueValueRatio Prüft das *eindeutige Werteverhältnis* einer Spalte anhand eines bestimmten Ausdrucks. Ein Einzelwertverhältnis ist der Bruchteil der Einzelwerte dividiert durch die Anzahl aller eindeutigen Werte in einer Spalte. Eindeutige Werte treten genau einmal auf, während unterschiedliche Werte *mindestens* einmal vorkommen. Der Satz `[a, a, b]` enthält beispielsweise einen eindeutigen Wert (`b`) und zwei unterschiedliche Werte (`a` und `b`). Das eindeutige Wertverhältnis der Menge ist also ½ = 0,5. **Syntax** ``` UniqueValueRatio ``` + **COL\$1NAME** – Der Name der Spalte, anhand der Sie die Datenqualitätsregel auswerten möchten. **Unterstützte Spaltentypen**: Jeder Spaltentyp + **AUSDRUCK** – Ein Ausdruck, der für die Antwort des Regeltyps ausgeführt wird, um einen booleschen Wert zu erzeugen. Weitere Informationen finden Sie unter [Ausdrücke](dqdl.md#dqdl-syntax-rule-expressions). **Beispiel: Einzigartiges Werteverhältnis** In diesem Beispiel wird das Verhältnis der eindeutigen Werte einer Spalte zu einem Wertebereich geprüft. ``` UniqueValueRatio "test_score" between 0 and 0.5 UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10" ``` **Beispiel für dynamische Regeln** + `UniqueValueRatio "colA" > avg(last(10))` + `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))` # DetectAnomalies Erkennt Anomalien für eine bestimmte Datenqualitätsregel. Jede Ausführung der DetectAnomalies Regel führt dazu, dass der ausgewertete Wert für die angegebene Regel gespeichert wird. Wenn genügend Daten gesammelt wurden, verwendet der Algorithmus zur Erkennung von Anomalien alle historischen Daten für diese bestimmte Regel und führt eine Anomalieerkennung durch. DetectAnomalies Die Regel schlägt fehl, wenn eine Anomalie erkannt wird. Weitere Informationen zu entdeckten Anomalien finden Sie in den Beobachtungen. **Syntax** ``` DetectAnomalies ``` `RULE_NAME` – Der Name der Regel, die ausgewertet und für die Anomalien erkannt werden sollen. Unterstützte Regeln: + "RowCount" + „Completeness“ + „Uniqueness“ + „Mean“ + „Sum“ + "StandardDeviation" + „Entropy“ + "DistinctValuesCount" + "UniqueValueRatio" + "ColumnLength" + "ColumnValues" + "ColumnCorrelation" + „CustomSQL“ + "ColumnCount" `RULE_PARAMETERS` – Für die Ausführung einiger Regeln sind zusätzliche Parameter erforderlich. Die erforderlichen Parameter finden Sie in der jeweiligen Regeldokumentation. **Beispiel: Anomalien für RowCount** Wenn wir beispielsweise RowCount Anomalien erkennen möchten, geben wir RowCount als Regelnamen an. ``` DetectAnomalies "RowCount" ``` **Beispiel: Anomalien für ColumnLength** Wenn wir beispielsweise ColumnLength Anomalien erkennen möchten, geben wir ColumnLength als Regelnamen und den Spaltennamen an. ``` DetectAnomalies "ColumnLength" "id" ``` # FileFreshness FileFreshness stellt sicher, dass Ihre Datendateien auf der Grundlage der von Ihnen angegebenen Bedingungen aktuell sind. Es verwendet den Zeitpunkt der letzten Änderung Ihrer Dateien, um sicherzustellen, dass die Datendateien oder der gesamte Ordner korrekt sind up-to-date. Diese Regel erfasst zwei Metriken: + FileFreshness Einhaltung der Vorschriften auf der Grundlage der von Ihnen eingerichteten Regel + Die Anzahl der Dateien, die von der Regel gescannt wurden ``` {"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1} ``` Die Anomalieerkennung berücksichtigt diese Metriken nicht. **Überprüfen der Aktualität von Dateien** Die folgende Regel stellt sicher, dass tickets.parquet innerhalb der letzten 24 Stunden erstellt wurde. ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours) ``` **Überprüfen der Aktualität von Ordnern** Die folgende Regel gilt, wenn alle Dateien im Ordner innerhalb der letzten 24 Stunden erstellt oder geändert wurden. ``` FileFreshness "s3://bucket/" >= (now() -1 days) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours) ``` **Überprüfen der Aktualität von Ordnern oder Dateien anhand eines Schwellenwerts** Die folgende Regel gilt, wenn 10 % der Dateien im Ordner „Tickets“ in den letzten 10 Tagen erstellt oder geändert wurden. ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1 ``` **Überprüfen von Dateien oder Ordnern mit bestimmten Daten** Sie können die Aktualität von Dateien für bestimmte Tage überprüfen. ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2020-01-01" FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2023-01-01" and "2024-01-01" ``` **Überprüfen von Dateien oder Ordnern mit Zeitpunkten** Sie können FileFreshness damit sicherstellen, dass Dateien zu bestimmten Zeiten eingetroffen sind. ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between now() and (now() - 45 minutes) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "9:30 PM" FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > (now() - 10 minutes) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > now() FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 2 hours) and (now() + 15 minutes) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 3 days) and (now() + 15 minutes) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2001-02-07" and (now() + 15 minutes) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"" FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2024-01-01" FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "02:30" and "04:30" FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "22:15" ``` Wesentliche Überlegungen: + FileFreshness kann Dateien anhand von Tagen, Stunden und Minuten auswerten + AM/PM und 24-Stunden-System werden unterstützt. + Die Zeiten werden in UTC berechnet, sofern keine Überschreibung angegeben ist. + Datumsangaben werden in UTC zur Uhrzeit 00:00 berechnet. FileFreshness das ist zeitbasiert und funktioniert wie folgt: ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45" ``` + Zunächst wird die Uhrzeit „21:45“ mit dem heutigen Datum im UTC-Format kombiniert, um ein Datums-/Zeitfeld zu erstellen. + Als Nächstes wird das Datum und die Uhrzeit in die von Ihnen angegebene Zeitzone umgewandelt. + Schließlich wird die Regel ausgewertet. **Optionale dateibasierte Regel-Tags:** Mit Tags können Sie das Verhalten der Regel steuern. **recentFiles** Dieses Tag begrenzt die Anzahl der verarbeiteten Dateien, indem die neueste Datei zuerst angezeigt wird. ``` FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1 ``` **uriRegex** **Anmerkung** Das `uriRegex` Tag ist in AWS Glue 5.0 und höher verfügbar. Dieses Tag filtert Dateien, indem es ein Regex-Muster auf den Dateipfad anwendet. Es werden nur Dateien verarbeitet, deren Pfade dem Muster entsprechen. Sie können auch einen negativen Lookahead verwenden, um Dateien auszuschließen, die einem Muster entsprechen. ``` # Match only files with a .csv extension FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "\.csv$" # Match Parquet files that contain "orders_" in the path FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = ".*orders_.*\.parquet" # Exclude files ending in .tmp using a negative lookahead FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "(?!.*\.tmp$).*" ``` **Reihenfolge filtern** **Anmerkung** Das `filterOrder` Tag ist in AWS Glue 5.0 und höher verfügbar. Wenn Sie mehrere Filter-Tags wie `recentFiles` und `uriRegex` zusammen verwenden, steuert das `filterOrder` Tag die Reihenfolge, in der sie angewendet werden. Die Standardreihenfolge ist `recentFiles` zuerst, dann`uriRegex`. ``` FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"] ``` Im obigen Beispiel wird der `uriRegex` Filter zuerst angewendet, um nur Dateien auszuwählen, die mit „inventory\$1“ übereinstimmen, und `recentFiles = 1` nimmt dann die neueste Datei aus diesem gefilterten Satz. `filterOrder`Andernfalls würde das Standardverhalten zuerst die neueste Datei verwenden und dann den regulären Ausdruck anwenden. Dies könnte dazu führen, dass keine Dateien übereinstimmen, wenn die neueste Datei nicht dem Muster entspricht. **Anmerkung** Alle Werte in der `filterOrder` Liste müssen auf andere Filter-Tags (`recentFiles`oder`uriRegex`) verweisen, die ebenfalls in derselben Regel vorhanden sind. Nichtfilter-Tags wie `timeZone` oder `failFast` sind nicht gültig in`filterOrder`. **FailFast** Wenn diese Option auf gesetzt ist`"true"`, gibt die Regel bei der ersten Datei, die die Aktualisierungsbedingung nicht erfüllt, sofort einen Fehler zurück, anstatt alle Dateien zu bewerten und eine Konformitätsquote zu berechnen. ``` FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true" ``` **timeZone** Akzeptierte Zeitzonenüberschreibungen. Unterstützte Zeitzonen finden Sie unter [Zulässige Zeitzonen](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html). ``` FileFreshness "s3://path/" > "21:45" with timeZone = "America/New_York" ``` ``` FileFreshness "s3://path/" > "21:45" with timeZone = "America/Chicago" ``` ``` FileFreshness "s3://path/" > "21:45" with timeZone = "Europe/Paris" ``` ``` FileFreshness "s3://path/" > "21:45" with timeZone = "Asia/Shanghai" ``` ``` FileFreshness "s3://path/" > "21:45" with timeZone = "Australia/Darwin" ``` **Direktes Ableiten von Dateinamen aus Datenrahmen** Sie müssen nicht immer einen Dateipfad angeben. Wenn Sie beispielsweise die Regel im AWS Glue-Datenkatalog erstellen, kann es schwierig sein, herauszufinden, welche Ordner die Katalogtabellen verwenden. AWS Glue Data Quality kann die spezifischen Ordner oder Dateien finden, die zum Auffüllen Ihres Datenrahmens verwendet wurden, und erkennt, ob sie aktuell sind. **Anmerkung** Diese Funktion funktioniert nur, wenn Dateien erfolgreich in das Feld oder eingelesen wurden. DynamicFrame DataFrame ``` FileFreshness > (now() - 24 hours) ``` Diese Regel findet den Ordnerpfad oder die Dateien, die zum Füllen des dynamischen Rahmens oder Datenrahmens verwendet werden. Dies funktioniert für Amazon S3 S3-Pfade oder Amazon S3-basierte AWS Glue Data Catalog-Tabellen. Es gibt ein paar Überlegungen: 1. In AWS Glue ETL müssen Sie die **EvaluateDataQuality**Transformation unmittelbar nach einer Amazon S3- oder AWS Glue Data Catalog-Transformation haben. ![\[Der Screenshot zeigt einen Knoten „Evaluate Data Quality“, der mit einem Amazon-S3-Knoten verbunden ist.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/data-quality-file-freshness.png) 1. Diese Regel funktioniert nicht in AWS Glue Interactive Sessions. Wenn Sie dies in beiden Fällen versuchen oder wenn AWS Glue die Dateien nicht finden kann, gibt AWS Glue den folgenden Fehler aus: `“Unable to parse file path from DataFrame”` # FileMatch Die FileMatch Regel ermöglicht es Ihnen, Dateien mit anderen Dateien oder Prüfsummen zu vergleichen. Dies kann in einigen Szenarien nützlich sein: 1. Überprüfen von Dateien, die von externen Quellen empfangen wurden: Mit FileMatch dieser Methode können Sie sicherstellen, dass Sie die richtigen Dateien von externen Quellen erhalten haben, indem Sie sie mit Prüfsummen vergleichen. Auf diese Weise können Sie die Integrität der Daten überprüfen, die Sie erfassen. 1. Daten in zwei verschiedenen Ordnern vergleichen: FileMatch Kann verwendet werden, um Dateien zwischen zwei Ordnern zu vergleichen. Diese Regel erfasst eine Metrik: die Anzahl der Dateien, die von der Regel gescannt wurden. ``` {"Dataset.*.FileCount":1} ``` **Datei mit einer Prüfsumme validieren:** FileMatch akzeptiert eine Datei und festgelegte Prüfsummen, um sicherzustellen, dass mindestens eine Prüfsumme mit der Datei übereinstimmt. ``` FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5" FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1" FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256" FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] ``` Die folgenden Algorithmen werden unterstützt: + MD5 + SHA-1 + SHA-1 Wenn Sie keinen Algorithmus angeben, ist der Standard SHA-256. **Alle Dateien in einem Ordner mit einer Reihe von Prüfsummen validieren:** ``` FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5" FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] ``` **Dateien in verschiedenen Ordnern vergleichen** ``` # Compare all files across two buckets FileMatch "s3://original_bucket/" "s3://archive_bucket/" # Compare files within specific subfolders FileMatch "s3://original_bucket/internal-folder/" "s3://original_bucket/other-folder/" # Compare only .json files across two folders FileMatch "s3://original_bucket/" "s3://archive_bucket/" with uriRegex = "\.json$" # Compare only the 5 most recent .csv files FileMatch "s3://original_bucket/" "s3://archive_bucket/" with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"] ``` FileMatch überprüft den Inhalt der Dateien `original_bucket` und stellt sicher, dass sie mit dem Inhalt übereinstimmen. `archive_bucket` Bei einer nicht vollständigen Übereinstimmung schlägt die Regel fehl. Ebenso kann der Inhalt interner Ordner oder einzelner Dateien überprüft werden. FileMatch kann auch einzelne Dateien miteinander vergleichen. ``` FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json" ``` **Ableiten von Dateinamen direkt aus Datenrahmen** Sie müssen nicht immer einen Dateipfad angeben. Wenn Sie beispielsweise die Regel im AWS Glue-Datenkatalog (unterstützt von Amazon S3) erstellen, kann es schwierig sein, herauszufinden, welche Ordner die Katalogtabellen verwenden. AWS Glue Data Quality kann die spezifischen Ordner oder Dateien finden, die zum Füllen Ihres Datenrahmens verwendet werden. **Anmerkung** Diese Funktion funktioniert nur, wenn Dateien erfolgreich in das DynamicFrame oder DataFrame eingelesen wurden. ``` FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5" FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1" FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256" FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] ``` Wenn sich die angegebene Prüfsumme von der berechneten unterscheidet, FileMatch werden Sie auf den Unterschied hingewiesen. ![\[Der Screenshot zeigt eine Regel mit dem DQ-Status Regel fehlgeschlagen. FileMatch erklärt den Fehler.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/data-quality-file-match.png) **Optionale dateibasierte Regel-Tags:** Mithilfe von Tags können Sie das Verhalten der Regel steuern. **recentFiles** Dieses Tag begrenzt die Anzahl der verarbeiteten Dateien, indem die neueste Datei zuerst angezeigt wird. ``` FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 ``` **uriRegex** **Anmerkung** Das `uriRegex` Tag ist in AWS Glue 5.0 und höher verfügbar. Dieses Tag filtert Dateien, indem es ein Regex-Muster auf den Dateipfad anwendet. Es werden nur Dateien verarbeitet, deren Pfade dem Muster entsprechen. Sie können auch einen negativen Lookahead verwenden, um Dateien auszuschließen, die einem Muster entsprechen. ``` # Match only files with a .json extension FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "\.json$" # Exclude files ending in .tmp using a negative lookahead FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "(?!.*\.tmp$).*" ``` **Reihenfolge filtern** **Anmerkung** Das `filterOrder` Tag ist in AWS Glue 5.0 und höher verfügbar. Wenn Sie mehrere Filter-Tags wie `recentFiles` und `uriRegex` zusammen verwenden, steuert das `filterOrder` Tag die Reihenfolge, in der sie angewendet werden. Die Standardreihenfolge ist `recentFiles` zuerst, dann`uriRegex`. ``` FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"] ``` **matchFileName** Dieses Tag stellt sicher, dass Dateien keine doppelten Namen aufweisen. Das Standardverhalten lautet „false“. ``` FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true" ``` Es gibt ein paar Überlegungen: 1. In AWS Glue ETL müssen Sie die **EvaluateDataQuality**Transformation unmittelbar nach einer Amazon S3- oder AWS Glue Data Catalog-Transformation haben. ![\[Der Screenshot zeigt eine Regel mit dem DQ-Status Regel fehlgeschlagen. FileMatch erklärt den Fehler.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/data-quality-file-match-transform.png) 1. Diese Regel funktioniert nicht in AWS Glue Interactive Sessions. # FileUniqueness Mit FileUniqueness können Sie sicherstellen, dass die Daten, die Sie von Ihren Datenproduzenten erhalten haben, keine doppelten Dateien enthalten. Folgende Datenstatistiken werden erfasst: 1. Die Anzahl der Dateien, die von der Regel gescannt wurden 1. Das Eindeutigkeitsverhältnis der Dateien ``` Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00 ``` **Doppelte Dateien in einem Ordner finden:** ``` FileUniqueness "s3://bucket/" > 0.5 FileUniqueness "s3://bucket/folder/" = 1 ``` **Ordnernamen direkt von Datenrahmen ableiten, um Duplikate zu erkennen:** Sie müssen nicht immer einen Dateipfad angeben. Wenn Sie beispielsweise die Regel im AWS Glue-Datenkatalog erstellen, kann es schwierig sein, herauszufinden, welche Ordner die Katalogtabellen verwenden. AWS Glue Data Quality kann die spezifischen Ordner oder Dateien finden, die zum Füllen Ihres Datenrahmens verwendet werden. **Anmerkung** Bei der Verwendung von Inferenz können dateibasierte Regeln nur Dateien erkennen, die erfolgreich in das oder gelesen wurden. DynamicFrame DataFrame ``` FileUniqueness > 0.5 ``` **Optionale dateibasierte Regel-Tags:** Mithilfe von Tags können Sie das Verhalten der Regel steuern. **recentFiles** Dieses Tag begrenzt die Anzahl der verarbeiteten Dateien, indem die neueste Datei zuerst angezeigt wird. ``` FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1 ``` **uriRegex** **Anmerkung** Das `uriRegex` Tag ist in AWS Glue 5.0 und höher verfügbar. Dieses Tag filtert Dateien, indem es ein Regex-Muster auf den Dateipfad anwendet. Es werden nur Dateien verarbeitet, deren Pfade dem Muster entsprechen. Sie können auch einen negativen Lookahead verwenden, um Dateien auszuschließen, die einem Muster entsprechen. ``` # Match only files with a .csv extension FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "\.csv$" # Exclude files ending in .tmp using a negative lookahead FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "(?!.*\.tmp$).*" ``` **Reihenfolge filtern** **Anmerkung** Das `filterOrder` Tag ist in AWS Glue 5.0 und höher verfügbar. Wenn Sie mehrere Filter-Tags wie `recentFiles` und `uriRegex` zusammen verwenden, steuert das `filterOrder` Tag die Reihenfolge, in der sie angewendet werden. Die Standardreihenfolge ist `recentFiles` zuerst, dann`uriRegex`. ``` FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"] ``` **matchFileName** Dieses Tag stellt sicher, dass Dateien keine doppelten Namen aufweisen. Das Standardverhalten lautet „false“. ``` FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true" ``` Es gibt ein paar Überlegungen: 1. In AWS Glue ETL müssen Sie die **EvaluateDataQuality**Transformation unmittelbar nach einer Amazon S3- oder AWS Glue Data Catalog-Transformation haben. 1. Diese Regel funktioniert nicht in AWS Glue Interactive Sessions. # FileSize Mit dem FileSize Regeltyp können Sie sicherstellen, dass Dateien bestimmte Dateigrößenkriterien erfüllen. Dies ist für folgende Anwendungsfälle nützlich: 1. Stellen Sie sicher, dass Produzenten keine leeren oder wesentlich kleineren Dateien zur Verarbeitung senden. 1. Stellen Sie sicher, dass Ihre Ziel-Buckets keine kleineren Dateien enthalten, was zu Leistungseinbußen führen kann. FileSize sammelt die folgenden Messwerte: 1. Compliance: Gibt den Prozentsatz der Dateien zurück, die den von Ihnen festgelegten Regelschwellenwert erfüllen 1. Dateianzahl: Die Anzahl der Dateien, die von der Regel gescannt wurden 1. Minimale Dateigröße in Bytes 1. Maximale Datengröße in Bytes ``` Dataset.*.FileSize.Compliance: 1.00, Dataset.*.FileCount: 8.00, Dataset.*.MaximumFileSize: 327413121.00, Dataset.*.MinimumFileSize: 204558920.00 ``` Die Erkennung von Anomalien wird für diese Metriken nicht unterstützt. **Überprüfen der Größe von Dateien** Diese Regel wird erfüllt, wenn file.dat größer als 2 MB ist. ``` FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB ``` Zu den unterstützten Einheiten gehören B (Byte), MB (Megabytes), GB (Gigabytes) und TB (Terabyte). **Überprüfen der Größe von Dateien in Ordnern** ``` FileSize "s3://bucket/" > 5 B FileSize "s3://bucket/" < 2 GB ``` Diese Regel wird erfüllt, wenn 70 % der Dateien in s3://amzn-s3-demo-bucket zwischen 2 GB und 1 TB groß sind. ``` FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7 ``` **Ableiten von Dateinamen direkt aus Datenrahmen** Sie müssen nicht immer einen Dateipfad angeben. Wenn Sie beispielsweise die Regel im Datenkatalog erstellen, kann es schwierig sein, herauszufinden, welche Ordner die Katalogtabellen verwenden. AWS Glue Data Quality kann die spezifischen Ordner oder Dateien finden, die zum Füllen Ihres Datenrahmens verwendet werden. **Anmerkung** Diese Funktion funktioniert nur, wenn Dateien erfolgreich in das Feld DynamicFrame oder DataFrame eingelesen wurden. ``` FileSize < 10 MB with threshold > 0.7 ``` **Optionale dateibasierte Regel-Tags:** Mithilfe von Tags können Sie das Verhalten der Regel steuern. **recentFiles** Dieses Tag begrenzt die Anzahl der verarbeiteten Dateien, indem die neueste Datei zuerst angezeigt wird. ``` FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1 ``` **uriRegex** **Anmerkung** Das `uriRegex` Tag ist in AWS Glue 5.0 und höher verfügbar. Dieses Tag filtert Dateien, indem es ein Regex-Muster auf den Dateipfad anwendet. Es werden nur Dateien verarbeitet, deren Pfade dem Muster entsprechen. Sie können auch einen negativen Lookahead verwenden, um Dateien auszuschließen, die einem Muster entsprechen. ``` # Match only files with a .dat extension FileSize "s3://bucket/" > 5 B with uriRegex = "\.dat$" # Exclude files ending in .tmp using a negative lookahead FileSize "s3://bucket/" > 5 B with uriRegex = "(?!.*\.tmp$).*" ``` **Reihenfolge filtern** **Anmerkung** Das `filterOrder` Tag ist in AWS Glue 5.0 und höher verfügbar. Wenn Sie mehrere Filter-Tags wie `recentFiles` und `uriRegex` zusammen verwenden, steuert das `filterOrder` Tag die Reihenfolge, in der sie angewendet werden. Die Standardreihenfolge ist `recentFiles` zuerst, dann`uriRegex`. ``` FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"] ``` **FailFast** Wenn diese Option auf gesetzt ist`"true"`, gibt die Regel sofort bei der ersten Datei, die die Größenbedingung nicht erfüllt, einen Fehler zurück, anstatt alle Dateien auszuwerten und ein Kompatibilitätsverhältnis zu berechnen. ``` FileSize "s3://bucket/" > 2 MB with failFast = "true" ``` Es gibt ein paar Überlegungen: 1. In AWS Glue ETL muss Evaluate DataQuality Transform unmittelbar nach der Amazon S3- oder Data Catalog-Transformation installiert sein. 1. Diese Regel funktioniert nicht in AWS Glue Interactive Sessions.