datastore

package
v0.0.0-...-b1bb88e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 19, 2021 License: LGPL-2.1 Imports: 12 Imported by: 0

Documentation

Overview 

A small wrapper for boltDB to mimic update/view notation while having a single

transaction 

Data dbs as base for persistence
*
* Datastore: A type that holds all the relevant data and in which a multitude of
*            different databases can exist. The datastore handles the creation
*            and management of all different databases
* Key:	  	  A universal way of accessing data entries within a datastore without knowing any
*			  specifics about it. A key consists of the DB type, the set key and than
*			  multiple entrie keys, dependend on the required recursiveness
* Database:  Special type of storage with unique properties, e.g. ValueVersionedType database,
*            relational database etc. A database lives within a Datastorage and is
*            managed by it. It provides access to its functionality in sub entries,
*            meaning it provides its special storage for multiple keys.
* Set:       A set in a database for a certain key. Set means seperated group, and
*            can contain a hughe amount of data. E.g. a Set for a ValueVersionedType database
*            is a group of multiple ValueVersioneds, accessed by keys. A MapVersionedType is a group
*            of MapVersioneds, each accessed by a key. Keys in a set cannot be removed and
*            must be added at the beginning, bevor versioning, as they are not part
*            of the versioning process. Versioning happens inside the set, e.g.
*            for a ValueVersionedType set the individual valueVersioneds are versioned.
* Entry: 	  A data entry within a database. It is accessed via a key in a Set, and can be
*			  almost anything dependend in type of database. E.g for a ValueType Set a entry
* 			  is just a single value. For a MapType a entry is a Map. Entries are recursive,
* 			  that means an entry can hold other entries also accessbile by key. This goes
* 			  down till no subentries are available. E.g. a ValueType entry does not have
*			  any more subentries, but a MapType entry has one subentry for each map key.
* 			  Entries can be Versioned, as well as subentries. Any versioning action on a
* 			  VersionedEntry is also applied to the subentries.
*
* General properties:
* - Not enabled for concurrent usage, user needs to ensure single access
* - Golang objects do not store any state, hence having multiple objects for the same
*   data works well

List database: The list database saves multiple lists per set which are accessed by a key

ListVersioned database: The listVersioned database saves multiple listVersioneds per set which are accessed by a key

Map database: The map database saves multiple maps per set which are accessed by a key

MapVersioned database: The mapVersioned database saves multiple mapVersioneds per set which are accessed by a key

Value database: The key value database saves the multiple entries per set which are accessed by keys.

ValueVersioned database: The key valueVersioned database saves the multiple entries per set which are accessed by keys.

Index

Constants

View Source 
const (
	CURRENT  uint64 = math.MaxUint64 - 10
	VERSIONS uint64 = math.MaxUint64 - 11
)
View Source 
const (
	INVALID uint64 = math.MaxUint64
	HEAD    uint64 = math.MaxUint64 - 1
)
View Source 
const Error_Bolt_Access_Failure = "bolt_access_failure"
View Source 
const Error_Datastore_invalid = "datastore_invalid"
View Source 
const Error_Invalid_Data = "invalid_data"
View Source 
const Error_Key_Not_Existant = "key_not_existant"

DS error reasons

View Source 
const Error_Operation_Invalid = "operation_invalid"
View Source 
const Error_Setup_Incorrectly = "setup_incorectly"
View Source 
const Error_Transaction_Invalid = "transaction_invalid"

Variables

View Source 
var INVALID_VALUE = make([]byte, 0)
View Source 
var StorageTypes = []StorageType{ValueType, MapType, ListType}

Functions

func NewDSError 

func NewDSError(reason, msg string, args ...interface{}) utils.OCPError

Types

type DataBase 

type DataBase interface {
	Close()
	HasSet(set [32]byte) (bool, error)
	GetOrCreateSet(set [32]byte) (Set, error)
	RemoveSet(set [32]byte) error
}

Describes a Database of any kind, parent of sets of a storage type

type Datastore 

type Datastore struct {
	// contains filtered or unexported fields
}

func NewDatastore 

func NewDatastore(path string) (*Datastore, error)

func (*Datastore) Begin 

func (self *Datastore) Begin() error

func (*Datastore) Close 

func (self *Datastore) Close() error

func (*Datastore) Commit 

func (self *Datastore) Commit() error

