Jordan Hrycaj f926222fec
Aristo cull journal related stuff (#2288)
* Remove all journal related stuff

* Refactor function names journal*() => delta*(), filter*() => delta*()

* remove `trg` fileld from `FilterRef`

why:
  Same as `kMap[$1]`

* Re-type FilterRef.src as `HashKey`

why:
  So it is directly comparable to `kMap[$1]`

* Moved `vGen[]` field from `LayerFinalRef` to `LayerDeltaRef`

why:
  Then a separate `FilterRef` type is not needed, anymore

* Rename `roFilter` field in `AristoDbRef` => `balancer`

why:
  New name more appropriate.

* Replace `FilterRef` by `LayerDeltaRef` type

why:
  This allows to avoid copying into the `balancer` (see next patch set)
  most of the time. Typically, only one instance is running on the backend
  and the `balancer` is only used as a stage before saving data.

* Refactor way how to store data persistently

why:
  Avoid useless copy when staging `top` layer for persistently saving to
  backend.

* Fix copyright header?
2024-06-03 20:10:35 +00:00

115 lines
3.8 KiB
Nim

# nimbus-eth1
# Copyright (c) 2023-2024 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
# http://www.apache.org/licenses/LICENSE-2.0)
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
# http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed
# except according to those terms.
## Non persistent constructors for Aristo DB
## =========================================
##
{.push raises: [].}
import
results,
../aristo_desc,
../aristo_desc/desc_backend,
"."/[init_common, memory_db]
type
VoidBackendRef* = ref object of TypedBackendRef
## Dummy descriptor type, used as `nil` reference
MemOnlyBackend* = VoidBackendRef|MemBackendRef
export
BackendType,
GuestDbRef,
MemBackendRef
# ------------------------------------------------------------------------------
# Public helpers
# ------------------------------------------------------------------------------
proc kind*(
be: BackendRef;
): BackendType =
## Retrieves the backend type symbol for a `be` backend database argument
## where `BackendVoid` is returned for the`nil` backend.
if be.isNil:
BackendVoid
else:
be.TypedBackendRef.beKind
# ------------------------------------------------------------------------------
# Public database constuctors, destructor
# ------------------------------------------------------------------------------
proc init*(
T: type AristoDbRef; # Target type
B: type MemBackendRef; # Backend type
): T =
## Memory backend constructor.
##
## If the `qidLayout` argument is set `QidLayoutRef(nil)`, the a backend
## database will not provide filter history management. Providing a different
## scheduler layout shoud be used with care as table access with different
## layouts might render the filter history data unmanageable.
##
when B is MemBackendRef:
AristoDbRef(top: LayerRef.init(), backend: memoryBackend())
proc init*(
T: type AristoDbRef; # Target type
B: type MemOnlyBackend; # Backend type
): T =
## Memory backend constructor.
##
## If the `qidLayout` argument is set `QidLayoutRef(nil)`, the a backend
## database will not provide filter history management. Providing a different
## scheduler layout shoud be used with care as table access with different
## layouts might render the filter history data unmanageable.
##
when B is VoidBackendRef:
AristoDbRef(top: LayerRef.init())
elif B is MemBackendRef:
AristoDbRef(top: LayerRef.init(), backend: memoryBackend())
proc init*(
T: type AristoDbRef; # Target type
): T =
## Shortcut for `AristoDbRef.init(VoidBackendRef)`
AristoDbRef.init VoidBackendRef
proc guestDb*(db: AristoDbRef; instance = 0): Result[GuestDbRef,AristoError] =
## Database pigiback feature
if db.backend.isNil:
ok(GuestDbRef(nil))
else:
let gdb = db.backend.guestDbFn(instance).valueOr:
return err(error)
ok(gdb.GuestDbRef)
proc finish*(db: AristoDbRef; flush = false) =
## Backend destructor. The argument `flush` indicates that a full database
## deletion is requested. If set `false` the outcome might differ depending
## on the type of backend (e.g. the `BackendMemory` backend will always
## flush on close.)
##
## In case of distributed descriptors accessing the same backend, all
## distributed descriptors will be destroyed.
##
## This distructor may be used on already *destructed* descriptors.
##
if not db.backend.isNil:
db.backend.closeFn flush
discard db.getCentre.forgetOthers()
# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------