perf(table): remove two round trips from every single-row update

A single-cell PATCH spends far more time in sequential round trips to a remote
Postgres than in the UPDATE it issues. Prepared statements are disabled for
PgBouncer transaction mode, so every await is a full Parse/Bind/Execute.

Two of them were avoidable.

getRowById issued the row lookup and its executions sidecar in series, but the
sidecar is keyed on the row id the caller already supplied, so it never
depended on the lookup. Issuing both together makes it one round trip. A miss
now pays one redundant sidecar read, which is the rare path and costs no extra
wall time.

The uniqueness probe ran whenever the table had any unique column, passing the
fully merged row, so editing an unrelated cell re-probed every unique column —
its own transaction plus one query per column. It is now scoped to the columns
the patch actually writes. A merge cannot newly violate uniqueness on a column
it leaves alone: that value is the one already stored, and it satisfied the
constraint when it was written.

Sized before changing: few tables declare a unique column, but write traffic
concentrates in the ones that do, so this is the larger of the two savings in
practice.

Verified to fail: reverting the probe scoping turns the covering test red.

Author: waleedlatif1

apps/sim/lib/api/contracts/tables.ts

@@ -1433,6 +1433,22 @@ export const upsertTableRowContract = defineRouteContract({
   },
 })
 
+/**
+ * Reads one row. The sibling of {@link updateTableRowContract} and
+ * {@link deleteTableRowContract}, which take their workspace scope from a body;
+ * a GET has none, so it is asserted on the query string instead.
+ */
+export const getTableRowContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/table/[tableId]/rows/[rowId]',
+  params: tableRowParamsSchema,
+  query: getTableQuerySchema,
+  response: {
+    mode: 'json',
+    schema: successResponseSchema(z.object({ row: tableRowSchema })),
+  },
+})
+
 export const updateTableRowContract = defineRouteContract({
   method: 'PATCH',
   path: '/api/table/[tableId]/rows/[rowId]',

apps/sim/lib/table/__tests__/update-row.test.ts

@@ -548,3 +548,98 @@ describe('batchUpdateRows — per-row partial merge', () => {
     expect(values).not.toContain(JSON.stringify({ name: 'Alice', age: 31 }))
   })
 })
+
+/**
+ * The uniqueness probe opens its own transaction and queries once per unique
+ * column, so on a table that has any unique column it used to cost several
+ * round trips on every edit — including edits nowhere near one. It is now
+ * scoped to the columns the patch actually writes.
+ *
+ * The safety argument is that a merge cannot newly violate uniqueness on a
+ * column it leaves alone: that value is the one already stored, and it
+ * satisfied the constraint when it was written.
+ */
+describe('updateRow — uniqueness probe scoping', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetDbChainMock()
+    dbChainMockFns.limit.mockResolvedValue([EXISTING_ROW])
+    dbChainMockFns.returning.mockResolvedValue([
+      { id: EXISTING_ROW.id, updatedAt: PERSISTED_UPDATED_AT },
+    ])
+  })
+
+  it('does not probe when the patch touches no unique column', async () => {
+    const { checkUniqueConstraintsDb, getUniqueColumns } = await import('@/lib/table/validation')
+    vi.mocked(getUniqueColumns).mockReturnValue([{ name: 'name', type: 'string', unique: true }])
+
+    await updateRow(
+      { tableId: 'tbl-1', rowId: 'row-1', data: { age: 31 }, workspaceId: 'ws-1' },
+      TABLE,
+      'req-1'
+    )
+
+    expect(checkUniqueConstraintsDb).not.toHaveBeenCalled()
+  })
+
+  it('still probes when the patch touches a unique column', async () => {
+    const { checkUniqueConstraintsDb, getUniqueColumns } = await import('@/lib/table/validation')
+    vi.mocked(getUniqueColumns).mockReturnValue([{ name: 'name', type: 'string', unique: true }])
+
+    await updateRow(
+      { tableId: 'tbl-1', rowId: 'row-1', data: { name: 'Grace' }, workspaceId: 'ws-1' },
+      TABLE,
+      'req-1'
+    )
+
+    expect(checkUniqueConstraintsDb).toHaveBeenCalledTimes(1)
+  })
+
+  it('probes against the merged row, so the excluded row is still the one being edited', async () => {
+    const { checkUniqueConstraintsDb, getUniqueColumns } = await import('@/lib/table/validation')
+    vi.mocked(getUniqueColumns).mockReturnValue([{ name: 'name', type: 'string', unique: true }])
+
+    await updateRow(
+      { tableId: 'tbl-1', rowId: 'row-1', data: { name: 'Grace' }, workspaceId: 'ws-1' },
+      TABLE,
+      'req-1'
+    )
+
+    expect(checkUniqueConstraintsDb).toHaveBeenCalledWith(
+      'tbl-1',
+      { name: 'Grace', age: 30 },
+      TABLE.schema,
+      'row-1'
+    )
+  })
+
+  it('surfaces a duplicate on a column the patch does write', async () => {
+    const { checkUniqueConstraintsDb, getUniqueColumns } = await import('@/lib/table/validation')
+    vi.mocked(getUniqueColumns).mockReturnValue([{ name: 'name', type: 'string', unique: true }])
+    vi.mocked(checkUniqueConstraintsDb).mockResolvedValueOnce({
+      valid: false,
+      errors: ['Duplicate value for name'],
+    })
+
+    await expect(
+      updateRow(
+        { tableId: 'tbl-1', rowId: 'row-1', data: { name: 'Grace' }, workspaceId: 'ws-1' },
+        TABLE,
+        'req-1'
+      )
+    ).rejects.toThrow(/Duplicate value for name/)
+  })
+
+  it('does not probe on a table with no unique columns at all', async () => {
+    const { checkUniqueConstraintsDb, getUniqueColumns } = await import('@/lib/table/validation')
+    vi.mocked(getUniqueColumns).mockReturnValue([])
+
+    await updateRow(
+      { tableId: 'tbl-1', rowId: 'row-1', data: { name: 'Grace' }, workspaceId: 'ws-1' },
+      TABLE,
+      'req-1'
+    )
+
+    expect(checkUniqueConstraintsDb).not.toHaveBeenCalled()
+  })
+})