func (*Datastore) Delete 

func (self *Datastore) Delete() error

func (*Datastore) FinishFileBackup 

func (self *Datastore) FinishFileBackup() error

finishes backup: normal operation is restored afterwards

func (*Datastore) GetDatabase 

func (self *Datastore) GetDatabase(kind StorageType, versioned bool) (DataBase, error)

func (*Datastore) GetEntry 

func (self *Datastore) GetEntry(key Key) (Entry, error)

Retrieve any entry from within the datastore

func (*Datastore) GetOrCreateSet 

func (self *Datastore) GetOrCreateSet(kind StorageType, versioned bool, set [32]byte) (Set, error)

func (*Datastore) GetVersionedEntry 

func (self *Datastore) GetVersionedEntry(key Key) (VersionedEntry, error)

Retrieve any versioned entry from the datastore

func (*Datastore) HasSet 

func (self *Datastore) HasSet(kind StorageType, versioned bool, set [32]byte) (bool, error)

func (*Datastore) Path 

func (self *Datastore) Path() string

func (*Datastore) PrepareFileBackup 

func (self *Datastore) PrepareFileBackup() error

prepares for a backup: afterwards the directory can simply be copied!

func (*Datastore) Rollback 

func (self *Datastore) Rollback() error

func (*Datastore) RollbackKeepOpen 

func (self *Datastore) RollbackKeepOpen() error

type Entry 

type Entry interface {
	SupportsSubentries() bool
	GetEntry(interface{}) (Entry, error)
	Erase() error //Erases completely, 100%, including all version information if available. No checks done. Use carfully
}

type Key 

type Key struct {
	Type      StorageType
	Versioned bool
	Set       [32]byte
	Entries   []interface{}
}

func NewKey 

func NewKey(stype StorageType, versioned bool, set [32]byte, entries ...interface{}) Key

type List 

type List struct {
	// contains filtered or unexported fields
}

func (*List) Add 

func (self *List) Add(value interface{}) (ListValue, error)

func (*List) Erase 

func (self *List) Erase() error

func (*List) First 

func (self *List) First() (ListValue, error)

returns first value. If no existant, does not error, but returns invalid ListValue

func (*List) GetEntry 

func (self *List) GetEntry(key interface{}) (Entry, error)

func (*List) GetValues 

func (self *List) GetValues() ([]ListValue, error)

func (*List) HasReference 

func (self *List) HasReference(ref uint64) bool

func (*List) Last 

func (self *List) Last() (ListValue, error)

func (*List) SupportsSubentries 

func (self *List) SupportsSubentries() bool

type ListDatabase 

type ListDatabase struct {
	// contains filtered or unexported fields
}

implements the database interface

func NewListDatabase 

func NewListDatabase(db *boltWrapper) (*ListDatabase, error)

func (ListDatabase) Close 

func (self ListDatabase) Close()

func (ListDatabase) GetOrCreateSet 

func (self ListDatabase) GetOrCreateSet(set [32]byte) (Set, error)

func (ListDatabase) HasSet 

func (self ListDatabase) HasSet(set [32]byte) (bool, error)

func (ListDatabase) RemoveSet 

func (self ListDatabase) RemoveSet(set [32]byte) error

type ListSet 

type ListSet struct {
	// contains filtered or unexported fields
}

func (*ListSet) Erase 

func (self *ListSet) Erase() error

func (*ListSet) GetEntry 

func (self *ListSet) GetEntry(key interface{}) (Entry, error)

func (*ListSet) GetOrCreateList 

func (self *ListSet) GetOrCreateList(key []byte) (*List, error)

func (ListSet) GetType 

func (self ListSet) GetType() StorageType

* List functions * ********************************************************************************

func (*ListSet) HasList 

func (self *ListSet) HasList(key []byte) bool

func (*ListSet) IsValid 

func (self *ListSet) IsValid() bool

* Interface functions * ********************************************************************************

func (*ListSet) Print 

func (self *ListSet) Print(params ...int)

func (*ListSet) RemoveList 

func (self *ListSet) RemoveList(key []byte) error

func (*ListSet) SupportsSubentries 

func (self *ListSet) SupportsSubentries() bool

type ListValue 

