feat: add context management for generated columns in formula queries and update related tests

Author: nichenqin

apps/nestjs-backend/src/db-provider/formula-query/formula-query.abstract.ts

@@ -1,10 +1,22 @@
-import type { IFormulaQueryInterface } from './formula-query.interface';
+import type { IFormulaQueryInterface, IFormulaConversionContext } from './formula-query.interface';
 
 /**
  * Abstract base class for formula query implementations
  * Provides common functionality and default implementations
  */
 export abstract class FormulaQueryAbstract implements IFormulaQueryInterface {
+  /** Current conversion context */
+  protected context?: IFormulaConversionContext;
+
+  /** Set the conversion context */
+  setContext(context: IFormulaConversionContext): void {
+    this.context = context;
+  }
+
+  /** Check if we're in a generated column context */
+  protected get isGeneratedColumnContext(): boolean {
+    return this.context?.isGeneratedColumn ?? false;
+  }
   // Numeric Functions
   abstract sum(params: string[]): string;
   abstract average(params: string[]): string;

apps/nestjs-backend/src/db-provider/formula-query/formula-query.interface.ts

@@ -1,11 +1,11 @@
-import type { CellValueType } from '@teable/core';
-
 /**
  * Interface for database-specific formula function implementations
  * Each database provider (PostgreSQL, SQLite) should implement this interface
  * to provide SQL translations for Teable formula functions
  */
 export interface IFormulaQueryInterface {
+  // Context management
+  setContext(context: IFormulaConversionContext): void;
   // Numeric Functions
   sum(params: string[]): string;
   average(params: string[]): string;
@@ -159,6 +159,8 @@ export interface IFormulaConversionContext {
     };
   };
   timeZone?: string;
+  /** Whether this conversion is for a generated column (affects immutable function handling) */
+  isGeneratedColumn?: boolean;
 }
 
 /**

apps/nestjs-backend/src/db-provider/formula-query/postgres/formula-query.postgres.ts

@@ -175,10 +175,20 @@ export class FormulaQueryPostgres extends FormulaQueryAbstract {
 
   // DateTime Functions
   now(): string {
+    // For generated columns, use the current timestamp at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+      return `'${currentTimestamp}'::timestamp`;
+    }
     return 'NOW()';
   }
 
   today(): string {
+    // For generated columns, use the current date at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentDate = new Date().toISOString().split('T')[0];
+      return `'${currentDate}'::date`;
+    }
     return 'CURRENT_DATE';
   }
 
@@ -225,6 +235,11 @@ export class FormulaQueryPostgres extends FormulaQueryAbstract {
   }
 
   fromNow(date: string): string {
+    // For generated columns, use the current timestamp at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+      return `EXTRACT(EPOCH FROM '${currentTimestamp}'::timestamp - ${date}::timestamp)`;
+    }
     return `EXTRACT(EPOCH FROM NOW() - ${date}::timestamp)`;
   }
 
@@ -279,6 +294,11 @@ export class FormulaQueryPostgres extends FormulaQueryAbstract {
   }
 
   toNow(date: string): string {
+    // For generated columns, use the current timestamp at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+      return `EXTRACT(EPOCH FROM ${date}::timestamp - '${currentTimestamp}'::timestamp)`;
+    }
     return `EXTRACT(EPOCH FROM ${date}::timestamp - NOW())`;
   }
 

apps/nestjs-backend/src/db-provider/formula-query/sqlite/formula-query.sqlite.ts

@@ -175,10 +175,20 @@ export class FormulaQuerySqlite extends FormulaQueryAbstract {
 
   // DateTime Functions
   now(): string {
+    // For generated columns, use the current timestamp at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+      return `'${currentTimestamp}'`;
+    }
     return "DATETIME('now')";
   }
 
   today(): string {
+    // For generated columns, use the current date at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentDate = new Date().toISOString().split('T')[0];
+      return `'${currentDate}'`;
+    }
     return "DATE('now')";
   }
 
@@ -246,6 +256,11 @@ export class FormulaQuerySqlite extends FormulaQueryAbstract {
   }
 
   fromNow(date: string): string {
+    // For generated columns, use the current timestamp at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+      return `(JULIANDAY('${currentTimestamp}') - JULIANDAY(${date})) * 24 * 60 * 60`;
+    }
     return `(JULIANDAY('now') - JULIANDAY(${date})) * 24 * 60 * 60`;
   }
 
@@ -299,6 +314,11 @@ export class FormulaQuerySqlite extends FormulaQueryAbstract {
   }
 
   toNow(date: string): string {
+    // For generated columns, use the current timestamp at field creation time
+    if (this.isGeneratedColumnContext) {
+      const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+      return `(JULIANDAY(${date}) - JULIANDAY('${currentTimestamp}')) * 24 * 60 * 60`;
+    }
     return `(JULIANDAY(${date}) - JULIANDAY('now')) * 24 * 60 * 60`;
   }
 

apps/nestjs-backend/src/db-provider/postgres.provider.ts

@@ -595,6 +595,9 @@ ORDER BY
   convertFormula(expression: string, context: IFormulaConversionContext): IFormulaConversionResult {
     try {
       const formulaQuery = this.formulaQuery();
+      // Set the context on the formula query instance
+      formulaQuery.setContext(context);
+
       const visitor = new SqlConversionVisitor(formulaQuery, context);
 
       const sql = parseFormulaToSQL(expression, visitor);

apps/nestjs-backend/src/db-provider/sqlite.provider.ts

@@ -518,6 +518,9 @@ ORDER BY
   convertFormula(expression: string, context: IFormulaConversionContext): IFormulaConversionResult {
     try {
       const formulaQuery = this.formulaQuery();
+      // Set the context on the formula query instance
+      formulaQuery.setContext(context);
+
       const visitor = new SqlConversionVisitor(formulaQuery, context);
 
       const sql = parseFormulaToSQL(expression, visitor);

apps/nestjs-backend/src/features/field/database-column-visitor.postgres.ts

@@ -107,6 +107,7 @@ export class PostgresDatabaseColumnVisitor implements IFieldVisitor<void> {
 
         const conversionContext: IFormulaConversionContext = {
           fieldMap: this.context.fieldMap,
+          isGeneratedColumn: true, // Mark this as a generated column context
         };
 
         // Use expanded expression if available, otherwise use original expression

apps/nestjs-backend/src/features/field/database-column-visitor.sqlite.ts

@@ -107,6 +107,7 @@ export class SqliteDatabaseColumnVisitor implements IFieldVisitor<void> {
 
         const conversionContext: IFormulaConversionContext = {
           fieldMap: this.context.fieldMap,
+          isGeneratedColumn: true, // Mark this as a generated column context
         };
 
         // Use expanded expression if available, otherwise use original expression

apps/nestjs-backend/src/features/field/database-column-visitor.test.ts

@@ -10,6 +10,7 @@ import type { Knex } from 'knex';
 import type { Mock } from 'vitest';
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import type { IDbProvider } from '../../db-provider/db.provider.interface';
+import type { IFormulaConversionContext } from '../../db-provider/formula-query/formula-query.interface';
 import {
   PostgresDatabaseColumnVisitor,
   type IDatabaseColumnContext,
@@ -356,5 +357,101 @@ describe('Database Column Visitor', () => {
       expect(mockTextFn).toHaveBeenCalledTimes(1);
       expect(mockSpecificTypeFn).toHaveBeenCalledTimes(1);
     });
+
+    it('should pass isGeneratedColumn context for PostgreSQL generated columns', () => {
+      // Mock the convertFormula to capture the context and return a realistic SQL with current timestamp
+      let capturedContext: IFormulaConversionContext | undefined;
+      (mockDbProvider.convertFormula as Mock).mockImplementation(
+        (expression: string, context: IFormulaConversionContext) => {
+          capturedContext = context;
+          // Simulate what would happen with YEAR(NOW()) in generated column context
+          const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+          return {
+            sql: `EXTRACT(YEAR FROM '${currentTimestamp}'::timestamp)`,
+            dependencies: [],
+          };
+        }
+      );
+
+      const formulaField = plainToInstance(FormulaFieldCore, {
+        id: 'fld123',
+        name: 'Formula Field',
+        type: FieldType.Formula,
+        dbFieldType: DbFieldType.Integer,
+        cellValueType: CellValueType.Number,
+        dbFieldName: 'test_field',
+        options: {
+          expression: 'YEAR(NOW())',
+          dbGenerated: true,
+        },
+      });
+
+      const visitor = new PostgresDatabaseColumnVisitor(context);
+      formulaField.accept(visitor);
+
+      expect(capturedContext?.isGeneratedColumn).toBe(true);
+      expect(mockIntegerFn).toHaveBeenCalledWith('test_field');
+      // The exact timestamp will vary, so we just check the pattern
+      expect(mockSpecificTypeFn).toHaveBeenCalledWith(
+        getGeneratedColumnName('test_field'),
+        expect.stringMatching(
+          /INTEGER GENERATED ALWAYS AS \(EXTRACT\(YEAR FROM '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}'::timestamp\)\) STORED/
+        )
+      );
+    });
+  });
+
+  describe('SqliteDatabaseColumnVisitor - Non-deterministic function replacement', () => {
+    let sqliteContext: IDatabaseColumnContext;
+
+    beforeEach(() => {
+      mockKnex.client.config.client = 'sqlite3';
+      sqliteContext = {
+        ...context,
+        dbProvider: mockSqliteDbProvider,
+      };
+    });
+
+    it('should pass isGeneratedColumn context for SQLite generated columns', () => {
+      // Mock the convertFormula to capture the context and return a realistic SQL with current timestamp
+      let capturedContext: IFormulaConversionContext | undefined;
+      (mockSqliteDbProvider.convertFormula as Mock).mockImplementation(
+        (_expression: string, context: IFormulaConversionContext) => {
+          capturedContext = context;
+          // Simulate what would happen with YEAR(NOW()) in generated column context
+          const currentTimestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
+          return {
+            sql: `CAST(STRFTIME('%Y', '${currentTimestamp}') AS INTEGER)`,
+            dependencies: [],
+          };
+        }
+      );
+
+      const formulaField = plainToInstance(FormulaFieldCore, {
+        id: 'fld123',
+        name: 'Formula Field',
+        type: FieldType.Formula,
+        dbFieldType: DbFieldType.Integer,
+        cellValueType: CellValueType.Number,
+        dbFieldName: 'test_field',
+        options: {
+          expression: 'YEAR(NOW())',
+          dbGenerated: true,
+        },
+      });
+
+      const visitor = new SqliteDatabaseColumnVisitor(sqliteContext);
+      formulaField.accept(visitor);
+
+      expect(capturedContext?.isGeneratedColumn).toBe(true);
+      expect(mockIntegerFn).toHaveBeenCalledWith('test_field');
+      // The exact timestamp will vary, so we just check the pattern
+      expect(mockSpecificTypeFn).toHaveBeenCalledWith(
+        getGeneratedColumnName('test_field'),
+        expect.stringMatching(
+          /INTEGER GENERATED ALWAYS AS \(CAST\(STRFTIME\('%Y', '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}'\) AS INTEGER\)\) VIRTUAL/
+        )
+      );
+    });
   });
 });