Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var ErrReadAfterWriteInTransaction = errors.New("firestore: read after write in transaction")
ErrReadAfterWriteInTransaction matches the ordering error returned by Firestore transactions when a read follows a queued write.
Functions ¶
func NewBranchingProvider ¶ added in v0.63.2
NewBranchingProvider returns the optional database branching capability for dalgo2memory's default serialized storage engine.
Columnar and custom storage engines are intentionally outside this capability. Capture reports them as branching.UnsupportedError instead of publishing an incomplete checkpoint.
func NewDB ¶
NewDB creates an in-memory DALgo database.
The backend is wrapped by dal.NewDB, so writes through the returned DB run the framework write pipeline — record validation and before-save hooks — before reaching the in-memory store.
func WithCollection ¶
func WithCollection[T any](name string, newRecord func() *T, opts ...CollectionOption) collectionDef
WithCollection registers a collection backed by the concrete record type T.
If newRecord is nil, a zero value (new(T)) is used to materialize each record read by a query. Provide a factory to populate default field values instead.
Trailing CollectionOption arguments select a per-collection storage engine; with none, the collection uses the default Serialized engine.
Types ¶
type CollectionOption ¶
type CollectionOption func(*collectionDef)
CollectionOption configures a collection definition produced by WithCollection — currently the per-collection storage-engine selection. Pass it as a trailing argument to WithCollection.
func WithColumnarStorage ¶
func WithColumnarStorage(opts ...ColumnOption) CollectionOption
WithColumnarStorage selects the columnar storage engine for a schema-registered WithCollection[T] collection, with optional per-column strategies and a per-collection ref-breaking override. Selecting columnar storage for a schemaless or non-struct collection fails with a descriptive error when the collection is used.
func WithSerializedStorage ¶
func WithSerializedStorage() CollectionOption
WithSerializedStorage selects the Serialized storage engine for a collection. It is the default engine, so this option states the default explicitly; an option-less collection behaves identically.
type ColumnOption ¶
type ColumnOption func(*columnarConfig)
ColumnOption configures a single aspect of a columnar collection: it either supplies a ColumnStrategy for a named column (WithColumnStrategy) or sets the per-collection ref-breaking override (WithColumnarRefBreaking). It is passed to WithColumnarStorage. Exported so an out-of-core package can return one carrying its own ColumnStrategy without dalgo2memory importing it.
func WithColumnStrategy ¶
func WithColumnStrategy(name string, strategy ColumnStrategy) ColumnOption
WithColumnStrategy supplies a ColumnStrategy for the named column of a columnar collection. Columns without an explicit strategy use the default typed-slice strategy.
func WithColumnarRefBreaking ¶
func WithColumnarRefBreaking(refBreaking bool) ColumnOption
WithColumnarRefBreaking sets the per-collection ref-breaking override for a columnar collection, taking precedence over the schema-wide default (WithoutSchemaRefBreaking). Pass true to force faithful storage, false to store reference-bearing columns without the serialization round-trip.
func WithDeclaredColumn ¶
func WithDeclaredColumn[T any](name string) ColumnOption
WithDeclaredColumn declares a columnar column by name for a map-backed (map[string]any) collection, stored in a strongly-typed []T slice. At least one declared column is required to select columnar storage for a map-backed collection; undeclared fields are kept in a parallel leftover map. On a struct collection a declared column is accepted but redundant (the struct path reflects over the record type instead). When the same name is declared more than once, the last declaration wins.
type ColumnStrategy ¶
type ColumnStrategy interface {
// SetValue records that the column holds value at the given slot. The engine
// calls it on every write (insert/overwrite/update) for the column.
SetValue(slot int, value any)
// ClearValue records that the slot no longer holds a value for the column.
// The engine calls it on delete and during compaction rebuilds.
ClearValue(slot int)
// EqualSlots returns the live slots whose column equals value, with ok=true.
// Returning ok=false signals "no opinion": the engine falls back to scanning.
// Equality is the adapter's value equality (Go == on comparable decoded
// values, as in matchesWhere).
EqualSlots(value any) (slots SlotSet, ok bool)
}
ColumnStrategy backs a single column of a columnar collection. It is exported so an out-of-core package (e.g. a bitmap index) can supply a strategy via WithColumnStrategy without dalgo2memory importing it.
The engine remains the source of truth for stored values (its typed column slices); a strategy is an index kept in sync through the write side, used to accelerate the equality read side.
type Option ¶
type Option func(*database)
Option configures an in-memory database created by NewDB.
func WithNoReadsAfterWritesInTransaction ¶ added in v0.63.0
func WithNoReadsAfterWritesInTransaction() Option
WithNoReadsAfterWritesInTransaction enables Firestore-compatible transaction ordering for this in-memory database. In a read-write transaction, every read after the first successful write returns ErrReadAfterWriteInTransaction. It is intended for tests that need to catch Firestore-only ordering errors; the default in-memory behavior remains permissive.
func WithSchema ¶
WithSchema registers per-collection record types so that queries return records populated into the concrete Go type of the collection.
allowUndefinedCollections controls what happens when a query targets a collection that is not part of the schema: when false (the default intent) such a query returns an error; when true it falls back to the schemaless behavior (map[string]any / keys-only records).
func WithoutSchemaRefBreaking ¶
func WithoutSchemaRefBreaking() Option
WithoutSchemaRefBreaking disables columnar ref-breaking schema-wide: columnar collections store reference-bearing column values without the serialization round-trip unless a collection re-enables it (see WithColumnarRefBreaking). It has no effect on the always-faithful Serialized engine. The default is faithful (ref-breaking on).
type SlotSet ¶
type SlotSet map[int]struct{}
SlotSet is a set of per-row slot indices. The columnar engine assigns each live record a stable slot shared across all of a collection's column slices; a ColumnStrategy's equality read side returns the slots whose column equals a queried value. A set (rather than a slice) is returned so that, when the adapter grows multi-predicate AND WHERE, per-predicate sets can be intersected.
Source Files