type ListValue interface {
	Entry
	Write(value interface{}) error
	Read() (interface{}, error)
	IsValid() bool
	Remove() error
	Reference() uint64
	Previous() (ListValue, error)
	Next() (ListValue, error)
}

* List entries functions * ********************************************************************************

type ListVersioned 

type ListVersioned struct {
	// contains filtered or unexported fields
}

func (*ListVersioned) Add 

func (self *ListVersioned) Add(value interface{}) (ListValue, error)

func (*ListVersioned) Erase 

func (self *ListVersioned) Erase() error

func (*ListVersioned) First 

func (self *ListVersioned) First() (ListValue, error)

returns first value. If no existant, does not error, but returns invalid ListValue

func (*ListVersioned) FixStateAsVersion 

func (self *ListVersioned) FixStateAsVersion() (VersionID, error)

func (*ListVersioned) GetCurrentVersion 

func (self *ListVersioned) GetCurrentVersion() (VersionID, error)

func (*ListVersioned) GetEntries 

func (self *ListVersioned) GetEntries() ([]ListValue, error)

func (*ListVersioned) GetEntry 

func (self *ListVersioned) GetEntry(key interface{}) (Entry, error)

func (*ListVersioned) GetLatestVersion 

func (self *ListVersioned) GetLatestVersion() (VersionID, error)

func (*ListVersioned) GetVersionedEntry 

func (self *ListVersioned) GetVersionedEntry(key interface{}) (VersionedEntry, error)

func (*ListVersioned) HasReference 

func (self *ListVersioned) HasReference(ref uint64) bool

func (*ListVersioned) HasUpdates 

func (self *ListVersioned) HasUpdates() (bool, error)

func (*ListVersioned) HasVersions 

func (self *ListVersioned) HasVersions() (bool, error)

func (*ListVersioned) Last 

func (self *ListVersioned) Last() (ListValue, error)

func (*ListVersioned) LoadVersion 

func (self *ListVersioned) LoadVersion(id VersionID) error

func (*ListVersioned) RemoveVersionsUpFrom 

func (self *ListVersioned) RemoveVersionsUpFrom(id VersionID) error

func (*ListVersioned) RemoveVersionsUpTo 

func (self *ListVersioned) RemoveVersionsUpTo(id VersionID) error

func (*ListVersioned) ResetHead 

func (self *ListVersioned) ResetHead() error

func (*ListVersioned) SupportsSubentries 

func (self *ListVersioned) SupportsSubentries() bool

type ListVersionedDatabase 

type ListVersionedDatabase struct {
	// contains filtered or unexported fields
}

ilistlements the database interface

func NewListVersionedDatabase 

func NewListVersionedDatabase(db *boltWrapper) (*ListVersionedDatabase, error)

func (ListVersionedDatabase) Close 

func (self ListVersionedDatabase) Close()

func (ListVersionedDatabase) GetOrCreateSet 

func (self ListVersionedDatabase) GetOrCreateSet(set [32]byte) (Set, error)

func (ListVersionedDatabase) HasSet 

func (self ListVersionedDatabase) HasSet(set [32]byte) (bool, error)

func (ListVersionedDatabase) RemoveSet 

func (self ListVersionedDatabase) RemoveSet(set [32]byte) error

type ListVersionedSet 

type ListVersionedSet struct {
	// contains filtered or unexported fields
}

The store itself is very silistle, as all the access logic will be in the set type this is only to manage the existing entries

func (*ListVersionedSet) Erase 

func (self *ListVersionedSet) Erase() error

func (*ListVersionedSet) FixStateAsVersion 

func (self *ListVersionedSet) FixStateAsVersion() (VersionID, error)

func (*ListVersionedSet) GetCurrentVersion 

func (self *ListVersionedSet) GetCurrentVersion() (VersionID, error)

func (*ListVersionedSet) GetEntry 

func (self *ListVersionedSet) GetEntry(key interface{}) (Entry, error)

func (*ListVersionedSet) GetLatestVersion 

func (self *ListVersionedSet) GetLatestVersion() (VersionID, error)

func (*ListVersionedSet) GetOrCreateList 

func (self *ListVersionedSet) GetOrCreateList(key []byte) (*ListVersioned, error)

func (ListVersionedSet) GetType 

func (self ListVersionedSet) GetType() StorageType

* ListVersioned functions * ********************************************************************************

func (*ListVersionedSet) GetVersionedEntry 

