Why Atomic Query Construction Favors Arrays Over DTOs for Dynamic Query Logic

Why Atomic Query Construction (AQC) Intentionally Uses Arrays Instead of DTOs

The Atomic Query Construction (AQC) pattern intentionally prioritizes array-based parameters over Data Transfer Objects (DTOs) to maintain dynamic query flexibility. This design choice addresses the combinatorial explosion of query scenarios that arise when multiple optional parameters are combined.

Why This Matters

While DTOs are often viewed as cleaner due to type safety, they introduce rigid structures that conflict with the parameter-driven nature of AQC. In high-variability environments, forcing a fixed contract via DTOs results in an unnecessary translation layer and structural bloat as queries evolve, whereas arrays allow parameters to act as independent atomic switches for query logic, preserving the dynamic nature of query composition without adding weight to the system.

Key Insights

• AQC relies on Cartesian flexibility where five optional parameters can result in dozens of unique query combinations.
• DTOs define structure too early, requiring constant updates to the DTO class as new parameters like rating or visibility are added.
• The array-based approach maintains thin controllers by removing the translation layer, keeping the flow as Request to AQC to Query.
• Each parameter in the array acts as a trigger for an atomic query segment, facilitating conditional query pieces without structural constraints.

Working Examples

Example of parameter array shaping the query.

$params = [
'category_id' => 5,
'min_price' => 100,
'max_price' => 500,
'with' => ['brand']
];

Internal AQC query logic using parameters as triggers.

$query = Product::query();
if (!empty($params['category_id'])) {
$query->where('category_id', $params['category_id']);
}
if (!empty($params['min_price'])) {
$query->where('price', '>=', $params['min_price']);
}
if (!empty($params['max_price'])) {
$query->where('price', '<=', $params['max_price']);
}
if (!empty($params['with'])) {
$query->with($params['with']);
}

Rigid DTO structure that AQC intentionally avoids.

class ProductQueryDTO
{
public ?int $categoryId;
public ?int $brandId;
public ?int $priceMin;
public ?int $priceMax;
}

Practical Applications

• Use Case: Product filtering systems where category_id, brand_id, and price ranges must combine freely. Pitfall: Using DTOs leads to multiplying classes for slightly different query requirements.
• Use Case: Eloquent-based query builders in Laravel where relations are optional. Pitfall: Rigid DTOs force defining all possible relations upfront, reducing dynamic composition.

References:

• https://dev.to/raheelshan/why-atomic-query-construction-aqc-intentionally-uses-arrays-instead-of-dtos-3jfa