apps/sim/lib/table/rows/service.ts

@@ -1422,22 +1422,28 @@ export async function getRowById(
   rowId: string,
   workspaceId: string
 ): Promise<TableRow | null> {
-  const results = await db
-    .select()
-    .from(userTableRows)
-    .where(
-      and(
-        eq(userTableRows.id, rowId),
-        eq(userTableRows.tableId, tableId),
-        eq(userTableRows.workspaceId, workspaceId)
+  // The executions sidecar is keyed on the row id the caller already gave us, so
+  // it does not depend on the row lookup — issuing both together makes this one
+  // round trip instead of two. A miss pays one redundant sidecar read, which is
+  // the rare path and costs no extra wall time.
+  const [results, executions] = await Promise.all([
+    db
+      .select()
+      .from(userTableRows)
+      .where(
+        and(
+          eq(userTableRows.id, rowId),
+          eq(userTableRows.tableId, tableId),
+          eq(userTableRows.workspaceId, workspaceId)
+        )
       )
-    )
-    .limit(1)
+      .limit(1),
+    loadExecutionsForRow(db, rowId),
+  ])
 
   if (results.length === 0) return null
 
   const row = results[0]
-  const executions = await loadExecutionsForRow(db, row.id)
   return {
     id: row.id,
     data: row.data as RowData,
@@ -1604,9 +1610,19 @@ export async function updateRow(
     )
   }
 
-  // Check unique constraints using optimized database query
-  const uniqueColumns = getUniqueColumns(table.schema)
-  if (uniqueColumns.length > 0) {
+  // Check unique constraints using optimized database query.
+  //
+  // Scoped to the columns this patch actually writes. A merge cannot newly
+  // violate uniqueness on a column it leaves alone: that value is the one
+  // already stored, and it satisfied the constraint when it was written. The
+  // probe opens its own transaction and queries once per unique column, so on a
+  // table that has any unique column this was several round trips on every
+  // edit, including edits nowhere near one.
+  const patchedColumnIds = new Set(Object.keys(data.data))
+  const patchedUniqueColumns = getUniqueColumns(table.schema).filter((column) =>
+    patchedColumnIds.has(getColumnId(column))
+  )
+  if (patchedUniqueColumns.length > 0) {
     const uniqueValidation = await checkUniqueConstraintsDb(
       data.tableId,
       mergedData,