func (self *ListVersionedSet) GetVersionedEntry(key interface{}) (VersionedEntry, error)

func (*ListVersionedSet) HasList 

func (self *ListVersionedSet) HasList(key []byte) bool

func (*ListVersionedSet) HasUpdates 

func (self *ListVersionedSet) HasUpdates() (bool, error)

func (*ListVersionedSet) HasVersions 

func (self *ListVersionedSet) HasVersions() (bool, error)

func (*ListVersionedSet) IsValid 

func (self *ListVersionedSet) IsValid() bool

* Interface functions * ********************************************************************************

func (*ListVersionedSet) LoadVersion 

func (self *ListVersionedSet) LoadVersion(id VersionID) error

func (*ListVersionedSet) Print 

func (self *ListVersionedSet) Print(params ...int)

func (*ListVersionedSet) RemoveVersionsUpFrom 

func (self *ListVersionedSet) RemoveVersionsUpFrom(ID VersionID) error

func (*ListVersionedSet) RemoveVersionsUpTo 

func (self *ListVersionedSet) RemoveVersionsUpTo(ID VersionID) error

func (*ListVersionedSet) ResetHead 

func (self *ListVersionedSet) ResetHead() error

func (*ListVersionedSet) SupportsSubentries 

func (self *ListVersionedSet) SupportsSubentries() bool

type Map 

type Map struct {
	// contains filtered or unexported fields
}

func (*Map) Erase 

func (self *Map) Erase() error

func (*Map) GetEntry 

func (self *Map) GetEntry(key interface{}) (Entry, error)

func (*Map) GetKeys 

func (self *Map) GetKeys() ([]interface{}, error)

func (*Map) HasKey 

func (self *Map) HasKey(key interface{}) bool

func (*Map) IsValid 

func (self *Map) IsValid() bool

func (*Map) Print 

func (self *Map) Print(params ...int)

func (*Map) Read 

func (self *Map) Read(key interface{}) (interface{}, error)

func (*Map) Remove 

func (self *Map) Remove(key interface{}) error

func (*Map) SupportsSubentries 

func (self *Map) SupportsSubentries() bool

func (*Map) Write 

func (self *Map) Write(key interface{}, value interface{}) error

type MapDatabase 

type MapDatabase struct {
	// contains filtered or unexported fields
}

implements the database interface

func NewMapDatabase 

func NewMapDatabase(db *boltWrapper) (*MapDatabase, error)

func (MapDatabase) Close 

func (self MapDatabase) Close()

func (MapDatabase) GetOrCreateSet 

func (self MapDatabase) GetOrCreateSet(set [32]byte) (Set, error)

func (MapDatabase) HasSet 

func (self MapDatabase) HasSet(set [32]byte) (bool, error)

func (MapDatabase) RemoveSet 

func (self MapDatabase) RemoveSet(set [32]byte) error

type MapSet 

type MapSet struct {
	// contains filtered or unexported fields
}

func (*MapSet) Erase 

func (self *MapSet) Erase() error

func (*MapSet) GetEntry 

func (self *MapSet) GetEntry(key interface{}) (Entry, error)

func (*MapSet) GetOrCreateMap 

func (self *MapSet) GetOrCreateMap(key []byte) (*Map, error)

func (MapSet) GetType 

func (self MapSet) GetType() StorageType

* Map functions * ********************************************************************************

func (*MapSet) HasMap 

func (self *MapSet) HasMap(key []byte) bool

func (*MapSet) IsValid 

func (self *MapSet) IsValid() bool

* Interface functions * ********************************************************************************

func (*MapSet) Print 

func (self *MapSet) Print(params ...int)

func (*MapSet) SupportsSubentries 

func (self *MapSet) SupportsSubentries() bool

type MapVersioned 

type MapVersioned struct {
	// contains filtered or unexported fields
}

func (*MapVersioned) Erase 

func (self *MapVersioned) Erase() error

func (*MapVersioned) FixStateAsVersion 

func (self *MapVersioned) FixStateAsVersion() (VersionID, error)

func (*MapVersioned) GetCurrentVersion 

func (self *MapVersioned) GetCurrentVersion() (VersionID, error)

func (*MapVersioned) GetEntry 

func (self *MapVersioned) GetEntry(key interface{}) (Entry, error)

func (*MapVersioned) GetKeys 

