fix: enhance SQL expression handling for JSON fields and improve query logging

Author: nichenqin

apps/nestjs-backend/src/features/field/field.service.ts

@@ -307,6 +307,7 @@ export class FieldService implements IReadonlyAdapterService {
 
       // Execute all queries (main table alteration + any additional queries like junction tables)
       for (const query of alterTableQueries) {
+        this.logger.debug(`Executing alter table query: ${query}`);
         await this.prismaService.txClient().$executeRawUnsafe(query);
       }
 

apps/nestjs-backend/src/features/record/query-builder/field-cte-visitor.ts

@@ -469,13 +469,14 @@ class FieldCteSelectionVisitor implements IFieldVisitor<IFieldSelectName> {
       }
     } else {
       const targetFieldResult = targetLookupField.accept(selectVisitor);
-      expression =
-        typeof targetFieldResult === 'string' ? targetFieldResult : targetFieldResult.toSQL().sql;
-      // Self-join: ensure expression uses the foreign alias override
       const defaultForeignAlias = getTableAliasFromTable(this.foreignTable);
-      if (defaultForeignAlias !== foreignAlias) {
-        expression = expression.replaceAll(`"${defaultForeignAlias}"`, `"${foreignAlias}"`);
-      }
+      const baseExpression =
+        typeof targetFieldResult === 'string' ? targetFieldResult : targetFieldResult.toSQL().sql;
+      const normalizedBaseExpression =
+        defaultForeignAlias !== foreignAlias
+          ? baseExpression.replaceAll(`"${defaultForeignAlias}"`, `"${foreignAlias}"`)
+          : baseExpression;
+      expression = normalizedBaseExpression;
 
       // For Postgres multi-value lookups targeting datetime-like fields, normalize the
       // element expression to an ISO8601 UTC string so downstream JSON comparisons using
@@ -486,8 +487,9 @@ class FieldCteSelectionVisitor implements IFieldVisitor<IFieldSelectName> {
         field.isMultipleCellValue &&
         isDateLikeField(targetLookupField)
       ) {
-        // Format: 2020-01-10T16:00:00.000Z
-        expression = `to_char(${expression} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`;
+        // Format: 2020-01-10T16:00:00.000Z, wrap as jsonb so downstream aggregation remains valid JSON.
+        const isoUtcExpr = `to_char(${normalizedBaseExpression} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`;
+        expression = `to_jsonb(${isoUtcExpr})`;
       }
     }
     // Build deterministic order-by for multi-value lookups using the link field configuration

apps/nestjs-backend/src/features/record/query-builder/field-select-visitor.ts

@@ -23,7 +23,7 @@ import type {
   ButtonFieldCore,
   TableDomain,
 } from '@teable/core';
-import { FieldType, isLinkLookupOptions } from '@teable/core';
+import { DbFieldType, FieldType, isLinkLookupOptions } from '@teable/core';
 // no driver-specific logic here; use dialect for differences
 import type { Knex } from 'knex';
 import type { IDbProvider } from '../../../db-provider/db.provider.interface';
@@ -226,7 +226,7 @@ export class FieldSelectVisitor implements IFieldVisitor<IFieldSelectName> {
       // always emit the computed expression which degrades to NULL when references
       // are unresolved.
       if (this.rawProjection) {
-        return this.dbProvider.convertFormulaToSelectQuery(expression, {
+        const formulaSql = this.dbProvider.convertFormulaToSelectQuery(expression, {
           table: this.table,
           tableAlias: this.tableAlias,
           selectionMap: this.getSelectionMap(),
@@ -235,6 +235,10 @@ export class FieldSelectVisitor implements IFieldVisitor<IFieldSelectName> {
           preferRawFieldReferences: this.preferRawFieldReferences,
           targetDbFieldType: field.dbFieldType,
         });
+        const normalized =
+          field.dbFieldType === DbFieldType.Json ? `to_jsonb(${formulaSql})` : formulaSql;
+        this.state.setSelection(field.id, normalized);
+        return normalized;
       }
 
       // For non-raw contexts where the generated column exists, select it directly

apps/nestjs-backend/src/features/record/query-builder/record-query-builder.service.ts

@@ -9,7 +9,6 @@ import { ID_FIELD_NAME, preservedDbFieldNames } from '../../field/constant';
 import { TableDomainQueryService } from '../../table-domain/table-domain-query.service';
 import { FieldCteVisitor } from './field-cte-visitor';
 import { FieldSelectVisitor } from './field-select-visitor';
-import type { IFieldSelectName } from './field-select.type';
 import type {
   ICreateRecordAggregateBuilderOptions,
   ICreateRecordQueryBuilderOptions,
@@ -262,32 +261,17 @@ export class RecordQueryBuilderService implements IRecordQueryBuilder {
 
     // Apply grouping if specified
     if (groupBy && groupBy.length > 0) {
-      const groupingBuilder = this.dbProvider
+      this.dbProvider
         .groupQuery(qb, fieldMap, groupByFieldIds, undefined, { selectionMap })
         .appendGroupBuilder();
 
-      // After grouping, the select list aliases each grouped column to its dbFieldName.
-      // Normalize the selectionMap accordingly so subsequent sort builders reference the
-      // projected alias instead of the original table-qualified column, avoiding
-      // "must appear in GROUP BY" errors when ordering grouped aggregates.
-      const mutableSelectionMap = selectionMap as Map<string, IFieldSelectName>;
-      groupBy.forEach(({ fieldId }) => {
-        const groupedField = fieldMap[fieldId];
-        if (!groupedField) {
-          return;
-        }
+      for (const groupItem of groupBy) {
+        const groupedField = fieldMap[groupItem.fieldId];
+        if (!groupedField) continue;
+        const direction = groupItem.order === SortFunc.Desc ? 'DESC' : 'ASC';
+        const nullOrdering = direction === 'DESC' ? 'NULLS LAST' : 'NULLS FIRST';
         const quotedAlias = `"${groupedField.dbFieldName.replace(/"/g, '""')}"`;
-        mutableSelectionMap.set(fieldId, quotedAlias);
-      });
-
-      const groupSortItems: ISortItem[] = groupBy.map((item) => ({
-        fieldId: item.fieldId,
-        order: item.order ?? SortFunc.Asc,
-      }));
-      if (groupSortItems.length > 0) {
-        this.dbProvider
-          .sortQuery(qb, fieldMap, groupSortItems, undefined, { selectionMap })
-          .appendSortBuilder();
+        qb.orderByRaw(`${quotedAlias} ${direction} ${nullOrdering}`);
       }
     }
 

apps/nestjs-backend/src/features/record/query-builder/sql-conversion.visitor.ts

@@ -1321,6 +1321,9 @@ export class SelectColumnSqlConversionVisitor extends BaseSqlConversionVisitor<I
           columnRef = adjusted;
         }
         if (fieldInfo.isLookup && isLinkLookupOptions(fieldInfo.lookupOptions)) {
+          if (preferRaw) {
+            return columnRef;
+          }
           if (fieldInfo.dbFieldType !== DbFieldType.Json) {
             return columnRef;
           }
@@ -1427,6 +1430,9 @@ export class SelectColumnSqlConversionVisitor extends BaseSqlConversionVisitor<I
     }
 
     const preferRaw = !!selectContext.preferRawFieldReferences;
+    if (preferRaw) {
+      return expr;
+    }
     if (preferRaw && selectContext.targetDbFieldType === DbFieldType.Json) {
       return expr;
     }