",
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"
}
"""
)
)
}
```
Di AWS Glue Data Catalog, Anda dapat dengan mudah mengkonfigurasi opsi ini di antarmuka pengguna seperti yang ditunjukkan di bawah ini.
![\[Tangkapan layar menunjukkan jendela pengaturan aturan komposit di mana Anda dapat memilih konfigurasi evaluasi aturan antara baris dan kolom. Jika Anda memilih Baris, aturan komposit akan berperilaku sebagai aturan tunggal yang mengevaluasi seluruh baris. Jika Anda memilih Kolom, aturan komposit akan mengevaluasi aturan individual di seluruh kumpulan data dan menggabungkan hasilnya.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/composite-rule-settings.png)
Setelah ditetapkan, aturan komposit akan berperilaku sebagai aturan tunggal yang mengevaluasi seluruh baris. Contoh berikut menggambarkan perilaku ini.
```
# 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 |
+------+------+------------------------------------------------------------+---------------------------+
```
Beberapa aturan tidak dapat didukung dalam fitur ini karena hasil keseluruhannya bergantung pada ambang batas atau rasio. Mereka tercantum di bawah ini.
Aturan yang mengandalkan rasio:
+ Kelengkapan
+ DatasetMatch
+ ReferentialIntegrity
+ Keunikan
Aturan tergantung pada ambang batas:
Ketika aturan berikut termasuk dengan ambang batas, mereka tidak didukung. Namun, aturan yang tidak melibatkan `with threshold` tetap didukung.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Ekspresi
Jika tipe aturan tidak menghasilkan respons Boolean, Anda harus memberikan ekspresi sebagai parameter untuk membuat respons Boolean. Misalnya, aturan berikut memeriksa rata-rata (rata-rata) dari semua nilai dalam kolom terhadap ekspresi untuk mengembalikan hasil benar atau salah.
```
Mean "colA" between 80 and 100
```
Beberapa jenis aturan seperti `IsUnique` dan `IsComplete` sudah mengembalikan respons Boolean.
Tabel berikut mencantumkan ekspresi yang dapat Anda gunakan dalam aturan DQDL.
**Ekspresi DQDL yang didukung**
| Ekspresi | Deskripsi | Contoh |
| --- | --- | --- |
| =x | Menyelesaikan true jika respons tipe aturan sama dengan. x | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | x Menyelesaikan ke true jika respons tipe aturan tidak sama dengan. x | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | Menyelesaikan true jika respons tipe aturan lebih besar dari. x | ColumnValues "colA" > 10
|
| < x | Menyelesaikan true jika respons tipe aturan kurang dari. x | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | Menyelesaikan true jika respons tipe aturan lebih besar dari atau sama dengan. x | ColumnValues "colA" >= 10
|
| <= x | Menyelesaikan true jika respons tipe aturan kurang dari atau sama dengan. x | ColumnValues "colA" <= 1000
|
| antara x dan y | Menyelesaikan true jika respons tipe aturan jatuh dalam rentang tertentu (eksklusif). Hanya gunakan jenis ekspresi ini untuk tipe numerik dan tanggal. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| Bukan antara x dan y | Menyelesaikan ke true jika respons tipe aturan tidak termasuk dalam rentang tertentu (inklusif). Anda hanya harus menggunakan tipe ekspresi ini untuk tipe numerik dan tanggal. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| di [a, b, c, ...] | Menyelesaikan true jika respons tipe aturan ada di set yang ditentukan. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| tidak di [a, b, c, ...] | Menyelesaikan true jika respons tipe aturan tidak ada dalam set yang ditentukan. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| pertandingan /ab\$1c/i | Menyelesaikan true jika respons tipe aturan cocok dengan ekspresi reguler. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| tidak cocok /ab\$1c/i | Menyelesaikan true jika respons tipe aturan tidak cocok dengan ekspresi reguler. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | Bekerja hanya dengan jenis ColumnValues aturan untuk membuat ekspresi tanggal. | ColumnValues "load_date" > (now() - 3 days)
|
| matches/in […]/not matches/notdi [...] with threshold | Menentukan persentase nilai yang cocok dengan kondisi aturan. Bekerja hanya denganColumnValues,ColumnDataType, dan jenis CustomSQL aturan. | 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
|
#### Kata kunci untuk NULL, EMPTY dan WHITESPACES\$1ONLY
Jika Anda ingin memvalidasi jika kolom string memiliki nol, kosong atau string dengan hanya spasi putih Anda dapat menggunakan kata kunci berikut:
+ NULL/null — Kata kunci ini menyelesaikan true untuk `null` nilai dalam kolom string.
`ColumnValues "colA" != NULL with threshold > 0.5`akan mengembalikan true jika lebih dari 50% data Anda tidak memiliki nilai nol.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)`akan mengembalikan true untuk semua baris yang memiliki nilai nol atau memiliki panjang> 5. *Perhatikan bahwa ini akan memerlukan penggunaan opsi “compositeRuleEvaluation.method” = “ROW”.*
+ EMPTY/empty - Kata kunci ini menyelesaikan true untuk nilai string kosong (“”) dalam kolom string. Beberapa format data mengubah nol dalam kolom string menjadi string kosong. Kata kunci ini membantu menyaring string kosong dalam data Anda.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])`akan mengembalikan true jika baris kosong, “a” atau “b”. *Perhatikan bahwa ini memerlukan penggunaan opsi “compositeRuleEvaluation.method” = “ROW”.*
+ WHITESPACES\$1ONLY/whitespaces\$1only — Kata kunci ini menyelesaikan true untuk string dengan hanya spasi putih (“”) nilai dalam kolom string.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]`akan mengembalikan true jika baris bukan “a” atau “b” atau hanya spasi putih.
Aturan yang didukung:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
Untuk ekspresi berbasis numerik atau tanggal, jika Anda ingin memvalidasi jika kolom memiliki nol, Anda dapat menggunakan kata kunci berikut.
+ NULL/null — Kata kunci ini menyelesaikan true untuk nilai null dalam kolom string.
`ColumnValues "colA" in [NULL, "2023-01-01"]`akan mengembalikan true jika tanggal di kolom Anda salah satu `2023-01-01` atau null.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)`akan mengembalikan true untuk semua baris yang memiliki nilai nol atau memiliki nilai antara 1 dan 9. *Perhatikan bahwa ini akan memerlukan penggunaan opsi “compositeRuleEvaluation.method” = “ROW”.*
Aturan yang didukung:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Pemfilteran dengan Klausul Where
**catatan**
Di mana Klausul hanya didukung di AWS Glue 4.0.
Anda dapat memfilter data Anda saat membuat aturan. Ini sangat membantu ketika Anda ingin menerapkan aturan bersyarat.
```
where " "
```
Filter harus ditentukan dengan `where` kata kunci, diikuti oleh pernyataan SparkSQL yang valid yang terlampir dalam tanda kutip. `("")`
Jika aturan Anda ingin menambahkan klausa where ke aturan dengan ambang batas, klausa where harus ditentukan sebelum kondisi ambang batas.
```
where "valid SparkSQL statement>" with threshold
```
Dengan sintaks ini Anda dapat menulis aturan seperti berikut ini.
```
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)"
```
Kami akan memvalidasi bahwa pernyataan SparkSQL yang diberikan valid. Jika tidak valid, evaluasi aturan akan gagal dan kami akan melempar a `IllegalArgumentException` dengan format berikut:
```
Rule where "" has provided an invalid where clause :
```
**Di mana perilaku klausa saat identifikasi catatan kesalahan tingkat baris diaktifkan**
Dengan AWS Glue Data Quality, Anda dapat mengidentifikasi catatan spesifik yang gagal. Saat menerapkan klausa where ke aturan yang mendukung hasil tingkat baris, kami akan memberi label pada baris yang disaring oleh klausa where sebagai. `Passed`
Jika Anda lebih suka memberi label secara terpisah pada baris yang difilter sebagai`SKIPPED`, Anda dapat mengatur yang berikut ini `additionalOptions` untuk pekerjaan ETL.
```
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"
}
"""
)
)
}
```
Sebagai contoh, lihat aturan dan kerangka data berikut:
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | Hasil tingkat baris (Default) | Hasil Tingkat Baris (Opsi Dilewati) | Komentar |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | BERLALU | BERLALU | |
| 2 | b | d | BERLALU | DILEWATI | Baris disaring, att1 karena tidak "a" |
| 3 | a | null | FAILED | FAILED | |
| 4 | a | f | BERLALU | BERLALU | |
| 5 | b | null | BERLALU | DILEWATI | Baris disaring, att1 karena tidak "a" |
| 6 | a | f | BERLALU | BERLALU | |
### Konstanta
Di DQDL, Anda dapat menentukan nilai konstan dan mereferensikannya di seluruh skrip Anda. Ini membantu mencegah masalah yang terkait dengan batas ukuran kueri—misalnya, saat bekerja dengan pernyataan SQL besar yang mungkin melebihi batas yang diizinkan. Dengan menetapkan nilai-nilai ini ke Konstanta, Anda dapat menyederhanakan DQDL Anda dan menghindari mencapai batas tersebut.
Contoh berikut menunjukkan bagaimana mendefinisikan dan menggunakan konstanta:
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
Dalam contoh ini, kueri SQL ditugaskan ke konstanta`mySql`, yang kemudian direferensikan dalam aturan menggunakan awalan. `$`
### Label
Label menyediakan cara yang efektif untuk mengatur dan menganalisis hasil kualitas data. Anda dapat menanyakan hasil berdasarkan label tertentu untuk mengidentifikasi aturan yang gagal dalam kategori tertentu, menghitung hasil aturan berdasarkan tim atau domain, dan membuat laporan terfokus untuk pemangku kepentingan yang berbeda.
Misalnya, Anda dapat menerapkan semua aturan yang berkaitan dengan tim keuangan dengan label `"team=finance"` dan membuat laporan khusus untuk menampilkan metrik kualitas khusus untuk tim keuangan. Anda dapat memberi label aturan prioritas tinggi `"criticality=high"` untuk memprioritaskan upaya remediasi. Label dapat ditulis sebagai bagian dari DQDL. Anda dapat menanyakan label sebagai bagian dari hasil aturan, hasil tingkat baris, dan respons API, sehingga memudahkan integrasi dengan alur kerja pemantauan dan pelaporan yang ada.
**catatan**
Label hanya tersedia di AWS Glue ETL dan tidak tersedia dalam Kualitas Data berbasis Katalog Data AWS Glue.
#### Sintaks untuk label DQDL
DQDL mendukung label default dan khusus aturan. Label default didefinisikan pada tingkat set aturan dan secara otomatis berlaku untuk semua aturan dalam kumpulan aturan tersebut. Aturan individual juga dapat memiliki labelnya sendiri, dan karena label diimplementasikan sebagai pasangan nilai kunci, label khusus aturan dapat mengganti label default saat menggunakan kunci yang sama.
Contoh berikut menunjukkan cara menggunakan label default dan khusus aturan:
```
DefaultLabels=["frequency"="monthly"]
Rules = [
// Auto includes the default label ["frequency"="monthly"]
ColumnValues "col" > 21,
// Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
Rule 1 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(Rule 1 AND Rule 2) labels=["foo"="bar]
]
```
##### Kendala label
Label memiliki kendala berikut:
+ Maksimal 10 label per aturan DQDL.
+ Label ditentukan sebagai daftar pasangan kunci-nilai.
+ Kunci label dan nilai label peka huruf besar/kecil.
+ Panjang kunci label maksimum adalah 128 karakter. Kunci label tidak boleh kosong atau nol.
+ Panjang nilai label maksimum adalah 256 karakter. Nilai label mungkin kosong atau nol.
#### Mengambil label DQDL
Anda dapat mengambil label DQDL dari hasil aturan, hasil tingkat baris, dan respons API.
##### Hasil aturan
Label DQDL selalu terlihat dalam hasil aturan. Tidak diperlukan konfigurasi tambahan untuk mengaktifkannya.
##### Hasil tingkat baris
Label DQDL dinonaktifkan secara default dalam hasil tingkat baris tetapi dapat diaktifkan menggunakan in. `AdditionalOptions` `EvaluateDataQuality`
Contoh berikut menunjukkan cara mengaktifkan label dalam hasil tingkat baris:
```
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"
}""")
)
```
Saat diaktifkan, kerangka data hasil tingkat baris menyertakan label untuk setiap aturan di,, dan kolom. `DataQualityRulesPass` `DataQualityRulesFail` `DataQualityRulesSkip`
##### Respon API
Label DQDL selalu terlihat dalam respons API di bawah bidang baru `Labels` di objek. `RuleResults`
Contoh berikut menunjukkan label dalam respons API:
```
{
"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"
}
}
]
}
```
### Aturan dinamis
**catatan**
Aturan Dinamis hanya didukung di AWS Glue ETL dan tidak didukung di AWS Glue Data Catalog.
Anda sekarang dapat membuat aturan dinamis untuk membandingkan metrik saat ini yang dihasilkan oleh aturan Anda dengan nilai historisnya. Perbandingan historis ini diaktifkan dengan menggunakan `last()` operator dalam ekspresi. Misalnya, aturan `RowCount > last()` akan berhasil ketika jumlah baris dalam proses saat ini lebih besar dari jumlah baris sebelumnya terbaru untuk kumpulan data yang sama. `last()`mengambil argumen bilangan asli opsional yang menjelaskan berapa banyak metrik sebelumnya untuk dipertimbangkan; `last(k)` di mana `k >= 1` akan merujuk metrik terakhir`k`.
+ Jika tidak ada titik data yang tersedia, `last(k)` akan mengembalikan nilai default 0.0.
+ Jika kurang dari `k` metrik yang tersedia, `last(k)` akan mengembalikan semua metrik sebelumnya.
Untuk membentuk ekspresi yang valid gunakan`last(k)`, di mana `k > 1` memerlukan fungsi agregasi untuk mengurangi beberapa hasil historis menjadi satu nomor. Misalnya, `RowCount > avg(last(5))` akan memeriksa apakah jumlah baris kumpulan data saat ini benar-benar lebih besar dari rata-rata jumlah lima baris terakhir untuk kumpulan data yang sama. `RowCount > last(5)`akan menghasilkan kesalahan karena jumlah baris kumpulan data saat ini tidak dapat dibandingkan secara bermakna dengan daftar.
Fungsi agregasi yang didukung:
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std`(standar deviasi)
+ `abs`(nilai absolut)
+ `index(last(k), i)`akan memungkinkan untuk memilih nilai terbaru dari yang terakhir`k`. `i` `i`diindeks nol, jadi `index(last(3), 0)` akan mengembalikan titik data terbaru dan `index(last(3), 3)` akan menghasilkan kesalahan karena hanya ada tiga titik data dan kami mencoba untuk mengindeks yang terbaru ke-4.
**Ekspresi sampel**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
Sebagian besar tipe aturan dengan kondisi numerik atau ambang batas mendukung aturan dinamis; lihat tabel yang disediakan, [Analisa dan Aturan](#dqdl-analyzers-table), untuk menentukan apakah aturan dinamis didukung untuk jenis aturan Anda.
**Tidak termasuk statistik dari aturan dinamis**
Terkadang, Anda perlu mengecualikan statistik data dari perhitungan aturan dinamis Anda. Katakanlah Anda melakukan pemuatan data historis dan Anda tidak ingin itu memengaruhi rata-rata Anda. Untuk melakukan ini, buka pekerjaan di AWS Glue ETL dan pilih Tab **Kualitas Data**, lalu pilih **Statistik** dan pilih statistik yang ingin Anda kecualikan. Anda akan dapat melihat grafik tren bersama dengan tabel statistik. Pilih nilai yang ingin Anda kecualikan dan pilih **Kecualikan Statistik**. Sekarang statistik yang dikecualikan tidak akan dimasukkan dalam perhitungan aturan dinamis.
![\[Tangkapan layar menunjukkan opsi untuk mengecualikan atau menyertakan statistik dari menu tarik-turun setelah memilih statistik.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### Analisa
**catatan**
Analyzer tidak didukung di AWS Glue Data Catalog.
Aturan DQDL menggunakan fungsi yang disebut *penganalisis* untuk mengumpulkan informasi tentang data Anda. Informasi ini digunakan oleh ekspresi Boolean aturan untuk menentukan apakah aturan harus berhasil atau gagal. Misalnya, RowCount aturan `RowCount > 5 ` akan menggunakan penganalisis hitungan baris untuk menemukan jumlah baris dalam kumpulan data Anda, dan membandingkan jumlah itu dengan ekspresi `> 5` untuk memeriksa apakah ada lebih dari lima baris dalam kumpulan data saat ini.
Terkadang, alih-alih membuat aturan, kami sarankan untuk membuat penganalisis dan kemudian membuatnya menghasilkan statistik yang dapat digunakan untuk mendeteksi anomali. Untuk contoh seperti itu, Anda dapat membuat penganalisis. Penganalisis berbeda dari aturan dengan cara berikut.
| Karakteristik | Analisa | Aturan |
| --- | --- | --- |
| Bagian dari ruleset | Ya | Ya |
| Menghasilkan statistik | Ya | Ya |
| Menghasilkan pengamatan | Ya | Ya |
| Dapat mengevaluasi dan menegaskan suatu kondisi | Tidak | Ya |
| Anda dapat mengonfigurasi tindakan seperti menghentikan pekerjaan pada kegagalan, melanjutkan pekerjaan pemrosesan | Tidak | Ya |
Analyzer dapat eksis secara independen tanpa aturan, sehingga Anda dapat dengan cepat mengonfigurasinya dan secara progresif membangun aturan kualitas data.
Beberapa jenis aturan dapat dimasukkan ke dalam `Analyzers` blok kumpulan aturan Anda untuk menjalankan aturan yang diperlukan untuk penganalisis dan mengumpulkan informasi tanpa menerapkan pemeriksaan untuk kondisi apa pun. Beberapa penganalisis tidak terkait dengan aturan dan hanya dapat dimasukkan ke dalam `Analyzers` blok. Tabel berikut menunjukkan apakah setiap item didukung sebagai aturan atau penganalisis mandiri, bersama dengan detail tambahan untuk setiap jenis aturan.
**Contoh Ruleset dengan Analyzer**
Ruleset berikut menggunakan:
+ aturan dinamis untuk memeriksa apakah kumpulan data tumbuh di atas rata-rata trailing untuk tiga pekerjaan terakhir
+ `DistinctValuesCount`analyzer untuk mencatat jumlah nilai yang berbeda di kolom dataset `Name`
+ `ColumnLength`analyzer untuk melacak `Name` ukuran minimum dan maksimum dari waktu ke waktu
Hasil metrik penganalisis dapat dilihat di tab Kualitas Data untuk menjalankan pekerjaan Anda.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
AWS Glue Data Quality mendukung analisa berikut.
| Nama penganalisis | Fungsionalitas |
| --- | --- |
| RowCount | Menghitung jumlah baris untuk kumpulan data |
| Completeness | Menghitung persentase kelengkapan kolom |
| Uniqueness | Menghitung persentase keunikan kolom |
| Mean | Menghitung rata-rata kolom numerik |
| Sum | Menghitung jumlah kolom numerik |
| StandardDeviation | Menghitung standar deviasi kolom numerik |
| Entropy | Menghitung entropi kolom numerik |
| DistinctValuesCount | Menghitung jumlah nilai yang berbeda dalam kolom |
| UniqueValueRatio | Menghitung rasio nilai unik dalam kolom |
| ColumnCount | Menghitung jumlah kolom dalam kumpulan data |
| ColumnLength | Menghitung panjang kolom |
| ColumnValues | Menghitung minimum, maksimum untuk kolom numerik. Menghitung Minimum ColumnLength dan Maksimum ColumnLength untuk kolom non-numerik |
| ColumnCorrelation | Menghitung korelasi kolom untuk kolom yang diberikan |
| CustomSql | Menghitung statistik yang dikembalikan oleh CustomSQL |
| AllStatistics | Menghitung statistik berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/dqdl.html) |
### Komentar
Anda dapat menggunakan karakter '\$1' untuk menambahkan komentar ke dokumen DQDL Anda. Apa pun setelah karakter '\$1' dan sampai akhir baris diabaikan oleh DQDL.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# Referensi tipe aturan DQDL
Bagian ini memberikan referensi untuk setiap jenis aturan yang didukung AWS Glue Data Quality.
**catatan**
DQDL saat ini tidak mendukung data kolom bersarang atau tipe daftar.
Nilai kurung pada tabel di bawah ini akan diganti dengan informasi yang disediakan dalam argumen aturan.
Aturan biasanya memerlukan argumen tambahan untuk ekspresi.
| Jenis aturan | Deskripsi | Pendapat | Metrik yang Dilaporkan | Didukung sebagai Aturan? | Didukung sebagai Analyzer? | Mengembalikan Hasil tingkat baris? | Dukungan aturan dinamis? | Menghasilkan Pengamatan | Mendukung Sintaks Klausul Dimana? |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | Memeriksa apakah dua kumpulan data cocok dengan membandingkan metrik ringkasan seperti jumlah total penjualan. Berguna bagi lembaga keuangan untuk membandingkan jika semua data dicerna dari sistem sumber. | Satu atau lebih agregasi | Ketika nama kolom agregasi pertama dan kedua cocok: `Column.[Column].AggregateMatch` Ketika nama kolom agregasi pertama dan kedua berbeda: `Column.[Column1,Column2].AggregateMatch` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| AllStatistics | Penganalisis mandiri untuk mengumpulkan beberapa metrik untuk kolom yang disediakan dalam kumpulan data. | Nama kolom tunggal | Untuk kolom dari semua jenis: `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Metrik tambahan untuk kolom bernilai string: `ColumnLength metrics` Metrik tambahan untuk kolom bernilai numerik: `ColumnValues metrics` | Tidak | Ya | Tidak | Tidak | Tidak | Tidak |
| ColumnCorrelation | Memeriksa seberapa baik dua kolom berkorelasi. | Tepat dua nama kolom | Multicolumn.[Column1,Column2].ColumnCorrelation | Ya | Ya | Tidak | Ya | Tidak | Ya |
| ColumnCount | Memeriksa apakah ada kolom yang dijatuhkan. | Tidak ada | Dataset.\$1.ColumnCount | Ya | Ya | Tidak | Ya | Ya | Tidak |
| ColumnDataType | Memeriksa apakah kolom sesuai dengan tipe data. | Tepat satu nama kolom | Column.[Column].ColumnDataType.Compliance | Ya | Tidak | Tidak | Ya, dalam ekspresi ambang batas tingkat baris | Tidak | Ya |
| ColumnExists | Memeriksa apakah kolom ada dalam kumpulan data. Hal ini memungkinkan pelanggan membangun platform data layanan mandiri untuk memastikan kolom tertentu tersedia. | Tepat satu nama kolom | N/A | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| ColumnLength | Memeriksa apakah panjang data konsisten. | Tepat satu nama kolom | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Metrik tambahan saat ambang tingkat baris disediakan: `Column.[Column].ColumnValues.Compliance` | Ya | Ya | Ya, ketika ambang batas tingkat baris disediakan | Tidak | Ya. Hanya menghasilkan pengamatan dengan menganalisis panjang Minimum dan Maksimum | Ya |
| ColumnNamesMatchPattern | Memeriksa apakah nama kolom cocok dengan pola yang ditentukan. Berguna bagi tim tata kelola untuk menegakkan konsistensi nama kolom. | Sebuah regex untuk nama kolom | Dataset.\$1.ColumnNamesPatternMatchRatio | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| ColumnValues | Memeriksa apakah data konsisten per nilai yang ditentukan. Aturan ini mendukung ekspresi reguler. | Tepat satu nama kolom | `Column.[Column].Maximum` `Column.[Column].Minimum` Metrik tambahan saat ambang tingkat baris disediakan: `Column.[Column].ColumnValues.Compliance` | Ya | Ya | Ya, ketika ambang batas tingkat baris disediakan | Tidak | Ya. Hanya menghasilkan pengamatan dengan menganalisis nilai Minimum dan Maksimum | Ya |
| Kelengkapan | Memeriksa data kosong atau NULLs dalam data. | Tepat satu nama kolom | `Column.[Column].Completeness` | Ya | Ya | Ya | Ya | Ya | Ya |
| CustomSql | Pelanggan dapat menerapkan hampir semua jenis pemeriksaan kualitas data di SQL. | Pernyataan SQL (Opsional) Ambang batas tingkat baris | `Dataset.*.CustomSQL` Metrik tambahan saat ambang tingkat baris disediakan: `Dataset.*.CustomSQL.Compliance` | Ya | Tidak | Ya, ketika ambang batas tingkat baris disediakan | Ya | Tidak | Tidak |
| DataFreshness | Memeriksa apakah data masih segar. | Tepat satu nama kolom | Column.[Column].DataFreshness.Compliance | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| DatasetMatch | Membandingkan dua kumpulan data dan mengidentifikasi jika mereka sinkron. | Nama dataset referensi Pemetaan kolom (Opsional) Kolom untuk memeriksa kecocokan | Dataset.[ReferenceDatasetAlias].DatasetMatch | Ya | Tidak | Ya | Ya | Tidak | Tidak |
| DistinctValuesCount | Memeriksa nilai duplikat. | Tepat satu nama kolom | Column.[Column].DistinctValuesCount | Ya | Ya | Ya | Ya | Ya | Ya |
| DetectAnomalies | Memeriksa anomali dalam metrik yang dilaporkan tipe aturan lain. | Jenis aturan | Metrik yang dilaporkan oleh argumen tipe aturan | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| Entropi | Memeriksa entropi data. | Tepat satu nama kolom | Column.[Column].Entropy | Ya | Ya | Tidak | Ya | Tidak | Ya |
| IsComplete | Memeriksa apakah 100% data selesai. | Tepat satu nama kolom | Column.[Column].Completeness | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| IsPrimaryKey | Memeriksa apakah kolom adalah kunci utama (bukan NULL dan unik). | Tepat satu nama kolom | Untuk kolom tunggal: `Column.[Column].Uniqueness` Untuk beberapa kolom: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| IsUnique | Memeriksa apakah 100% data unik. | Tepat satu nama kolom | Column.[Column].Uniqueness | Ya | Tidak | Ya | Tidak | Tidak | Ya |
| Berarti | Memeriksa apakah mean cocok dengan ambang batas yang ditetapkan. | Tepat satu nama kolom | Column.[Column].Mean | Ya | Ya | Ya | Ya | Tidak | Ya |
| ReferentialIntegrity | Memeriksa apakah dua kumpulan data memiliki integritas referensial. | Satu atau beberapa nama kolom dari dataset Satu atau beberapa nama kolom dari dataset referensi | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Ya | Tidak | Ya | Ya | Tidak | Tidak |
| RowCount | Memeriksa apakah jumlah catatan cocok dengan ambang batas. | Tidak ada | Dataset.\$1.RowCount | Ya | Ya | Tidak | Ya | Ya | Ya |
| RowCountMatch | Memeriksa apakah jumlah rekaman antara dua kumpulan data cocok. | Alias dataset referensi | Dataset.[ReferenceDatasetAlias].RowCountMatch | Ya | Tidak | Tidak | Ya | Tidak | Tidak |
| StandardDeviation | Memeriksa apakah standar deviasi cocok dengan ambang batas. | Tepat satu nama kolom | Column.[Column].StandardDeviation | Ya | Ya | Ya | Ya | Tidak | Ya |
| SchemaMatch | Memeriksa apakah skema antara dua kumpulan data cocok. | Alias dataset referensi | Dataset.[ReferenceDatasetAlias].SchemaMatch | Ya | Tidak | Tidak | Ya | Tidak | Tidak |
| Jumlah | Memeriksa apakah jumlah cocok dengan ambang batas yang ditetapkan. | Tepat satu nama kolom | Column.[Column].Sum | Ya | Ya | Tidak | Ya | Tidak | Ya |
| Keunikan | Memeriksa apakah keunikan kumpulan data cocok dengan ambang batas. | Tepat satu nama kolom | Column.[Column].Uniqueness | Ya | Ya | Ya | Ya | Tidak | Ya |
| UniqueValueRatio | Memeriksa apakah ransum nilai unik cocok dengan ambang batas. | Tepat satu nama kolom | Column.[Column].UniqueValueRatio | Ya | Ya | Ya | Ya | Tidak | Ya |
| FileFreshness | Memeriksa apakah file di Amazon S3 masih segar. | Jalur file atau Folder dan ambang batas. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| FileMatch | Memeriksa apakah isi file cocok dengan checksum atau dengan file lain. Aturan ini menggunakan checksum untuk memvalidasi jika dua file sama. | Sumber File atau jalur Folder dan file Target atau jalur folder. | Tidak ada statistik yang dihasilkan. | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| FileSize | Memeriksa apakah ukuran file cocok dengan kondisi tertentu. | Jalur dan ambang batas file atau folder. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
| FileUniqueness | Memeriksa apakah file unik menggunakan checksum. | Jalur dan ambang batas file atau folder. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Ya | Tidak | Tidak | Tidak | Tidak | Tidak |
**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)
+ [Kelengkapan](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)
+ [Entropi](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Berarti](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)
+ [Jumlah](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Keunikan](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
Memeriksa rasio agregasi dua kolom terhadap ekspresi yang diberikan. Ruletype ini bekerja pada beberapa dataset. Dua agregasi kolom dievaluasi dan rasio dihasilkan dengan membagi hasil agregasi kolom pertama dengan hasil agregasi kolom kedua. Rasio diperiksa terhadap ekspresi yang disediakan untuk menghasilkan respons boolean.
**Sintaksis**
**Agregasi kolom**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION — Operasi** yang digunakan untuk agregasi. Saat ini, `sum` dan `avg` didukung.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **OPTIONAL\$1REFERENCE\$1ALIAS** - Parameter ini perlu disediakan jika kolom berasal dari kumpulan data referensi dan bukan kumpulan data utama. Jika Anda menggunakan aturan ini di Katalog Data AWS Glue, alias referensi Anda harus mengikuti format ". .
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **COL\$1NAME** — Nama kolom untuk agregat.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Contoh: Rata-rata**
```
"avg(rating)"
```
**Contoh: Jumlah**
```
"sum(amount)"
```
**Contoh: Rata-rata kolom dalam dataset referensi**
```
"avg(reference.rating)"
```
**Aturan**
```
AggregateMatch
```
+ **AGG\$1EXP\$11** - Agregasi kolom pertama.
Jenis kolom yang didukung: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **AGG\$1EXP\$12** - Agregasi kolom kedua.
Jenis kolom yang didukung: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Pencocokan Agregat menggunakan jumlah**
Contoh aturan berikut memeriksa apakah jumlah nilai dalam `amount` kolom persis sama dengan jumlah nilai dalam `total_amount` kolom.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**Contoh: Pencocokan Agregat menggunakan rata-rata**
Contoh aturan berikut memeriksa apakah rata-rata nilai dalam `ratings` kolom sama dengan setidaknya 90% dari rata-rata nilai dalam `ratings` kolom dalam `reference` dataset. Dataset referensi disediakan sebagai sumber data tambahan dalam pengalaman ETL atau Katalog Data.
Di AWS Glue ETL, Anda dapat menggunakan:
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
Dalam Katalog Data AWS Glue, Anda dapat menggunakan:
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Perilaku nol**
`AggregateMatch`Aturan akan mengabaikan baris dengan nilai NULL dalam perhitungan metode agregasi (jumlah/mean). Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Rata-rata kolom `units` adalah (0 \$1 20 \$1 40)/3 = 20. Baris 101 dan 103 tidak dipertimbangkan dalam perhitungan ini.
# ColumnCorrelation
Memeriksa *korelasi* antara dua kolom terhadap ekspresi yang diberikan. AWS Glue Data Quality menggunakan koefisien korelasi Pearson untuk mengukur korelasi linier antara dua kolom. Hasilnya adalah angka antara -1 dan 1 yang mengukur kekuatan dan arah hubungan.
**Sintaksis**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME** — Nama kolom pertama yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **COL\$12\$1NAME** — Nama kolom kedua yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Korelasi kolom**
Contoh aturan berikut memeriksa apakah koefisien korelasi antara kolom `height` dan `weight` memiliki korelasi positif yang kuat (nilai koefisien lebih besar dari 0,8).
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**Contoh aturan dinamis**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**Perilaku nol**
`ColumnCorrelation`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan korelasi. Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Baris 101 dan 103 akan diabaikan, dan `ColumnCorrelation` akan menjadi 1.0.
# ColumnCount
Memeriksa jumlah kolom dari dataset primer terhadap ekspresi yang diberikan. Dalam ekspresi, Anda dapat menentukan jumlah kolom atau rentang kolom menggunakan operator seperti `>` dan`<`.
**Sintaksis**
```
ColumnCount
```
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Pemeriksaan numerik hitungan kolom**
Contoh aturan berikut memeriksa apakah jumlah kolom berada dalam rentang tertentu.
```
ColumnCount between 10 and 20
```
**Contoh aturan dinamis**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
Memeriksa apakah nilai dalam kolom tertentu dapat dilemparkan di Apache Spark ke jenis yang disediakan. Menerima `with threshold` ekspresi untuk memeriksa subset nilai di kolom.
**Sintaksis**
```
ColumnDataType =
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
Jenis kolom yang didukung: Jenis string
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **EXPECTED\$1TYPE** — Jenis nilai yang diharapkan di kolom.
Nilai yang didukung: Boolean, Date, Timestamp, Integer, Double, Float, Long
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **EKSPRESI** - Ekspresi opsional untuk menentukan persentase nilai yang harus dari tipe yang diharapkan.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Contoh: Kolom tipe data bilangan bulat sebagai string**
Contoh aturan berikut memeriksa apakah nilai-nilai dalam kolom yang diberikan, yang bertipe string, dapat dilemparkan sebagai bilangan bulat.
```
ColumnDataType "colA" = "INTEGER"
```
**Contoh: Kolom tipe data bilangan bulat sebagai string memeriksa subset dari nilai**
Contoh aturan berikut memeriksa apakah lebih dari 90% nilai dalam kolom yang diberikan, yang bertipe string, dapat dilemparkan sebagai bilangan bulat.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Memeriksa apakah kolom ada.
**Sintaksis**
```
ColumnExists
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh: Kolom ada**
Contoh aturan berikut memeriksa apakah kolom bernama `Middle_Name` ada.
```
ColumnExists "Middle_Name"
```
# ColumnLength
Memeriksa apakah panjang setiap baris dalam kolom sesuai dengan ekspresi yang diberikan.
**Sintaksis**
```
ColumnLength
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: String
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Panjang baris kolom**
Contoh aturan berikut memeriksa apakah nilai di setiap baris dalam kolom bernama `Postal_Code` adalah 5 karakter panjang.
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**Perilaku nol**
`ColumnLength`Aturan memperlakukan `NULL` s sebagai 0 string panjang. Untuk satu `NULL` baris:
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
Contoh aturan majemuk berikut menyediakan cara untuk secara eksplisit gagal `NULL` nilai:
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
Memeriksa apakah nama semua kolom dalam kumpulan data utama cocok dengan ekspresi reguler yang diberikan.
**Sintaksis**
```
ColumnNamesMatchPattern
```
+ **POLA** — Pola yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
**Contoh: Pola pencocokan nama kolom**
Contoh aturan berikut memeriksa apakah semua kolom dimulai dengan awalan “aws\$1”
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Menjalankan ekspresi terhadap nilai-nilai dalam kolom.
**Sintaksis**
```
ColumnValues
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Nilai yang diizinkan**
Contoh aturan berikut memeriksa apakah setiap nilai dalam kolom yang ditentukan berada dalam satu set nilai yang diizinkan (termasuk nol, kosong, dan string dengan hanya spasi putih).
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**Contoh: Ekspresi reguler**
Contoh aturan berikut memeriksa nilai-nilai dalam kolom terhadap ekspresi reguler.
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**Contoh: Nilai tanggal**
Contoh aturan berikut memeriksa nilai-nilai dalam kolom tanggal terhadap ekspresi tanggal.
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**Contoh: Nilai numerik**
Contoh aturan berikut memeriksa apakah nilai kolom cocok dengan kendala numerik tertentu.
```
ColumnValues "Customer_ID" between 1 and 2000
```
**Perilaku nol**
Untuk semua `ColumnValues` aturan (selain `!=` dan`NOT IN`), `NULL` baris akan gagal aturan. Jika aturan gagal karena nilai nol, alasan kegagalan akan menampilkan yang berikut:
```
Value: NULL does not meet the constraint requirement!
```
Contoh aturan majemuk berikut menyediakan cara untuk secara eksplisit mengizinkan nilai: `NULL`
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
ColumnValues Aturan yang dinegasikan menggunakan `not in` sintaks `!=` dan akan diteruskan untuk `NULL` baris. Contoh:
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
Contoh berikut memberikan cara untuk secara eksplisit gagal nilai `NULL`
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# Kelengkapan
Memeriksa persentase nilai lengkap (non-null) dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
Completeness
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Persentase nilai nol**
Contoh aturan berikut memeriksa apakah lebih dari 95 persen nilai dalam kolom selesai.
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**Contoh aturan dinamis**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Perilaku nol**
Catatan tentang Format Data CSV: Baris kosong pada kolom CSV dapat menampilkan beberapa perilaku.
+ Jika kolom `String` bertipe, baris kosong akan dikenali sebagai string kosong dan tidak akan gagal `Completeness` aturannya.
+ Jika kolom adalah tipe data lain seperti`Int`, baris kosong akan dikenali sebagai `NULL` dan akan gagal `Completeness` aturan.
# CustomSQL
Jenis aturan ini telah diperluas untuk mendukung dua kasus penggunaan:
+ Jalankan pernyataan SQL kustom terhadap dataset dan periksa nilai kembali terhadap ekspresi yang diberikan.
+ Jalankan pernyataan SQL kustom di mana Anda menentukan nama kolom dalam pernyataan SELECT Anda yang Anda bandingkan dengan beberapa kondisi untuk mendapatkan hasil tingkat baris.
**Sintaksis**
```
CustomSql
```
+ **SQL\$1STATEMENT — Pernyataan** SQL yang mengembalikan nilai numerik tunggal, dikelilingi oleh tanda kutip ganda.
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Kustom SQL untuk mengambil hasil aturan keseluruhan**
Aturan contoh ini menggunakan pernyataan SQL untuk mengambil jumlah catatan untuk kumpulan data. Aturan kemudian memeriksa bahwa jumlah rekor adalah antara 10 dan 20.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**Contoh: SQL khusus untuk mengambil hasil tingkat baris**
Aturan contoh ini menggunakan pernyataan SQL di mana Anda menentukan nama kolom dalam pernyataan SELECT Anda yang Anda bandingkan dengan beberapa kondisi untuk mendapatkan hasil tingkat baris. Ekspresi kondisi ambang batas mendefinisikan ambang batas berapa banyak catatan yang harus gagal agar seluruh aturan gagal. Perhatikan bahwa aturan mungkin tidak mengandung kondisi dan kata kunci bersama-sama.
```
CustomSql "select Name from primary where Age > 18"
```
atau
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**penting**
`primary`Alias singkatan dari nama kumpulan data yang ingin Anda evaluasi. Saat Anda bekerja dengan pekerjaan ETL visual di konsol, `primary` selalu mewakili `DynamicFrame` diteruskan ke `EvaluateDataQuality.apply()` transformasi. Bila Anda menggunakan AWS Glue Data Catalog untuk menjalankan tugas kualitas data terhadap tabel, `primary` mewakili tabel.
Jika Anda berada di Katalog AWS Glue Data, Anda juga dapat menggunakan nama tabel yang sebenarnya:
```
CustomSql "select count(*) from database.table" between 10 and 20
```
Anda juga dapat bergabung dengan beberapa tabel untuk membandingkan elemen data yang berbeda:
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
Di AWS Glue ETL, CustomSQL dapat mengidentifikasi catatan yang gagal dalam pemeriksaan kualitas data. Agar ini berfungsi, Anda perlu mengembalikan catatan yang merupakan bagian dari tabel utama tempat Anda mengevaluasi kualitas data. Catatan yang dikembalikan sebagai bagian dari kueri dianggap berhasil dan catatan yang tidak dikembalikan dianggap gagal. Ini berfungsi dengan menggabungkan hasil kueri CustomSQL Anda dengan kumpulan data asli. Mungkin ada implikasi kinerja berdasarkan kompleksitas kueri SQL Anda.
Untuk melakukannya:
+ Anda harus memilih setidaknya 1 kolom dari tabel utama Anda.
+ `select count(*) from primary`adalah kueri yang valid untuk aturan DQ CUSTOMSQL KESELURUHAN tetapi tidak untuk SQL Kustom Tingkat Baris.
+ Aturan ini akan menimbulkan kesalahan selama evaluasi: `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.`
+ Dalam kueri SQL Anda, pilih `Kunci Utama` dari tabel Anda atau pilih satu set kolom yang membentuk kunci komposit. Tidak melakukannya dapat mengakibatkan hasil yang tidak konsisten karena pencocokan baris duplikat dan kinerja yang menurun.
+ Pilih kunci HANYA dari tabel utama Anda dan bukan dari tabel referensi Anda.
Aturan berikut akan memastikan bahwa catatan dengan usia < 100 diidentifikasi sebagai berhasil dan catatan yang di atas ditandai sebagai gagal.
```
CustomSql "select id from primary where age < 100"
```
Aturan CustomSQL ini akan berlalu ketika 50% dari catatan memiliki usia> 10 dan juga akan mengidentifikasi catatan yang gagal. Catatan yang dikembalikan oleh CustomSQL ini akan dianggap lulus sementara yang tidak dikembalikan akan dianggap gagal.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
Catatan: Aturan CustomSQL akan gagal jika Anda mengembalikan catatan yang tidak tersedia di kumpulan data.
# DataFreshness
Memeriksa kesegaran data dalam kolom dengan mengevaluasi perbedaan antara waktu saat ini dan nilai kolom tanggal. Anda dapat menentukan ekspresi berbasis waktu untuk jenis aturan ini untuk memastikan bahwa nilai kolom up to date.
**Sintaksis**
```
DataFreshness
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Tanggal
+ **EKSPRESI — Ekspresi** numerik dalam jam atau hari. Anda harus menentukan satuan waktu dalam ekspresi Anda.
**Contoh: Kesegaran data**
Contoh aturan berikut memeriksa kesegaran data.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Perilaku nol**
`DataFreshness`Aturan akan gagal untuk baris dengan `NULL` nilai. Jika aturan gagal karena nilai nol, alasan kegagalan akan menampilkan yang berikut:
```
80.00 % of rows passed the threshold
```
di mana 20% dari baris yang gagal termasuk baris dengan`NULL`.
Contoh aturan majemuk berikut menyediakan cara untuk secara eksplisit mengizinkan nilai: `NULL`
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Kesegaran Data untuk objek Amazon S3**
Terkadang Anda perlu memvalidasi kesegaran data berdasarkan waktu pembuatan file Amazon S3. Untuk melakukan ini, Anda dapat menggunakan kode berikut untuk mendapatkan stempel waktu dan menambahkannya ke kerangka data Anda, dan kemudian menerapkan pemeriksaan Kesegaran Data.
```
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
Memeriksa apakah data dalam kumpulan data utama cocok dengan data dalam kumpulan data referensi. Kedua kumpulan data digabungkan menggunakan pemetaan kolom kunci yang disediakan. Pemetaan kolom tambahan dapat disediakan jika Anda ingin memeriksa kesetaraan data hanya di kolom tersebut. Perhatikan bahwa **DataSetMatch**agar berfungsi, kunci gabungan Anda harus unik dan tidak boleh NULL (harus menjadi kunci utama). Jika Anda tidak memenuhi kondisi ini, Anda akan mendapatkan pesan kesalahan, “Peta kunci yang disediakan tidak cocok untuk bingkai data yang diberikan”. Dalam kasus di mana Anda tidak dapat memiliki kunci gabungan yang unik, pertimbangkan untuk menggunakan tipe aturan lain seperti **AggregateMatch**untuk mencocokkan data ringkasan.
**Sintaksis**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS — Alias** dari dataset referensi yang Anda gunakan untuk membandingkan data dari kumpulan data utama.
+ **KEY\$1COLUMN\$1MAPPINGS** - Daftar nama kolom yang dipisahkan koma yang membentuk kunci dalam kumpulan data. Jika nama kolom tidak sama di kedua kumpulan data, Anda harus memisahkannya dengan `->`
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS** - Anda dapat menyediakan parameter ini jika Anda ingin memeriksa data yang cocok hanya di kolom tertentu. Ini menggunakan sintaks yang sama dengan pemetaan kolom kunci. Jika parameter ini tidak disediakan, kami akan mencocokkan data di semua kolom yang tersisa. Kolom non-kunci yang tersisa harus memiliki nama yang sama di kedua kumpulan data.
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Cocokkan set dataset menggunakan kolom ID**
Aturan contoh berikut memeriksa bahwa lebih dari 90% kumpulan data utama cocok dengan kumpulan data referensi, menggunakan kolom “ID” untuk menggabungkan dua kumpulan data. Ini membandingkan semua kolom dalam kasus ini.
```
DatasetMatch "reference" "ID" >= 0.9
```
**Contoh: Cocokkan set dataset menggunakan beberapa kolom kunci**
Dalam contoh berikut, dataset primer dan dataset referensi memiliki nama yang berbeda untuk kolom kunci. `ID_1`dan `ID_2` bersama-sama membentuk kunci komposit dalam dataset primer. `ID_ref1`dan `ID_ref2` bersama-sama membentuk kunci komposit dalam dataset referensi. Dalam skenario ini, Anda dapat menggunakan sintaks khusus untuk menyediakan nama kolom.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**Contoh: Cocokkan kumpulan data set menggunakan beberapa kolom kunci dan periksa apakah kolom tertentu cocok**
Contoh ini dibangun di atas contoh sebelumnya. Kami ingin memeriksa bahwa hanya kolom yang berisi jumlah yang cocok. Kolom ini dinamai `Amount1` dalam kumpulan data utama dan `Amount2` dalam kumpulan data referensi. Anda menginginkan kecocokan yang tepat.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
Memeriksa jumlah nilai yang berbeda dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
DistinctValuesCount
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Jumlah nilai kolom yang berbeda**
Contoh aturan berikut memeriksa bahwa kolom bernama `State` berisi lebih dari 3 nilai yang berbeda.
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# Entropi
Memeriksa apakah nilai *entropi* kolom cocok dengan ekspresi yang diberikan. Entropi mengukur tingkat informasi yang terkandung dalam pesan. Mengingat distribusi probabilitas atas nilai dalam kolom, entropi menjelaskan berapa banyak bit yang diperlukan untuk mengidentifikasi nilai.
**Sintaksis**
```
Entropy
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Entropi kolom**
Contoh aturan berikut memeriksa bahwa kolom bernama `Feedback` memiliki nilai entropi lebih besar dari satu.
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
Memeriksa apakah semua nilai dalam kolom selesai (non-null).
**Sintaksis**
```
IsComplete
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh: Nilai nol**
Contoh berikut memeriksa apakah semua nilai dalam kolom bernama `email` non-null.
```
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"
```
**Perilaku nol**
Catatan tentang Format Data CSV: Baris kosong pada kolom CSV dapat menampilkan beberapa perilaku.
+ Jika kolom `String` bertipe, baris kosong akan dikenali sebagai string kosong dan tidak akan gagal `Completeness` aturannya.
+ Jika kolom adalah tipe data lain seperti`Int`, baris kosong akan dikenali sebagai `NULL` dan akan gagal `Completeness` aturan.
# IsPrimaryKey
Memeriksa apakah kolom berisi kunci utama. Kolom berisi kunci primer jika semua nilai dalam kolom unik dan lengkap (non-null). Anda juga dapat memeriksa kunci utama dengan beberapa kolom.
**Sintaksis**
```
IsPrimaryKey
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh: Kunci utama**
Contoh aturan berikut memeriksa apakah kolom bernama `Customer_ID` berisi kunci utama.
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**Contoh: Kunci primer dengan beberapa kolom. Salah satu contoh berikut ini valid.**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
Memeriksa apakah semua nilai dalam kolom unik, dan mengembalikan nilai Boolean.
**Sintaksis**
```
IsUnique
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
**Contoh**
Contoh aturan berikut memeriksa apakah semua nilai dalam kolom bernama `email` unik.
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
Contoh aturan berikut memeriksa beberapa kolom.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Berarti
Memeriksa apakah mean (rata-rata) dari semua nilai dalam kolom cocok dengan ekspresi yang diberikan.
**Sintaksis**
```
Mean
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Nilai rata-rata**
Contoh aturan berikut memeriksa apakah rata-rata semua nilai dalam kolom melebihi ambang batas.
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**Perilaku nol**
`Mean`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan mean. Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Rata-rata kolom `units` adalah (0 \$1 20 \$1 40)/3 = 20. Baris 101 dan 103 tidak dipertimbangkan dalam perhitungan ini.
# ReferentialIntegrity
Memeriksa sejauh mana nilai dari satu set kolom dalam dataset primer adalah bagian dari nilai-nilai dari satu set kolom dalam dataset referensi.
**Sintaksis**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS** — Daftar nama kolom yang dipisahkan koma dalam kumpulan data utama.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ **REFERENCE\$1DATASET\$1COLS** — Parameter ini berisi dua bagian yang dipisahkan oleh titik. Bagian pertama adalah alias dari dataset referensi. Bagian kedua adalah daftar nama kolom yang dipisahkan koma dalam kumpulan data referensi yang terlampir dalam tanda kurung gigi.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Periksa integritas referensial kolom kode pos**
Contoh aturan berikut memeriksa bahwa lebih dari 90% dari nilai-nilai dalam `zipcode` kolom dalam dataset utama, hadir di `zipcode` kolom dalam `reference` dataset.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**Contoh: Periksa integritas referensial kolom kota dan negara bagian**
Dalam contoh berikut, kolom yang berisi informasi kota dan negara bagian ada di kumpulan data utama dan kumpulan data referensi. Nama-nama kolom berbeda di kedua kumpulan data. Aturan memeriksa apakah himpunan nilai kolom dalam dataset primer persis sama dengan himpunan nilai kolom dalam dataset referensi.
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**Contoh aturan dinamis**
+ `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
Memeriksa jumlah baris dataset terhadap ekspresi yang diberikan. Dalam ekspresi, Anda dapat menentukan jumlah baris atau rentang baris menggunakan operator seperti `>` dan`<`.
**Sintaksis**
```
RowCount
```
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Cek numerik hitungan baris**
Contoh aturan berikut memeriksa apakah jumlah baris berada dalam rentang tertentu.
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
Memeriksa rasio jumlah baris dari kumpulan data utama dan jumlah baris dari kumpulan data referensi terhadap ekspresi yang diberikan.
**Sintaksis**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS — Alias** dari dataset referensi yang digunakan untuk membandingkan jumlah baris.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Pemeriksaan jumlah baris terhadap kumpulan data referensi**
Contoh aturan berikut memeriksa apakah jumlah baris dari dataset primer setidaknya 90% dari jumlah baris dari dataset referensi.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
Memeriksa standar deviasi dari semua nilai dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
StandardDeviation
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Standar deviasi**
Contoh aturan berikut memeriksa apakah standar deviasi nilai dalam kolom bernama `colA` kurang dari nilai yang ditentukan.
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Perilaku nol**
`StandardDeviation`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan standar deviasi. Contoh:
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
Standar deviasi kolom tidak `units1` akan mempertimbangkan baris 101 dan 103 dan hasilnya menjadi 16,33. Standar deviasi untuk kolom `units2` akan menghasilkan 16.
# Jumlah
Memeriksa jumlah semua nilai dalam kolom terhadap ekspresi yang diberikan.
**Sintaksis**
```
Sum
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Jumlah**
Contoh aturan berikut memeriksa apakah jumlah semua nilai dalam kolom melebihi ambang batas yang diberikan.
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Perilaku nol**
`Sum`Aturan akan mengabaikan baris dengan `NULL` nilai dalam perhitungan jumlah. Contoh:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Jumlah kolom tidak `units` akan mempertimbangkan baris 101 dan 103 dan hasilnya menjadi (0 \$1 20 \$1 40) = 60.
# SchemaMatch
Memeriksa apakah skema kumpulan data utama cocok dengan skema kumpulan data referensi. Pemeriksaan skema dilakukan kolom demi kolom. Skema dua kolom cocok jika nama identik dan jenisnya identik. Urutan kolom tidak masalah.
**Sintaksis**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS — Alias** dari dataset referensi yang digunakan untuk membandingkan skema.
**Jenis kolom yang didukung**: Byte, Desimal, Ganda, Float, Integer, Panjang, Pendek
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: SchemaMatch**
Contoh aturan berikut memeriksa apakah skema dataset primer sama persis dengan skema dataset referensi.
```
SchemaMatch "reference" = 1.0
```
# Keunikan
Memeriksa persentase nilai unik dalam kolom terhadap ekspresi yang diberikan. Nilai unik terjadi tepat sekali.
**Sintaksis**
```
Uniqueness
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh**
Contoh aturan berikut memeriksa apakah persentase nilai unik dalam kolom cocok dengan kriteria numerik tertentu.
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
Contoh aturan berikut memeriksa beberapa kolom.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**Contoh aturan dinamis**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
Memeriksa *rasio nilai unik* kolom terhadap ekspresi yang diberikan. Rasio nilai unik adalah pecahan dari nilai unik dibagi dengan jumlah semua nilai yang berbeda dalam kolom. Nilai unik terjadi tepat satu kali, sedangkan nilai yang berbeda terjadi *setidaknya* sekali.
Misalnya, himpunan `[a, a, b]` berisi satu nilai unik (`b`) dan dua nilai berbeda (`a`dan`b`). Jadi rasio nilai unik dari himpunan adalah ½ = 0,5.
**Sintaksis**
```
UniqueValueRatio
```
+ **COL\$1NAME** — Nama kolom yang ingin Anda evaluasi terhadap aturan kualitas data.
**Jenis kolom yang didukung: Tipe** kolom apa pun
+ EXPRESSION — **Ekspresi** yang dijalankan terhadap respons tipe aturan untuk menghasilkan nilai Boolean. Untuk informasi selengkapnya, lihat [Ekspresi](dqdl.md#dqdl-syntax-rule-expressions).
**Contoh: Rasio nilai unik**
Contoh ini memeriksa rasio nilai unik kolom terhadap rentang nilai.
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**Contoh aturan dinamis**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
Mendeteksi anomali untuk aturan kualitas data tertentu. Setiap eksekusi DetectAnomalies aturan menghasilkan penghematan nilai yang dievaluasi untuk aturan yang diberikan. Ketika ada cukup data yang dikumpulkan, algoritma deteksi anomali mengambil semua data historis untuk aturan yang diberikan dan menjalankan deteksi anomali. DetectAnomalies aturan gagal ketika anomali terdeteksi. Info lebih lanjut tentang anomali apa yang terdeteksi dapat diperoleh dari Observasi.
**Sintaksis**
```
DetectAnomalies
```
`RULE_NAME`— Nama aturan yang ingin Anda evaluasi dan deteksi anomali. Aturan yang didukung:
+ "RowCount"
+ “Kelengkapan”
+ “Keunikan”
+ “Berarti”
+ “Jumlah”
+ "StandardDeviation"
+ “Entropi”
+ "DistinctValuesCount"
+ "UniqueValueRatio"
+ "ColumnLength"
+ "ColumnValues"
+ "ColumnCorrelation"
+ “CustomSQL”
+ "ColumnCount"
`RULE_PARAMETERS`— beberapa aturan memerlukan parameter tambahan untuk dijalankan. Lihat dokumentasi aturan yang diberikan untuk melihat parameter yang diperlukan.
**Contoh: Anomali untuk RowCount**
Misalnya, jika kami ingin mendeteksi RowCount anomali, kami berikan RowCount sebagai nama aturan.
```
DetectAnomalies "RowCount"
```
**Contoh: Anomali untuk ColumnLength**
Misalnya, jika kita ingin mendeteksi ColumnLength anomali, kita berikan ColumnLength sebagai nama aturan dan nama kolom.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness memastikan file data Anda segar berdasarkan kondisi yang Anda berikan. Ini menggunakan waktu modifikasi terakhir file Anda untuk memastikan bahwa file data atau seluruh folder. up-to-date
Aturan ini mengumpulkan dua metrik:
+ FileFreshness kepatuhan berdasarkan aturan yang Anda atur
+ Jumlah file yang dipindai oleh aturan
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
Deteksi anomali tidak mempertimbangkan metrik ini.
**Memeriksa kesegaran file**
Aturan berikut memastikan bahwa tiket.parket dibuat dalam 24 jam terakhir.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Memeriksa kesegaran folder**
Aturan berikut berlalu jika semua file dalam folder dibuat atau dimodifikasi dalam 24 jam terakhir.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Memeriksa kesegaran folder atau file dengan ambang batas**
Aturan berikut berlalu jika 10% dari file dalam folder “tiket “dibuat atau dimodifikasi dalam 10 hari terakhir.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Memeriksa file atau folder dengan tanggal tertentu**
Anda dapat memeriksa kesegaran file untuk hari-hari tertentu.
```
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"
```
**Memeriksa file atau folder dengan waktu**
Anda dapat menggunakan FileFreshness untuk memastikan bahwa file telah tiba berdasarkan waktu-waktu tertentu.
```
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"
```
Pertimbangan utama:
+ FileFreshness dapat mengevaluasi file menggunakan unit hari, jam, dan menit
+ Untuk waktu, ini mendukung AM/PM dan 24 jam
+ Waktu dihitung dalam UTC kecuali penggantian ditentukan
+ Tanggal dihitung dalam UTC pada waktu 00:00
FileFreshness yang merupakan karya berbasis waktu sebagai berikut:
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ Pertama, waktu “21:45" digabungkan dengan tanggal hari ini dalam format UTC untuk membuat bidang tanggal-waktu
+ Selanjutnya, tanggal-waktu dikonversi ke zona waktu yang telah Anda tentukan
+ Akhirnya, aturan dievaluasi
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# 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$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
Dalam contoh di atas, `uriRegex` filter diterapkan terlebih dahulu untuk memilih hanya file yang cocok dengan “inventaris\$1”, dan kemudian `recentFiles = 1` mengambil file terbaru dari set yang difilter itu. Tanpa`filterOrder`, perilaku default akan mengambil satu file terbaru terlebih dahulu dan kemudian menerapkan regex, yang dapat mengakibatkan tidak ada file yang cocok jika file terbaru tidak cocok dengan polanya.
**catatan**
Semua nilai dalam `filterOrder` daftar harus mereferensikan tag filter lain (`recentFiles`atau`uriRegex`) yang juga ada pada aturan yang sama. Tag non-filter seperti `timeZone` atau `failFast` tidak valid di`filterOrder`.
**FailFast**
Saat disetel ke`"true"`, aturan segera mengembalikan kegagalan pada file pertama yang gagal dalam kondisi kesegaran, alih-alih mengevaluasi semua file dan menghitung rasio kepatuhan.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**Zona Waktu**
Penggantian zona waktu yang diterima, lihat Zona Waktu yang [Diizinkan untuk zona waktu](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) yang didukung.
```
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"
```
**Menyimpulkan nama file langsung dari bingkai data**
Anda tidak selalu harus menyediakan jalur file. Misalnya, ketika Anda menulis aturan di Katalog Data AWS Glue, mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi kerangka data Anda dan dapat mendeteksi apakah masih segar.
**catatan**
Fitur ini hanya akan berfungsi ketika file berhasil dibaca ke dalam DynamicFrame atau DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Aturan ini akan menemukan jalur folder atau file yang digunakan untuk mengisi frame dinamis atau bingkai data. Ini berfungsi untuk jalur Amazon S3 atau tabel Katalog Data AWS Glue berbasis Amazon S3. Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki **EvaluateDataQuality**Transform segera setelah transformasi Amazon S3 atau AWS Glue Data Catalog.
![\[Tangkapan layar menunjukkan node Evaluasi Kualitas Data yang terhubung ke node Amazon S3.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-file-freshness.png)
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
Jika Anda mencoba ini di kedua kasus, atau ketika AWS Glue tidak dapat menemukan file, AWS Glue akan memunculkan kesalahan berikut: `“Unable to parse file path from DataFrame”`
# FileMatch
FileMatch Aturan ini memungkinkan Anda membandingkan file dengan file atau checksum lain. Ini dapat berguna dalam beberapa skenario:
1. Memvalidasi file yang diterima dari sumber eksternal: Anda dapat menggunakan FileMatch untuk memastikan bahwa Anda telah menerima file yang benar dari sumber eksternal dengan membandingkan dengan checksum. Ini membantu memvalidasi integritas data yang Anda konsumsi.
1. Membandingkan data dalam dua folder yang berbeda: FileMatch dapat digunakan untuk membandingkan file antara dua folder.
Aturan ini mengumpulkan satu metrik: jumlah file yang dipindai oleh aturan.
```
{"Dataset.*.FileCount":1}
```
**Validasi file dengan checksum:**
FileMatch menerima file dan set checksum untuk memastikan bahwa setidaknya satu checksum cocok dengan file.
```
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"]
```
Algoritma standar berikut didukung:
+ MD5
+ SHA-1
+ SHA-256
Jika Anda tidak menyediakan algoritma, defaultnya adalah SHA-256.
**Validasi semua file dalam folder dengan set checksum:**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Bandingkan file di folder yang berbeda**
```
# 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 akan memeriksa isi file `original_bucket` dan memastikan mereka cocok dengan apa yang ada di dalamnya`archive_bucket`. Aturan akan gagal jika mereka tidak benar-benar cocok. Itu juga dapat memeriksa isi folder internal atau file individual.
FileMatch juga dapat memeriksa file individual terhadap satu sama lain.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Menyimpulkan nama file langsung dari bingkai data**
Anda tidak selalu harus menyediakan jalur file. Misalnya, saat Anda membuat aturan di Katalog Data AWS Glue (didukung oleh Amazon S3), mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi bingkai data Anda.
**catatan**
Fitur ini hanya akan berfungsi ketika file berhasil dibaca ke dalam DynamicFrame atau DataFrame.
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
Jika checksum yang disediakan berbeda dari yang dihitung, FileMatch akan mengingatkan Anda akan perbedaannya.
![\[Tangkapan layar menunjukkan aturan dengan status DQ dari Aturan gagal. FileMatch menjelaskan kegagalan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-file-match.png)
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda untuk mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# 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$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Tag ini memastikan bahwa file tidak memiliki nama duplikat. Perilaku default adalah false.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki **EvaluateDataQuality**Transform segera setelah transformasi Amazon S3 atau AWS Glue Data Catalog.
![\[Tangkapan layar menunjukkan aturan dengan status DQ dari Aturan gagal. FileMatch menjelaskan kegagalan.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
# FileUniqueness
Keunikan File memungkinkan Anda untuk memastikan bahwa tidak ada file duplikat dalam data yang Anda terima dari produsen data Anda.
Ini mengumpulkan statistik data berikut:
1. Jumlah file yang dipindai oleh aturan
1. Rasio Keunikan file
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Temukan file duplikat dalam folder:**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Menyimpulkan nama folder langsung dari bingkai data untuk mendeteksi duplikat:**
Anda tidak selalu harus menyediakan jalur file. Misalnya, ketika Anda menulis aturan di Katalog Data AWS Glue, mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi bingkai data Anda.
**catatan**
Saat menggunakan inferensi, aturan berbasis file hanya dapat mendeteksi file yang berhasil dibaca ke dalam atau. DynamicFrame DataFrame
```
FileUniqueness > 0.5
```
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda untuk mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# 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$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Tag ini memastikan bahwa file tidak memiliki nama duplikat. Perilaku default adalah false.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki **EvaluateDataQuality**Transform segera setelah transformasi Amazon S3 atau AWS Glue Data Catalog.
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.
# FileSize
FileSize RuleType memungkinkan Anda untuk memastikan bahwa file memenuhi kriteria ukuran file tertentu. Ini berguna untuk kasus penggunaan berikut:
1. Pastikan produsen tidak mengirim file kosong atau jauh lebih kecil untuk diproses.
1. Pastikan bucket target Anda tidak memiliki file yang lebih kecil yang dapat menyebabkan masalah kinerja.
FileSize mengumpulkan metrik berikut:
1. Kepatuhan: mengembalikan% file yang memenuhi ambang batas aturan yang telah Anda buat
1. Jumlah File: jumlah file yang dipindai oleh aturan
1. Ukuran file minimum dalam byte
1. Ukuran file maksimum dalam byte
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
Deteksi anomali tidak didukung untuk metrik ini.
**Validasi ukuran file**
Aturan ini akan berlalu ketika file.dat lebih besar dari 2 MB.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
Unites yang didukung termasuk B (byte), MB (mega byte), GB (giga byte) dan TB (terra byte).
**Validasi ukuran file dalam folder**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Aturan ini akan berlalu jika 70% file di s3://amzn-s3-demo-bucket adalah antara 2 GB dan 1 TB.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Menyimpulkan nama file langsung dari bingkai data**
Anda tidak selalu harus menyediakan jalur file. Misalnya, ketika Anda menulis aturan di Katalog Data, mungkin sulit untuk menemukan folder mana yang digunakan tabel katalog. AWS Glue Data Quality dapat menemukan folder atau file tertentu yang digunakan untuk mengisi bingkai data Anda.
**catatan**
Fitur ini hanya akan berfungsi ketika file berhasil dibaca ke dalam DynamicFrame atau DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Tag Aturan Berbasis File Opsional:**
Tag memungkinkan Anda mengontrol perilaku aturan.
**RecentFiles**
Tag ini membatasi jumlah file yang diproses dengan menyimpan file terbaru terlebih dahulu.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**UriRegex**
**catatan**
`uriRegex`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Tag ini memfilter file dengan menerapkan pola regex ke jalur file. Hanya file yang jalurnya cocok dengan pola yang diproses. Anda juga dapat menggunakan lookahead negatif untuk mengecualikan file yang cocok dengan pola.
```
# 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$).*"
```
**FilterOrder**
**catatan**
`filterOrder`Tag tersedia di AWS Glue 5.0 dan yang lebih baru.
Bila Anda menggunakan beberapa tag filter seperti `recentFiles` dan `uriRegex` bersama-sama, `filterOrder` tag mengontrol urutan penerapannya. Urutan default adalah yang `recentFiles` pertama, lalu`uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**FailFast**
Saat disetel ke`"true"`, aturan segera mengembalikan kegagalan pada file pertama yang gagal dalam kondisi ukuran, alih-alih mengevaluasi semua file dan menghitung rasio kepatuhan.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Ada beberapa pertimbangan:
1. Di AWS Glue ETL, Anda harus memiliki DataQuality Evaluate Transform segera setelah Amazon S3 atau Data Catalog berubah.
1. Aturan ini tidak akan berfungsi di AWS Glue Interactive Sessions.