Swift: Update data

from(_:).update(_:transforms:precondition:) starts a KizunaSyncWriteBuilder that patches every row a chained filter matches; execute() sends it as one Write with filters call and answers the primary keys touched. apply(table:pk:op:...) is the low-level call that patches one row by primary key directly. Only the columns given are touched; every other column keeps the value the local database holds.

Examples#

One row, by primary key#

// TodoApp/TodoListView.swift (excerpt)
import KizunaSync

try await kizunasync.apply(
  table: "todos",
  pk: todoId,
  op: .update,
  columns: ["done": true]
)

Every matching row, with the write builder#

// TodoApp/TodoListView.swift (excerpt)
import KizunaSync

let pks = try await kizunasync.from("todos")
  .update(["done": true])
  .eq("done", false)
  .execute()

Return the updated rows#

// TodoApp/TodoListView.swift (excerpt)
import KizunaSync

let completed = try await kizunasync.from("todos")
  .update(["done": true])
  .eq("done", false)
  .maxAffected(50)
  .select("id, title")
  .execute() as? [[String: Any]]

The rows come back as a read reports them after the update. When more than 50 rows match, nothing is written and the call throws LOCAL_CONSTRAINT.

With a precondition#

// TodoApp/TodoListView.swift (excerpt)
import KizunaSync

try await kizunasync.apply(
  table: "todos",
  pk: todoId,
  op: .update,
  columns: ["title": "works on a plane"],
  precondition: ["done": false]
)

The local row changes right away. The server compares precondition against the row its own policies let it read, and answers a mismatch with a PRECONDITION rejection, which reverts the optimistic value.

With a transform#

// TodoApp/TodoListView.swift (excerpt)
import KizunaSync

try await kizunasync.apply(
  table: "todos",
  pk: todoId,
  op: .update,
  columns: [:],
  transforms: ["views": ["op": "increment", "by": 1]]
)

Parameters#

from(_:).update(_:transforms:precondition:)#

The returned KizunaSyncWriteBuilder then chains every filter Using filters documents, except search and textSearch, which stay read-only and are not on this builder. execute() async throws -> [String] sends the write once at least one filter is chained. The builder also takes:

apply(table:pk:op:columns:mutationId:transforms:precondition:)#

Returns#

apply answers Void; the write builder's execute() answers [String], the primary keys that matched. Both are async throws and run the engine call on a dedicated dispatch queue, so neither ever blocks the main actor.

Errors#

apply throws KizunaSyncError.engine(code: "LOCAL_UNSUPPORTED", message: "apply requires table and pk") inside the client when table or pk is empty, before the engine is reached. A value the platform serializer refuses never reaches the engine: JSONSerialization raises inside the client first, so it surfaces as a serialization error rather than an engine code.

Notes#

Supabase documents the column payload and its examples on update(). This page adds only what local-first changes. The update is optimistic: it commits locally at once, and its verdict arrives with a later Sync. Two peers that write different columns of one row both keep their value, because the merge is per column. Two peers that write the same column settle by the mode the table is configured with, and the loser is reported as COLUMN_OVERWRITTEN on Subscribe to events. Conflict resolution explains the rule. The queued mutation waits in the outbox until a run delivers it, the path Offline writes walks through.

An update whose row is missing locally writes the assigned columns as the whole row rather than failing, because the mutation is already queued for the server. That shape does not clear a tombstone a peer's delete left behind, so a deleted row is not revived by a late edit.

The write builder is a convenience over Write with filters: it targets rows a chained filter matches rather than one primary key, which is the shape a bulk edit like "mark every open todo done" wants.

Related reference#

• Insert data
• Delete data
• Write with filters
• Using transforms
• List rejections
• Kotlin: Update data
• JavaScript: Update data