func (self *MapVersioned) GetKeys() ([]interface{}, error)

func (*MapVersioned) GetLatestVersion 

func (self *MapVersioned) GetLatestVersion() (VersionID, error)

func (*MapVersioned) GetVersionedEntry 

func (self *MapVersioned) GetVersionedEntry(key interface{}) (VersionedEntry, error)

func (*MapVersioned) HasKey 

func (self *MapVersioned) HasKey(key interface{}) bool

func (*MapVersioned) HasUpdates 

func (self *MapVersioned) HasUpdates() (bool, error)

func (*MapVersioned) HasVersions 

func (self *MapVersioned) HasVersions() (bool, error)

func (*MapVersioned) IsValid 

func (self *MapVersioned) IsValid() bool

func (*MapVersioned) LoadVersion 

func (self *MapVersioned) LoadVersion(id VersionID) error

func (*MapVersioned) Print 

func (self *MapVersioned) Print(params ...int)

func (*MapVersioned) Read 

func (self *MapVersioned) Read(key interface{}) (interface{}, error)

func (*MapVersioned) Remove 

func (self *MapVersioned) Remove(key interface{}) error

func (*MapVersioned) RemoveVersionsUpFrom 

func (self *MapVersioned) RemoveVersionsUpFrom(id VersionID) error

func (*MapVersioned) RemoveVersionsUpTo 

func (self *MapVersioned) RemoveVersionsUpTo(id VersionID) error

func (*MapVersioned) ResetHead 

func (self *MapVersioned) ResetHead() error

func (*MapVersioned) SupportsSubentries 

func (self *MapVersioned) SupportsSubentries() bool

func (*MapVersioned) Write 

func (self *MapVersioned) Write(key interface{}, valueVersioned interface{}) error

type MapVersionedDatabase 

type MapVersionedDatabase struct {
	// contains filtered or unexported fields
}

implements the database interface

func NewMapVersionedDatabase 

func NewMapVersionedDatabase(db *boltWrapper) (*MapVersionedDatabase, error)

func (MapVersionedDatabase) Close 

func (self MapVersionedDatabase) Close()

func (MapVersionedDatabase) GetOrCreateSet 

func (self MapVersionedDatabase) GetOrCreateSet(set [32]byte) (Set, error)

func (MapVersionedDatabase) HasSet 

func (self MapVersionedDatabase) HasSet(set [32]byte) (bool, error)

func (MapVersionedDatabase) RemoveSet 

func (self MapVersionedDatabase) RemoveSet(set [32]byte) error

type MapVersionedSet 

type MapVersionedSet struct {
	// contains filtered or unexported fields
}

The store itself is very simple, as all the access logic will be in the set type this is only to manage the existing entries

func (*MapVersionedSet) Erase 

func (self *MapVersionedSet) Erase() error

func (*MapVersionedSet) FixStateAsVersion 

func (self *MapVersionedSet) FixStateAsVersion() (VersionID, error)

func (*MapVersionedSet) GetCurrentVersion 

func (self *MapVersionedSet) GetCurrentVersion() (VersionID, error)

func (*MapVersionedSet) GetEntry 

func (self *MapVersionedSet) GetEntry(key interface{}) (Entry, error)

func (*MapVersionedSet) GetLatestVersion 

func (self *MapVersionedSet) GetLatestVersion() (VersionID, error)

func (*MapVersionedSet) GetOrCreateMap 

func (self *MapVersionedSet) GetOrCreateMap(key []byte) (*MapVersioned, error)

func (MapVersionedSet) GetType 

func (self MapVersionedSet) GetType() StorageType

* MapVersioned functions * ********************************************************************************

func (*MapVersionedSet) GetVersionedEntry 

func (self *MapVersionedSet) GetVersionedEntry(key interface{}) (VersionedEntry, error)

func (*MapVersionedSet) HasMap 

func (self *MapVersionedSet) HasMap(key []byte) bool

func (*MapVersionedSet) HasUpdates 

func (self *MapVersionedSet) HasUpdates() (bool, error)

func (*MapVersionedSet) HasVersions 

func (self *MapVersionedSet) HasVersions() (bool, error)

func (*MapVersionedSet) IsValid 

func (self *MapVersionedSet) IsValid() bool

* Interface functions * ********************************************************************************

