executeQueryAsMaps method

Implementation

@override
Future<List<Map<String, dynamic>>> executeQueryAsMaps(JsonQuery query) async {
  // Compile to get relation metadata
  final sqlQuery = compiler.compile(query);

  // Execute the query
  final result = await transaction.queryRaw(sqlQuery);

  // Check if we need to deserialize relations
  final hasRelations =
      sqlQuery.hasRelations && sqlQuery.relationMetadata is CompiledRelations;

  // Convert to maps - preserve aliases when relations are present so
  // the RelationDeserializer can match column aliases like "user__name"
  final flatMaps = _resultSetToMaps(result, preserveAliases: hasRelations);

  if (hasRelations) {
    final compiledRelations = sqlQuery.relationMetadata as CompiledRelations;

    // Use relation deserializer to nest flat JOIN results
    final deserializer = RelationDeserializer(
      schema: schema ?? compiler.schema ?? schemaRegistry,
    );

    final deserialized = deserializer.deserialize(
      rows: flatMaps,
      baseModel: query.modelName,
      columnAliases: compiledRelations.columnAliases,
      includedRelations: compiledRelations.includedRelations,
    );

    // Preserve computed fields that were lost during relation deserialization.
    if (sqlQuery.computedFieldNames.isNotEmpty && flatMaps.isNotEmpty) {
      final model = (schema ?? compiler.schema ?? schemaRegistry)
          .getModel(query.modelName);
      if (model != null && model.primaryKeys.isNotEmpty) {
        final pkColumns =
            model.primaryKeys.map((pk) => pk.columnName).toList();

        String getPkValue(Map<String, dynamic> row) {
          return pkColumns.map((c) => row[c]?.toString() ?? '').join('::');
        }

        final flatMapByPk = <String, Map<String, dynamic>>{};
        for (final row in flatMaps) {
          flatMapByPk.putIfAbsent(getPkValue(row), () => row);
        }

        for (final resultRow in deserialized) {
          final flatRow = flatMapByPk[getPkValue(resultRow)];
          if (flatRow != null) {
            for (final fieldName in sqlQuery.computedFieldNames) {
              if (flatRow.containsKey(fieldName)) {
                resultRow[fieldName] = flatRow[fieldName];
              }
            }
          }
        }
      }
    }

    return deserialized;
  }

  return flatMaps;
}