storage

Documentation

Overview

maintain the on-disk data store

maintain separate pools of a number of elements in key->value form

This maintains a LevelDB database split into a series of tables. Each table is defined by a prefix byte that is obtained from the prefix tag in the struct defining the avaiable tables.

Notes: 1. each separate pool has a single byte prefix (to spread the keys in LevelDB) 2. ++ = concatenation of byte data 3. block number = big endian uint64 (8 bytes) 4. txId = transaction digest as 32 byte SHA3-256(data) 5. asset index = fingerprint digest as 64 byte SHA3-512(data) 6. count = successive index value as big endian uint64 (8 bytes) 7. owner = bitmark account (32 byte public key) 8. *others* = byte values of various length

Blocks:

B ++ block number          - block store
                             data: header ++ base transaction ++ (concat transactions)
F ++ block number          - current block owner
                             data: owner ++ currency ++ currency address

Transactions:

T ++ txId                  - confirmed transactions
                             data: packed transaction data

Assets:

A ++ asset index           - confirmed asset
                             data: packed asset data

Ownership:

N ++ owner                 - next count value to use for appending to owned items
                             data: count
K ++ owner ++ count        - list of owned items
                             data: last transfer txId ++ last transfer block number ++ issue txId ++ issue block number ++ asset index
D ++ owner ++ txId         - position in list of owned items, for delete after transfer
                             data: count

Testing:

Z ++ key                   - testing data

Index

• Variables
• func Finalise()
• func Initialise(database string) error
• type Element
• type FetchCursor
  • func (cursor *FetchCursor) Fetch(count int) ([]Element, error)
  • func (cursor *FetchCursor) Seek(key []byte) *FetchCursor
• type PoolHandle
  • func (p *PoolHandle) Delete(key []byte)
  • func (p *PoolHandle) Get(key []byte) []byte
  • func (p *PoolHandle) Has(key []byte) bool
  • func (p *PoolHandle) LastElement() (Element, bool)
  • func (p *PoolHandle) NewFetchCursor() *FetchCursor
  • func (p *PoolHandle) Put(key []byte, value []byte)

Variables

var Pool pools

the instance

Functions

func Finalise

func Finalise()

close the database connection

func Initialise

func Initialise(database string) error

open up the database connection

this must be called before any pool.New() is created

Types

type Element

type Element struct {
	Key   []byte
	Value []byte
}

a binary data item

type FetchCursor

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

cursor structure

func (*FetchCursor) Fetch

func (cursor *FetchCursor) Fetch(count int) ([]Element, error)

fetch some elements starting from key

func (*FetchCursor) Seek

func (cursor *FetchCursor) Seek(key []byte) *FetchCursor

type PoolHandle

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

a pool handle

func (*PoolHandle) Delete

func (p *PoolHandle) Delete(key []byte)

remove a key from the database

func (*PoolHandle) Get

func (p *PoolHandle) Get(key []byte) []byte

read a value for a given key

this returns the actual element - copy the result if it must be preserved

func (*PoolHandle) Has

func (p *PoolHandle) Has(key []byte) bool

Check if a key exists

func (*PoolHandle) LastElement

func (p *PoolHandle) LastElement() (Element, bool)

get the last element in a pool

func (*PoolHandle) NewFetchCursor

func (p *PoolHandle) NewFetchCursor() *FetchCursor

initialise a cursor to the start of a key range

func (*PoolHandle) Put

func (p *PoolHandle) Put(key []byte, value []byte)

store a key/value bytes pair to the database