Referensi Bahasa Definisi Kualitas Data (DQDL)

Data Quality Definition Language (DQDL) adalah bahasa khusus domain yang Anda gunakan untuk menentukan aturan untuk AWS Glue Data Quality.

Panduan ini memperkenalkan konsep DQDL utama untuk membantu Anda memahami bahasa. Ini juga menyediakan referensi untuk jenis aturan DQDL dengan sintaks dan contoh. Sebelum Anda menggunakan panduan ini, kami sarankan Anda terbiasa dengan Kualitas Data AWS Lem. Untuk informasi selengkapnya, lihat AWS Glue Kualitas Data.

Sintaks DQDL

Dokumen DQDL peka huruf besar/kecil dan berisi kumpulan aturan, yang mengelompokkan aturan kualitas data individu bersama-sama. Untuk membangun kumpulan aturan, Anda harus membuat daftar bernama Rules (huruf besar), dibatasi oleh sepasang tanda kurung persegi. Daftar harus berisi satu atau lebih aturan DQDL yang dipisahkan koma seperti contoh berikut.

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

Struktur aturan

Struktur aturan DQDL tergantung pada jenis aturan. Namun, aturan DQDL umumnya sesuai dengan format berikut.

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

RuleTypeadalah nama peka huruf besar-kecil dari jenis aturan yang ingin Anda konfigurasikan. Sebagai contoh, IsComplete, IsUnique, atau CustomSql. Parameter aturan berbeda untuk setiap jenis aturan. Untuk referensi lengkap jenis aturan DQDL dan parameternya, lihat. Referensi tipe aturan DQDL

Aturan komposit

Anda dapat menggunakan operator yang sama untuk menghubungkan beberapa aturan, sehingga kombinasi aturan berikut diperbolehkan.

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

Anda dapat menggabungkan operator logis menjadi satu ekspresi. Contoh:

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

Anda juga dapat membuat aturan bersarang yang lebih kompleks.

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

Cara kerja aturan Komposit

Secara default, Aturan Komposit dievaluasi sebagai aturan individual di seluruh dataset atau tabel dan kemudian hasilnya digabungkan. Dengan kata lain, ia mengevaluasi seluruh kolom terlebih dahulu dan kemudian menerapkan operator. Perilaku default ini dijelaskan di bawah ini dengan contoh:

# Dataset

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

# Overall outcome

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

Dalam contoh di atas, AWS Glue Data Quality pertama-tama evaluasi (ColumnValues "myCol1" > 1) yang akan mengakibatkan kegagalan. Kemudian akan mengevaluasi (ColumnValues "myCol2" > 2) mana yang juga akan gagal. Kombinasi dari kedua hasil akan dicatat sebagai GAGAL.

Namun, jika Anda lebih suka perilaku seperti SQL, di mana Anda memerlukan seluruh baris untuk dievaluasi, Anda harus secara eksplisit mengatur ruleEvaluation.scope parameter seperti yang ditunjukkan pada cuplikan kode additionalOptions di bawah ini.

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

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

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

Di Katalog Data AWS Glue, Anda dapat dengan mudah mengkonfigurasi opsi ini di antarmuka pengguna seperti yang ditunjukkan di bawah ini.

Setelah ditetapkan, aturan komposit akan berperilaku sebagai aturan tunggal 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 mengandalkan rasio:

Aturan tergantung pada ambang batas:

Ketika aturan berikut menyertakan dengan ambang batas, mereka tidak didukung. Namun, aturan yang tidak melibatkan with threshold tetap didukung.

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.

Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"

ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"

ColumnValues "colA" > 10

ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"

ColumnValues "colA" >= 10

ColumnValues "colA" <= 1000

Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"

ColumnValues "colA" not between "2022-05-31" and "2022-06-30"

ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]

ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]

ColumnValues "colA" matches "[a-zA-Z]*"

ColumnValues "colA" not matches "[a-zA-Z]*"

ColumnValues "load_date" > (now() - 3 days)

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_ONLY

Jika Anda ingin memvalidasi jika kolom string memiliki null, kosong atau string dengan hanya spasi putih, Anda dapat menggunakan kata kunci berikut:

Untuk ekspresi berbasis numerik atau tanggal, jika Anda ingin memvalidasi jika kolom memiliki nol, Anda dapat menggunakan kata kunci berikut.