func (*MapVersionedSet) LoadVersion 

func (self *MapVersionedSet) LoadVersion(id VersionID) error

func (*MapVersionedSet) Print 

func (self *MapVersionedSet) Print(params ...int)

func (*MapVersionedSet) RemoveVersionsUpFrom 

func (self *MapVersionedSet) RemoveVersionsUpFrom(ID VersionID) error

func (*MapVersionedSet) RemoveVersionsUpTo 

func (self *MapVersionedSet) RemoveVersionsUpTo(ID VersionID) error

func (*MapVersionedSet) ResetHead 

func (self *MapVersionedSet) ResetHead() error

func (*MapVersionedSet) SupportsSubentries 

func (self *MapVersionedSet) SupportsSubentries() bool

type Set 

type Set interface {
	Entry
	// contains filtered or unexported methods
}

type StorageType 

type StorageType uint64
const (
	ValueType StorageType = 1
	MapType   StorageType = 3
	ListType  StorageType = 4
)

type Value 

type Value struct {
	// contains filtered or unexported fields
}

* Value functions * ********************************************************************************

func (*Value) Erase 

func (self *Value) Erase() error

func (*Value) Exists 

func (self *Value) Exists() (bool, error)

return true if the value exists: - was created by GetOrCreate - was not removed yet

func (*Value) GetEntry 

func (self *Value) GetEntry(interface{}) (Entry, error)

func (*Value) IsValid 

func (self *Value) IsValid() bool

returns true if: - setup correctly and able to write - value is not INVALID, hence can be read - was not removed yet

func (*Value) Read 

func (self *Value) Read() (interface{}, error)

func (*Value) SupportsSubentries 

func (self *Value) SupportsSubentries() bool

func (*Value) WasWrittenOnce 

func (self *Value) WasWrittenOnce() (bool, error)

return true if - the value was written before

func (*Value) Write 

func (self *Value) Write(value interface{}) error

type ValueDatabase 

type ValueDatabase struct {
	// contains filtered or unexported fields
}

implements the database interface

func NewValueDatabase 

func NewValueDatabase(db *boltWrapper) (*ValueDatabase, error)

func (ValueDatabase) Close 

func (self ValueDatabase) Close()

func (ValueDatabase) GetOrCreateSet 

func (self ValueDatabase) GetOrCreateSet(set [32]byte) (Set, error)

func (ValueDatabase) HasSet 

func (self ValueDatabase) HasSet(set [32]byte) (bool, error)

func (ValueDatabase) RemoveSet 

func (self ValueDatabase) RemoveSet(set [32]byte) error

type ValueSet 

type ValueSet struct {
	// contains filtered or unexported fields
}

The store itself is very simple, as all the access logic will be in the set type this is only to manage the existing entries

func (*ValueSet) Erase 

func (self *ValueSet) Erase() error

func (*ValueSet) GetEntry 

func (self *ValueSet) GetEntry(key interface{}) (Entry, error)

func (*ValueSet) GetOrCreateValue 

func (self *ValueSet) GetOrCreateValue(key []byte) (*Value, error)

func (ValueSet) GetType 

func (self ValueSet) GetType() StorageType

* Value functions * ********************************************************************************

func (*ValueSet) HasKey 

func (self *ValueSet) HasKey(key []byte) bool

func (*ValueSet) IsValid 

func (self *ValueSet) IsValid() bool

* Interface functions * ********************************************************************************

func (*ValueSet) Print 

func (self *ValueSet) Print(params ...int)

func (*ValueSet) SupportsSubentries 

func (self *ValueSet) SupportsSubentries() bool

type ValueVersioned 

type ValueVersioned struct {
	// contains filtered or unexported fields
}

* ValueVersioned functions * ********************************************************************************

func (*ValueVersioned) Erase 

func (self *ValueVersioned) Erase() error

func (*ValueVersioned) Exists 

func (self *ValueVersioned) Exists() (bool, error)

True if: - was setup with GetOrCreate - was not removed

Note that it does state nothing about content, could still be invalid or never be written before

func (*ValueVersioned) FixStateAsVersion 

func (self *ValueVersioned) FixStateAsVersion() (VersionID, error)

func (*ValueVersioned) GetCurrentVersion 

func (self *ValueVersioned) GetCurrentVersion() (VersionID, error)

func (*ValueVersioned) GetEntry 

