Close the table, flushing all pending writes to disk.

Delete all objects in the table (keeps the table open).

Delete all values for the given key.

This operation is idempotent — deleting a key that does not exist succeeds with Ok(Nil).

Delete all occurrences of a specific key-value pair from the table.

In a duplicate bag, this removes every copy of the exact pair. Other values (or different duplicates) for the same key are preserved.

import gleam/dynamic/decode
let assert Ok(table) = duplicate_bag.open("events.dets",
  key_decoder: decode.string, value_decoder: decode.string)
let assert Ok(Nil) = duplicate_bag.insert(table, "click", "btn_a")
let assert Ok(Nil) = duplicate_bag.insert(table, "click", "btn_a")
let assert Ok(Nil) = duplicate_bag.insert(table, "click", "btn_b")
let assert Ok(Nil) = duplicate_bag.delete_object(table, "click", "btn_a")
// Only "btn_b" remains

Fold over all entries. Order is unspecified.

Returns Error(DecodeErrors(_)) if any entry doesn’t match the expected types. The fold stops at the first decode error. If the callback raises, the exception is re-raised.

Fold over all entries, passing decode results to the callback.

Unlike fold, decode failures do not abort the traversal. Each entry is presented to the callback as Ok(#(key, value)) on success or Error(decode_errors) on failure, letting the caller decide how to handle bad records.

DETS-level errors (e.g., the table does not exist) still fail the entire operation via the outer Result. If the callback raises, the exception is re-raised.

Examples

Skip entries that fail to decode:

duplicate_bag.fold_results(table, [], fn(acc, entry) {
  case entry {
    Ok(#(key, value)) -> [#(key, value), ..acc]
    Error(_) -> acc
  }
})

Partition into successes and failures:

duplicate_bag.fold_results(table, #([], []), fn(acc, entry) {
  case entry {
    Ok(#(key, value)) -> #([#(key, value), ..acc.0], acc.1)
    Error(errors) -> #(acc.0, [errors, ..acc.1])
  }
})

Get the file size, object count, and absolute file path of an open table.

Returns Error(TableDoesNotExist) if the table is no longer open.

Insert a key-value pair. Duplicates are stored separately.

Unlike set and bag tables, duplicate bag does not provide an insert_new function because duplicate key-value pairs are explicitly allowed.

Insert multiple key-value pairs.

Look up all values for a key.

Returns Ok([]) if the key does not exist. This differs from set.lookup, which returns Error(NotFound) for missing keys. Returns Error(DecodeErrors(_)) if any stored value doesn’t match the expected type.

Check if a key exists without returning the values.

Open or create a DETS duplicate bag table at the given file path.

Decoders are used to validate data read from disk, ensuring type safety even when opening files created by other code or previous runs.

import gleam/dynamic/decode
let assert Ok(table) = duplicate_bag.open("data/events.dets",
  key_decoder: decode.string, value_decoder: decode.string)

Open or create a DETS duplicate bag table with a specific repair policy.

The repair policy controls what happens when the table file was not closed cleanly (e.g., after a crash):

• AutoRepair — silently repair the file if needed (default for open)
• ForceRepair — repair even if the file appears clean
• NoRepair — return an error instead of repairing

import gleam/dynamic/decode
import slate.{ForceRepair}
let assert Ok(table) = duplicate_bag.open_with(path: "data/events.dets",
  repair: ForceRepair,
  key_decoder: decode.string, value_decoder: decode.string)

Open a DETS duplicate bag table with repair and access mode options.

Use ReadOnly to open a table for reading only. Write operations on a read-only table will return Error(AccessDenied(context)).

import gleam/dynamic/decode
import slate.{AutoRepair, ReadOnly}
let assert Ok(table) = duplicate_bag.open_with_access(path: "data/events.dets",
  repair: AutoRepair, access: ReadOnly,
  key_decoder: decode.string, value_decoder: decode.string)
let assert Ok(values) = duplicate_bag.lookup(table, key: "key")
// duplicate_bag.insert(table, "key", "val") would return Error(AccessDenied(context))

Return the number of objects stored.

Flush pending writes to disk without closing the table.

DETS auto-syncs periodically, so this is only needed when you require a durability guarantee at a specific point (e.g., after a critical write).

Return all key-value pairs as a list.

Warning: loads entire table into memory. Returns Error(DecodeErrors(_)) if any entry doesn’t match the expected types.

Use a table within a callback with repair and access mode options.

Pass AutoRepair and ReadWrite to keep the behavior of slate 1.x. Uses the same options as open_with_access. ReadOnly requires an existing file, and writes return Error(AccessDenied(context)). NoRepair returns Error(NeedsRepair(context)) if the file was not closed cleanly.

If opening fails, returns the open error without calling the callback. Otherwise, closes the table before returning the callback result. If close fails after a successful callback, returns the close error. If both fail, returns the callback error. If the callback raises, attempts close before re-raising the original exception.

Keep the table handle within the callback; do not use it after cleanup. This cannot guarantee cleanup if the process is killed.

import gleam/dynamic/decode
import slate.{NoRepair, ReadOnly}
import slate/duplicate_bag

use table <- duplicate_bag.with_table(path: "data/events.dets",
  repair: NoRepair, access: ReadOnly,
  key_decoder: decode.string, value_decoder: decode.string)
duplicate_bag.lookup(table, key: "click")