Penyaringan dengan Where Clause

Anda dapat memfilter data saat membuat aturan. Ini sangat membantu ketika Anda ingin menerapkan aturan bersyarat.

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

Filter harus ditentukan dengan where kata kunci, diikuti dengan 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.

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

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 disediakan valid. Jika tidak valid, evaluasi aturan akan gagal dan kami akan membuang an IllegalArgumentException dengan format berikut:

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

Di mana perilaku klausa saat identifikasi catatan kesalahan tingkat baris diaktifkan

Dengan AWS Glue Data Quality, Anda dapat mengidentifikasi catatan tertentu yang gagal. Saat menerapkan klausa where ke aturan yang mendukung hasil tingkat baris, kami akan memberi label baris yang disaring oleh klausa where sebagaiPassed.

Jika Anda lebih suka memberi label terpisah pada baris yang disaring sebagaiSKIPPED, Anda dapat mengatur yang berikut additionalOptions untuk pekerjaan ETL.

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

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

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

Sebagai contoh, lihat aturan dan kerangka data berikut:

IsComplete att2 where "att1 = 'a'"

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 cara mendefinisikan dan menggunakan konstanta:

mySql = "select count(*) from primary"

Rules = [
    CustomSql $mySql between 0 and 100
]

Dalam contoh ini, query SQL ditetapkan ke konstantamySql, 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 pada 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 mudah diintegrasikan dengan alur kerja pemantauan dan pelaporan yang ada.

Sintaks untuk label DQDL

DQDL mendukung label default dan aturan khusus. Label default didefinisikan pada tingkat kumpulan aturan dan secara otomatis berlaku untuk semua aturan dalam kumpulan aturan tersebut. Aturan individual juga dapat memiliki label sendiri, dan karena label diimplementasikan sebagai pasangan kunci-nilai, label khusus aturan dapat mengganti label default saat menggunakan kunci yang sama.

Contoh berikut menunjukkan cara menggunakan label default dan aturan khusus:

DefaultLabels=["frequency"="monthly"]

