Bulk writes

`createMany`

const { created, failed } = await pawabase.from("tasks").createMany(
  [{ title: "One" }, { title: "Two" }, { title: "" }],
  { concurrency: 5, stopOnError: false },
);

created.length;      // 2
for (const f of failed) console.log("row", f.index, "failed:", f.error);

result = pb.from_("tasks").create_many([{"title": "One"}, {"title": "Two"}, {"title": ""}], stop_on_error=False)
result.created      # the saved records
result.failed       # [{index, error}]

It sends several creates in parallel and tells you which succeeded and which failed (with the row’s position), so one bad row doesn’t lose the rest. It is not one transaction: if you need all-or-nothing, see below.

Option	Meaning
`concurrency`	How many requests at once. Default 5
`stopOnError` (`stop_on_error`)	Stop sending more after the first failure

In Python the async client runs rows concurrently (concurrency= there); the sync client sends them in order.

All or nothing: a transaction

When several writes must succeed together (move stock and create the order, or neither), do them in a flow with the Transaction block. Its operations is a list; either every write lands or none does:

[
  { "op": "update", "resource": "products", "id": "{{ input.product_id }}", "data": { "stock": "{{ vars.new_stock }}" } },
  { "op": "create", "resource": "orders", "data": { "product_id": "{{ input.product_id }}", "customer_id": "{{ auth.user_id }}" } },
  { "op": "delete", "resource": "cart_items", "id": "{{ input.cart_item_id }}" }
]

Field	Meaning
`op`	`create`, `update` or `delete`
`resource`	The table
`id`	The record, for `update` and `delete`
`data`	The fields, for `create` and `update`

The block outputs the results in order. An update of a record that doesn’t exist fails the whole transaction with not_found, and nothing is written. Events for the records it created and updated are emitted only after the transaction has committed; deletes made in a transaction don’t emit events. Call the flow from your app with pawabase.flows.run(...), or make it a route. The flow runs with its own authority, so check who’s asking (a Require sign-in or Check policy block) before the transaction.

Update or delete many

Query, then act on each:

const { data } = await pawabase.from("tasks").eq("done", true).lt("updated_at", cutoff).perPage(100);
await Promise.all(data.map((t) => pawabase.from("tasks").delete(t.id)));

Keep concurrency modest (batches of 20 to 50) so you don’t hit your table’s rate limit. For thousands of rows, do it on a server (a flow, or SQL) where it is one operation.

When to use import instead

You have	Use
Up to a few hundred rows from your app	`createMany`
A file, or thousands of rows, with updates or duplicates	Import: validates, upserts, dry run, no events by default
A large one-time fix	The SQL editor, after a backup

Progress

For a progress bar, chunk it yourself:

for (let i = 0; i < rows.length; i += 50) {
  const batch = rows.slice(i, i + 50);
  const { failed } = await pawabase.from("tasks").createMany(batch);
  setProgress(Math.min(i + 50, rows.length) / rows.length);
  allFailures.push(...failed.map((f) => ({ ...f, index: f.index + i })));
}

Write records

Single writes.

Import and export

For files and large loads.

Getting started

Define your data

Change safely

Read and write

Protect and shape

Studio tools

Build well

`createMany`

All or nothing: a transaction

Update or delete many

When to use import instead

Progress

Write records

Import and export

​createMany

​All or nothing: a transaction

​Update or delete many

​When to use import instead

​Progress

Write records

Import and export

`createMany`

All or nothing: a transaction

Update or delete many

When to use import instead

Progress