Possible AWS Glue DQDL parser bug: composite rule with `where` fails, but equivalent simple rules work

Question

Hello,

I found what looks like a parser inconsistency in AWS Glue Data Quality DQDL and wanted to check whether others have seen the same behavior.

Context:

Service: AWS Glue Data Quality
API: CreateDataQualityRuleset
Region: us-east-1
Observed on: March 18, 2026

Problem: A composite rule using and works without a where clause. A simple rule also works with where. But when I apply a single where clause to the full composite expression, the ruleset is rejected with:

InvalidInputException: DataQuality rules cannot be parsed

Minimal example

This works:

Rules = [
  ColumnLength "field_a" >= 1,
  ColumnLength "field_a" <= 5
]

This also works:

Rules = [
  ColumnLength "field_a" >= 1 where "status_flag = DATE '2099-12-31'",
  ColumnLength "field_a" <= 5 where "status_flag = DATE '2099-12-31'"
]

This fails:

Rules = [
  (ColumnLength "field_a" >= 1) and (ColumnLength "field_a" <= 5) where "status_flag = DATE '2099-12-31'"
]

Error:

InvalidInputException: DataQuality rules cannot be parsed

What makes this confusing:

Composite rules seem supported
where clauses seem supported
But where attached to the composite expression appears to fail parsing

Workaround: Instead of writing one composite rule with a single where, I had to split it into two separate rules and repeat the same where clause on each one.

Question: Is this expected behavior and just undocumented, or is this a parser bug/limitation in Glue Data Quality?

If expected, it would be very helpful to have this explicitly documented in the DQDL reference, because the current behavior is not obvious.

re:Post Agent · Answer

Based on the current DQDL specification, this appears to be a limitation in how composite rules interact with `where` clauses rather than a documented bug. Here's what's happening:

**Current DQDL Support:**
- Composite rules using `and` and `or` operators are supported for combining multiple rules
- `where` clauses are supported for filtering data before applying data quality rules
- However, the syntax for applying a `where` clause to an entire composite expression is not explicitly documented as supported

**Why Your Workaround Works:**
When you split the composite rule into two separate rules with individual `where` clauses, each rule is parsed independently with its own filter condition. This follows the documented pattern where `where` clauses are applied at the individual rule level.

**The Parsing Issue:**
The parser appears to expect `where` clauses to be associated with individual rule expressions rather than composite expressions. When you write:
```
(ColumnLength "field_a" >= 1) and (ColumnLength "field_a" <= 5) where "status_flag = DATE '2099-12-31'"
```

The parser may be interpreting the `where` clause as applying only to the last part of the composite expression, or it may not recognize this as valid syntax at all, resulting in the parsing error.

**Recommendation:**
Your workaround of using separate rules with repeated `where` clauses is currently the correct approach. While this requires duplicating the filter condition, it aligns with how DQDL currently handles the combination of composite rules and filtering.

This does appear to be a gap in the DQDL syntax that could benefit from either explicit documentation or enhancement to support `where` clauses on composite expressions directly.  
**Sources**  
[Troubleshooting AWS Glue Data Quality errors - AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/data-quality-trouble.html)  
[Data Quality Definition Language (DQDL) reference - AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html)  
[AWS Glue Data Quality - AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-data-quality.html)

Johan Staring · Answer

It's not a bug, it's a confirmed limitation on the DQDL grammar. You work around it like you did, or (at least in your particular example) use a different expression like between that would let you use a single where clause.

The documentation could be clearer, though. I recommend that you use the Feedback link on the DQDL reference page.

The documentation could be clearer, though. I recommend that you use the Feedback link on the [DQDL reference page](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-syntax-composite-rules).

Possible AWS Glue DQDL parser bug: composite rule with `where` fails, but equivalent simple rules work

Add your answer

Relevant content