Rules = [
    // Auto includes the default label ["frequency"="monthly"]
    ColumnValues "col" > 21,
    // Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
    RowCount > 0 with threshold > 0.8 labels=["foo"="bar"],
    // Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
    ColumnValues "colA" in ["A", "B"]  with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
    // Labels must be applied to the entire composite rule (parentheses required)
    (isComplete "col" AND RowCount > 0) labels=["foo"="bar]
]

Contoh berikut menunjukkan sintaks yang tidak valid dengan label dan aturan komposit:

          (isComplete "colA") AND (RowCount > 0) labels=["foo"="bar"]
          (isComplete "colA" labels=["foo"="bar"]) AND (RowCount > 0)
          isComplete "col" AND RowCount > 0 labels=["foo"="bar]
        

Kendala label

Label memiliki batasan berikut:

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.

Row-level hasil

Label DQDL dinonaktifkan secara default di 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 kolomDataQualityRulesPass,, DataQualityRulesFail dan. DataQualityRulesSkip

Tanggapan API

Label DQDL selalu terlihat dalam respons API di bawah bidang baru Labels di RuleResults objek.

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

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 yang harus dipertimbangkan; last(k) di mana k >= 1 akan mereferensikan k metrik terakhir.

Untuk membentuk ekspresi yang valid gunakanlast(k), di mana k > 1 memerlukan fungsi agregasi untuk mengurangi beberapa hasil historis menjadi satu angka. Misalnya, RowCount > avg(last(5)) akan memeriksa apakah jumlah baris dataset saat ini benar-benar lebih besar dari rata-rata lima jumlah baris terakhir untuk kumpulan data yang sama. RowCount > last(5)akan menghasilkan kesalahan karena jumlah baris dataset saat ini tidak dapat dibandingkan secara bermakna dengan daftar.

Fungsi agregasi yang didukung:

Contoh ekspresi

ColumnCorrelation

DistinctValuesCount

Sebagian besar jenis aturan dengan kondisi numerik atau ambang mendukung aturan dinamis; lihat tabel yang disediakan, Analyzer dan Aturan, untuk menentukan apakah aturan dinamis didukung untuk jenis aturan Anda.

Mengecualikan 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 K ecualikan Statistik. Sekarang statistik yang dikecualikan tidak akan dimasukkan dalam perhitungan aturan dinamis.

Alat analisis

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 jumlah 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, sebaiknya buat penganalisis dan kemudian minta mereka menghasilkan statistik yang dapat digunakan untuk mendeteksi anomali. Untuk contoh seperti itu, Anda dapat membuat penganalisis. Penganalisis berbeda dari aturan dengan cara berikut.

Penganalisis dapat eksis secara independen tanpa aturan, sehingga Anda dapat dengan cepat mengonfigurasinya dan secara progresif membangun aturan kualitas data.

Beberapa jenis aturan dapat dimasukkan 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 dalam Analyzers blok. Tabel berikut menunjukkan apakah setiap item didukung sebagai aturan atau penganalisis mandiri, bersama dengan detail tambahan untuk setiap jenis aturan.

Contoh Rule Set dengan Analyzer

Kumpulan aturan berikut menggunakan:

Hasil metrik penganalisis dapat dilihat di tab Kualitas Data untuk menjalankan pekerjaan Anda.

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

AWS Kualitas Data Lem mendukung penganalisis berikut.

Penganalisis Distribusi

DistributionAnalyzer menghitung distribusi frekuensi untuk kolom dalam dataset Anda. Gunakan Distribution Analyzer untuk memahami bagaimana data Anda didistribusikan dari waktu ke waktu dan mendeteksi pergeseran rentang data di seluruh proses evaluasi.

Untuk informasi tentang sintaks DQDL dan contoh penggunaan dasar, lihat. Distribusi

Perilaku numerik dan kategoris

DistributionAnalyzer mengecualikan nilai NULL di kolom target dari perhitungan distribusi untuk kedua jenis kolom.

Format output

DistributionStatistik mengembalikan DistributionValue objek terstruktur yang berisi bidang berikut:

Tepi tempat sampah beku

Ketika Anda pertama kali menjalankan Distribution Analyzer pada kolom, penganalisis menghitung tepi bin berdasarkan rentang nilai kolom saat ini. Pada proses berikutnya untuk statistik yang sama (kolom yang sama, jumlah bin yang sama), penganalisis menggunakan kembali tepi dari proses pertama. Perilaku ini disebut tepi beku.

Tepi beku memungkinkan perbandingan yang berarti di seluruh proses karena tempat sampah tetap konsisten dari waktu ke waktu. Tanpa tepi beku, batas bin akan bergeser pada setiap proses saat rentang data berubah.

Pengamatan luapan

Ketika nilai data berada di luar batas bin beku, penganalisis menghitungnya di bin pertama atau terakhir (tempat sampah luapan). Jika lebih dari 2% nilai mendarat di tempat sampah yang meluap, Kualitas Data AWS Glue menghasilkan pengamatan informasi. Jika lebih dari 5% nilai meluap, AWS Glue Data Quality menghasilkan pengamatan yang lebih kuat dan melacak proses luapan berturut-turut. Setelah 3 kali berjalan berturut-turut melebihi 5%, rebinning otomatis dipicu.

Rebinning otomatis

Jika 3 kali evaluasi berturut-turut menghasilkan lebih dari 5% luapan, AWS Glue Data Quality secara otomatis menghitung ulang tepi tempat sampah. Tepi baru didasarkan pada rentang data saat ini. Setelah rebinning, tepi baru menjadi tepi beku untuk proses selanjutnya.

Setelah rebinning otomatis, histogram Anda beradaptasi dengan perubahan rentang data berkelanjutan tanpa intervensi manual. Tepi bin tetap stabil selama fluktuasi sementara.

Anda dapat memilih keluar dari rebinning otomatis dengan menyetel rebin parameter ke false dalam kumpulan aturan DQDL Anda:

Analyzers = [
    Distribution "Salary" with bins = 20, rebin = false
]

Saat rebinning otomatis dinonaktifkan, tepi tempat sampah tetap beku tanpa batas waktu terlepas dari frekuensi luapan. AWS Kualitas Data Lem terus menghasilkan pengamatan luapan.

Komentar

Anda dapat menggunakan karakter '#' untuk menambahkan komentar ke dokumen DQDL Anda. Apa pun setelah karakter '#' 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
]