fix: table comparsion query for date type column

apps/sim/app/api/table/[tableId]/rows/route.ts

@@ -266,8 +266,10 @@ export const GET = withRouteHandler(
         eq(userTableRows.workspaceId, validated.workspaceId),
       ]
 
+      const schema = table.schema as TableSchema
+
       if (validated.filter) {
-        const filterClause = buildFilterClause(validated.filter as Filter, USER_TABLE_ROWS_SQL_NAME)
+        const filterClause = buildFilterClause(validated.filter as Filter, USER_TABLE_ROWS_SQL_NAME, schema.columns)
         if (filterClause) {
           baseConditions.push(filterClause)
         }
@@ -286,7 +288,6 @@ export const GET = withRouteHandler(
         .where(and(...baseConditions))
 
       if (validated.sort) {
-        const schema = table.schema as TableSchema
         const sortClause = buildSortClause(validated.sort, USER_TABLE_ROWS_SQL_NAME, schema.columns)
         if (sortClause) {
           query = query.orderBy(sortClause) as typeof query
@@ -509,6 +510,7 @@ export const DELETE = withRouteHandler(
           limit: validated.limit,
           workspaceId: validated.workspaceId,
         },
+        table,
         requestId
       )
 

apps/sim/app/api/v1/tables/[tableId]/rows/route.ts

@@ -158,8 +158,10 @@ export const GET = withRouteHandler(async (request: NextRequest, context: TableR
       eq(userTableRows.workspaceId, validated.workspaceId),
     ]
 
+    const schema = table.schema as TableSchema
+
     if (validated.filter) {
-      const filterClause = buildFilterClause(validated.filter as Filter, USER_TABLE_ROWS_SQL_NAME)
+      const filterClause = buildFilterClause(validated.filter as Filter, USER_TABLE_ROWS_SQL_NAME, schema.columns)
       if (filterClause) {
         baseConditions.push(filterClause)
       }
@@ -177,7 +179,6 @@ export const GET = withRouteHandler(async (request: NextRequest, context: TableR
       .where(and(...baseConditions))
 
     if (validated.sort) {
-      const schema = table.schema as TableSchema
       const sortClause = buildSortClause(validated.sort, USER_TABLE_ROWS_SQL_NAME, schema.columns)
       if (sortClause) {
         query = query.orderBy(sortClause) as typeof query
@@ -490,6 +491,7 @@ export const DELETE = withRouteHandler(
           limit: validated.limit,
           workspaceId: validated.workspaceId,
         },
+        table,
         requestId
       )
 

apps/sim/lib/copilot/tools/server/table/user-table.ts

@@ -474,6 +474,11 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             return { success: false, message: 'Workspace ID is required' }
           }
 
+          const table = await getTableById(args.tableId)
+          if (!table) {
+            return { success: false, message: `Table not found: ${args.tableId}` }
+          }
+
           const requestId = generateId().slice(0, 8)
           const result = await queryRows(
             args.tableId,
@@ -483,6 +488,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
               sort: args.sort,
               limit: args.limit,
               offset: args.offset,
+              columns: table.schema.columns,
             },
             requestId
           )
@@ -605,6 +611,11 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             return { success: false, message: 'Workspace ID is required' }
           }
 
+          const table = await getTableById(args.tableId)
+          if (!table) {
+            return { success: false, message: `Table not found: ${args.tableId}` }
+          }
+
           const requestId = generateId().slice(0, 8)
           assertNotAborted()
           const result = await deleteRowsByFilter(
@@ -614,6 +625,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
               limit: args.limit,
               workspaceId,
             },
+            table,
             requestId
           )
 

apps/sim/lib/table/__tests__/sql.test.ts

@@ -5,10 +5,29 @@
  *
  * Tests for the table SQL query builder utilities including filter and sort clause generation.
  */
+import type { SQL } from 'drizzle-orm'
 import { describe, expect, it } from 'vitest'
 import { buildFilterClause, buildSortClause } from '../sql'
 import type { Filter } from '../types'
 
+/**
+ * Serializes a drizzle SQL object to a flat string for assertion.
+ * Works with both real SQL instances (queryChunks) and the test-environment mock (strings/values).
+ */
+function getRawSqlString(sqlObj: SQL): string {
+  const obj = sqlObj as unknown as Record<string, unknown>
+  if (Array.isArray(obj['queryChunks'])) {
+    return (obj['queryChunks'] as unknown[])
+      .map((chunk) => {
+        if (typeof chunk === 'string') return chunk
+        const raw = chunk as { value?: string[] }
+        return raw.value?.join('') ?? ''
+      })
+      .join('')
+  }
+  return JSON.stringify(sqlObj)
+}
+
 describe('SQL Builder', () => {
   describe('buildFilterClause', () => {
     const tableName = 'user_table_rows'
@@ -171,6 +190,83 @@ describe('SQL Builder', () => {
 
       expect(result).toBeDefined()
     })
+
+    describe('date column type', () => {
+      const dateColumns = [{ name: 'birthDate', type: 'date' as const }]
+
+      it('should use ::timestamp cast for $gt with date column type', () => {
+        const filter: Filter = { birthDate: { $gt: '2024-01-01' } }
+        const result = buildFilterClause(filter, tableName, dateColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::timestamp')
+        expect(raw).not.toContain('::numeric')
+      })
+
+      it('should use ::timestamp cast for $gte with date column type', () => {
+        const filter: Filter = { birthDate: { $gte: '2024-01-01' } }
+        const result = buildFilterClause(filter, tableName, dateColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::timestamp')
+        expect(raw).not.toContain('::numeric')
+      })
+
+      it('should use ::timestamp cast for $lt with date column type', () => {
+        const filter: Filter = { birthDate: { $lt: '2024-12-31' } }
+        const result = buildFilterClause(filter, tableName, dateColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::timestamp')
+        expect(raw).not.toContain('::numeric')
+      })
+
+      it('should use ::timestamp cast for $lte with date column type', () => {
+        const filter: Filter = { birthDate: { $lte: '2024-12-31' } }
+        const result = buildFilterClause(filter, tableName, dateColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::timestamp')
+        expect(raw).not.toContain('::numeric')
+      })
+
+      it('should use ::timestamp cast for date range ($gte + $lte)', () => {
+        const filter: Filter = { birthDate: { $gte: '2024-01-01', $lte: '2024-12-31' } }
+        const result = buildFilterClause(filter, tableName, dateColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::timestamp')
+        expect(raw).not.toContain('::numeric')
+      })
+
+      it('should use ::timestamp cast inside $and with date column type', () => {
+        const filter: Filter = {
+          $and: [{ birthDate: { $gte: '2024-01-01' } }, { birthDate: { $lte: '2024-12-31' } }],
+        }
+        const result = buildFilterClause(filter, tableName, dateColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::timestamp')
+        expect(raw).not.toContain('::numeric')
+      })
+
+      it('should still use ::numeric cast for $gt on a number column', () => {
+        const numberColumns = [{ name: 'age', type: 'number' as const }]
+        const filter: Filter = { age: { $gt: 18 } }
+        const result = buildFilterClause(filter, tableName, numberColumns)
+
+        expect(result).toBeDefined()
+        const raw = getRawSqlString(result!)
+        expect(raw).toContain('::numeric')
+        expect(raw).not.toContain('::timestamp')
+      })
+    })
   })
 
   describe('buildSortClause', () => {

apps/sim/lib/table/service.ts

@@ -1435,7 +1435,7 @@ export async function queryRows(
 
   let whereClause = baseConditions
   if (filter && Object.keys(filter).length > 0) {
-    const filterClause = buildFilterClause(filter, tableName)
+    const filterClause = buildFilterClause(filter, tableName, options.columns)
     if (filterClause) {
       whereClause = and(baseConditions, filterClause)
     }
@@ -1453,7 +1453,7 @@ export async function queryRows(
   // Build ORDER BY clause (default to position ASC for stable ordering)
   let orderByClause
   if (sort && Object.keys(sort).length > 0) {
-    orderByClause = buildSortClause(sort, tableName)
+    orderByClause = buildSortClause(sort, tableName, options.columns)
   }
 
   // Execute query
@@ -1818,7 +1818,7 @@ export async function updateRowsByFilter(
 ): Promise<BulkOperationResult> {
   const tableName = USER_TABLE_ROWS_SQL_NAME
 
-  const filterClause = buildFilterClause(data.filter, tableName)
+  const filterClause = buildFilterClause(data.filter, tableName, (table.schema as TableSchema).columns)
   if (!filterClause) {
     throw new Error('Filter is required for bulk update')
   }
@@ -2119,17 +2119,19 @@ async function recompactPositions(tableId: string, trx: DbTransaction, minDelete
  * Deletes multiple rows matching a filter.
  *
  * @param data - Bulk delete data
+ * @param table - Table definition used to emit correct SQL casts in filter expressions
  * @param requestId - Request ID for logging
  * @returns Bulk operation result
  */
 export async function deleteRowsByFilter(
   data: BulkDeleteData,
+  table: TableDefinition,
   requestId: string
 ): Promise<BulkOperationResult> {
   const tableName = USER_TABLE_ROWS_SQL_NAME
 
   // Build filter clause
-  const filterClause = buildFilterClause(data.filter, tableName)
+  const filterClause = buildFilterClause(data.filter, tableName, (table.schema as TableSchema).columns)
   if (!filterClause) {
     throw new Error('Filter is required for bulk delete')
   }

apps/sim/lib/table/sql.ts

@@ -64,8 +64,13 @@ const ALLOWED_OPERATORS = new Set([
  * // Logical operators
  * buildFilterClause({ $or: [{ status: 'active' }, { verified: true }] }, 'user_table_rows')
  */
-export function buildFilterClause(filter: Filter, tableName: string): SQL | undefined {
+export function buildFilterClause(
+  filter: Filter,
+  tableName: string,
+  columns?: ColumnDefinition[]
+): SQL | undefined {
   const conditions: SQL[] = []
+  const columnTypeMap = new Map(columns?.map((col) => [col.name, col.type]))
 
   for (const [field, condition] of Object.entries(filter)) {
     if (condition === undefined) {
@@ -75,7 +80,7 @@ export function buildFilterClause(filter: Filter, tableName: string): SQL | unde
     // This represents a case where the filter is a logical OR of multiple filters
     // e.g. { $or: [{ status: 'active' }, { status: 'pending' }] }
     if (field === '$or' && Array.isArray(condition)) {
-      const orClause = buildLogicalClause(condition as Filter[], tableName, 'OR')
+      const orClause = buildLogicalClause(condition as Filter[], tableName, 'OR', columns)
       if (orClause) {
         conditions.push(orClause)
       }
@@ -85,7 +90,7 @@ export function buildFilterClause(filter: Filter, tableName: string): SQL | unde
     // This represents a case where the filter is a logical AND of multiple filters
     // e.g. { $and: [{ status: 'active' }, { status: 'pending' }] }
     if (field === '$and' && Array.isArray(condition)) {
-      const andClause = buildLogicalClause(condition as Filter[], tableName, 'AND')
+      const andClause = buildLogicalClause(condition as Filter[], tableName, 'AND', columns)
       if (andClause) {
         conditions.push(andClause)
       }
@@ -103,7 +108,8 @@ export function buildFilterClause(filter: Filter, tableName: string): SQL | unde
     const fieldConditions = buildFieldCondition(
       tableName,
       field,
-      condition as JsonValue | ConditionOperators
+      condition as JsonValue | ConditionOperators,
+      columnTypeMap.get(field)
     )
     conditions.push(...fieldConditions)
   }
@@ -208,7 +214,8 @@ function validateOperator(operator: string): void {
 function buildFieldCondition(
   tableName: string,
   field: string,
-  condition: JsonValue | ConditionOperators
+  condition: JsonValue | ConditionOperators,
+  columnType?: string
 ): SQL[] {
   validateFieldName(field)
 
@@ -231,19 +238,19 @@ function buildFieldCondition(
           break
 
         case '$gt':
-          conditions.push(buildComparisonClause(tableName, field, '>', value as number))
+          conditions.push(buildComparisonClause(tableName, field, '>', value as number | string, columnType))
           break
 
         case '$gte':
-          conditions.push(buildComparisonClause(tableName, field, '>=', value as number))
+          conditions.push(buildComparisonClause(tableName, field, '>=', value as number | string, columnType))
           break
 
         case '$lt':
-          conditions.push(buildComparisonClause(tableName, field, '<', value as number))
+          conditions.push(buildComparisonClause(tableName, field, '<', value as number | string, columnType))
           break
 
         case '$lte':
-          conditions.push(buildComparisonClause(tableName, field, '<=', value as number))
+          conditions.push(buildComparisonClause(tableName, field, '<=', value as number | string, columnType))
           break
 
         case '$in':
@@ -312,11 +319,12 @@ function buildFieldCondition(
 function buildLogicalClause(
   subFilters: Filter[],
   tableName: string,
-  operator: 'OR' | 'AND'
+  operator: 'OR' | 'AND',
+  columns?: ColumnDefinition[]
 ): SQL | undefined {
   const clauses: SQL[] = []
   for (const subFilter of subFilters) {
-    const clause = buildFilterClause(subFilter, tableName)
+    const clause = buildFilterClause(subFilter, tableName, columns)
     if (clause) {
       clauses.push(clause)
     }
@@ -334,15 +342,24 @@ function buildContainmentClause(tableName: string, field: string, value: JsonVal
   return sql`${sql.raw(`${tableName}.data`)} @> ${jsonObj}::jsonb`
 }
 
-/** Builds numeric comparison: `(data->>'field')::numeric <op> value` (cannot use GIN index) */
+/**
+ * Builds a range comparison: `(data->>'field')::<type> <op> value` (cannot use GIN index).
+ * Uses `::timestamp` when `columnType === 'date'`, otherwise `::numeric`.
+ */
 function buildComparisonClause(
   tableName: string,
   field: string,
   operator: '>' | '>=' | '<' | '<=',
-  value: number
+  value: number | string,
+  columnType?: string
 ): SQL {
   const escapedField = field.replace(/'/g, "''")
-  return sql`(${sql.raw(`${tableName}.data->>'${escapedField}'`)})::numeric ${sql.raw(operator)} ${value}`
+  const extract = sql.raw(`${tableName}.data->>'${escapedField}'`)
+  const isDate = columnType === 'date'
+  if (isDate) {
+    return sql`(${extract})::timestamp ${sql.raw(operator)} ${value}::timestamp`
+  }
+  return sql`(${extract})::numeric ${sql.raw(operator)} ${value}`
 }
 
 /** Escapes LIKE/ILIKE wildcard characters so they match literally */