func (self *ValueVersioned) GetEntry(interface{}) (Entry, error)

func (*ValueVersioned) GetLatestVersion 

func (self *ValueVersioned) GetLatestVersion() (VersionID, error)

func (*ValueVersioned) GetVersionedEntry 

func (self *ValueVersioned) GetVersionedEntry(interface{}) (VersionedEntry, error)

func (*ValueVersioned) HasUpdates 

func (self *ValueVersioned) HasUpdates() (bool, error)

func (*ValueVersioned) HasVersions 

func (self *ValueVersioned) HasVersions() (bool, error)

func (*ValueVersioned) IsValid 

func (self *ValueVersioned) IsValid() bool

True if: - setup correctly and writeable/readable - is available in currently load version - contains a value, hence can be safely read

func (*ValueVersioned) LoadVersion 

func (self *ValueVersioned) LoadVersion(id VersionID) error

func (*ValueVersioned) Read 

func (self *ValueVersioned) Read() (interface{}, error)

func (*ValueVersioned) RemoveVersionsUpFrom 

func (self *ValueVersioned) RemoveVersionsUpFrom(version VersionID) error

func (*ValueVersioned) RemoveVersionsUpTo 

func (self *ValueVersioned) RemoveVersionsUpTo(version VersionID) error

func (*ValueVersioned) ResetHead 

func (self *ValueVersioned) ResetHead() error

func (*ValueVersioned) SupportsSubentries 

func (self *ValueVersioned) SupportsSubentries() bool

func (*ValueVersioned) WasWrittenOnce 

func (self *ValueVersioned) WasWrittenOnce() (bool, error)

return true if - the value was already written in HEAD, or - any versions exist with valid data

func (*ValueVersioned) Write 

func (self *ValueVersioned) Write(valueVersioned interface{}) error

type ValueVersionedDatabase 

type ValueVersionedDatabase struct {
	// contains filtered or unexported fields
}

implements the database interface

func NewValueVersionedDatabase 

func NewValueVersionedDatabase(db *boltWrapper) (*ValueVersionedDatabase, error)

func (ValueVersionedDatabase) Close 

func (self ValueVersionedDatabase) Close()

func (ValueVersionedDatabase) GetOrCreateSet 

func (self ValueVersionedDatabase) GetOrCreateSet(set [32]byte) (Set, error)

func (ValueVersionedDatabase) HasSet 

func (self ValueVersionedDatabase) HasSet(set [32]byte) (bool, error)

func (ValueVersionedDatabase) RemoveSet 

func (self ValueVersionedDatabase) RemoveSet(set [32]byte) error

type ValueVersionedSet 

type ValueVersionedSet struct {
	// contains filtered or unexported fields
}

The store itself is very simple, as all the access logic will be in the set type this is only to manage the existing entries

func (*ValueVersionedSet) Erase 

func (self *ValueVersionedSet) Erase() error

func (*ValueVersionedSet) FixStateAsVersion 

func (self *ValueVersionedSet) FixStateAsVersion() (VersionID, error)

func (*ValueVersionedSet) GetCurrentVersion 

func (self *ValueVersionedSet) GetCurrentVersion() (VersionID, error)

func (*ValueVersionedSet) GetEntry 

func (self *ValueVersionedSet) GetEntry(key interface{}) (Entry, error)

func (*ValueVersionedSet) GetLatestVersion 

func (self *ValueVersionedSet) GetLatestVersion() (VersionID, error)

func (*ValueVersionedSet) GetOrCreateValue 

func (self *ValueVersionedSet) GetOrCreateValue(key []byte) (*ValueVersioned, error)

func (ValueVersionedSet) GetType 

func (self ValueVersionedSet) GetType() StorageType

* Key-ValueVersioned functions * ********************************************************************************

func (*ValueVersionedSet) GetVersionedEntry 

func (self *ValueVersionedSet) GetVersionedEntry(key interface{}) (VersionedEntry, error)

func (*ValueVersionedSet) HasKey 

func (self *ValueVersionedSet) HasKey(key []byte) bool

func (*ValueVersionedSet) HasUpdates 

func (self *ValueVersionedSet) HasUpdates() (bool, error)

func (*ValueVersionedSet) HasVersions 

func (self *ValueVersionedSet) HasVersions() (bool, error)

func (*ValueVersionedSet) IsValid 

func (self *ValueVersionedSet) IsValid() bool

* Interface functions * ********************************************************************************

func (*ValueVersionedSet) LoadVersion 

func (self *ValueVersionedSet) LoadVersion(id VersionID) error

func (*ValueVersionedSet) Print 

func (self *ValueVersionedSet) Print(params ...int)

func (*ValueVersionedSet) RemoveVersionsUpFrom 

func (self *ValueVersionedSet) RemoveVersionsUpFrom(ID VersionID) error

func (*ValueVersionedSet) RemoveVersionsUpTo 

func (self *ValueVersionedSet) RemoveVersionsUpTo(ID VersionID) error

func (*ValueVersionedSet) ResetHead 

func (self *ValueVersionedSet) ResetHead() error

func (*ValueVersionedSet) SupportsSubentries 

func (self *ValueVersionedSet) SupportsSubentries() bool

type VersionID 

type VersionID uint64

func (VersionID) IsHead 

func (self VersionID) IsHead() bool

func (VersionID) IsValid 

func (self VersionID) IsValid() bool

type VersionManager 

type VersionManager interface {
	VersionedData
	GetDatabaseSet(sType StorageType) (Set, error)
	Erase() error
}

Makes version managing for a number of equal key sets easy * * It is possible to have multiple sets for the same key, just different kinds. As a * set is able to be versioned, it might be useful to version those sets with a * single key together, meaning creating versions over the whole collection of sets. * This is handled by the VersionManager, who collects all sets for a key and * provides the same functionality for versioning as the set itself.

type VersionManagerImp 

type VersionManagerImp struct {
	// contains filtered or unexported fields
}

func NewVersionManager 

func NewVersionManager(key [32]byte, ds *Datastore) (VersionManagerImp, error)

func (*VersionManagerImp) Erase 

func (self *VersionManagerImp) Erase() error

func (*VersionManagerImp) FixStateAsVersion 

func (self *VersionManagerImp) FixStateAsVersion() (VersionID, error)

func (*VersionManagerImp) GetCurrentVersion 

func (self *VersionManagerImp) GetCurrentVersion() (VersionID, error)

func (*VersionManagerImp) GetDatabaseSet 

func (self *VersionManagerImp) GetDatabaseSet(sType StorageType) (Set, error)

func (*VersionManagerImp) GetLatestVersion 

func (self *VersionManagerImp) GetLatestVersion() (VersionID, error)

func (*VersionManagerImp) HasUpdates 

func (self *VersionManagerImp) HasUpdates() (bool, error)

func (*VersionManagerImp) HasVersions 

func (self *VersionManagerImp) HasVersions() (bool, error)

func (*VersionManagerImp) LoadVersion 

func (self *VersionManagerImp) LoadVersion(id VersionID) error

func (*VersionManagerImp) RemoveVersionsUpFrom 

func (self *VersionManagerImp) RemoveVersionsUpFrom(ID VersionID) error

func (*VersionManagerImp) RemoveVersionsUpTo 

func (self *VersionManagerImp) RemoveVersionsUpTo(ID VersionID) error

func (*VersionManagerImp) ResetHead 

func (self *VersionManagerImp) ResetHead() error

type VersionedData 

type VersionedData interface {
	HasUpdates() (bool, error)
	HasVersions() (bool, error)
	ResetHead() error
	FixStateAsVersion() (VersionID, error)
	LoadVersion(id VersionID) error
	GetLatestVersion() (VersionID, error)
	GetCurrentVersion() (VersionID, error)
	RemoveVersionsUpTo(VersionID) error
	RemoveVersionsUpFrom(VersionID) error
}

VersionedData interface: Handle any kind of data according to versioning rules * * - A Version is only created on demand from current state (FixStateAsVersion) * - If the loaded version is not the highest one no change of data is allowed * - The Versioned data is requried to check on write if an older version is loaded * and prevent write actively * - To change data based on older version, all newer versions muse be deleted * and normal processing of change and versioning goes on * (in general this means forking or removal of version data)

type VersionedEntry 

type VersionedEntry interface {
	VersionedData
	Entry

	GetVersionedEntry(interface{}) (VersionedEntry, error)
}

type VersionedSet 

type VersionedSet interface {
	VersionedEntry
	// contains filtered or unexported methods
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.