internal

package

Go to main page

Versions in this module

v0

v0.4.4

Dec 11, 2023

v0.4.3

Oct 4, 2023

v0.4.2

Jun 27, 2023

v0.4.1

May 29, 2023

v0.4.0

Oct 18, 2022

v0.3.0

Oct 10, 2022

Changes in this version

+ const FADV_NORMAL

+ const FADV_RANDOM

+ const FADV_SEQUENTIAL

+ const FADV_WILLNEED

+ func Fadvise(fd int, offset int64, length int64, advice int) error

v0.2.2

Nov 23, 2020

v0.2.1

Nov 23, 2020

Changes in this version

type BucketCache

+ func (c *BucketCache) FetchHeader(hash uint64, key string, df *DataFile) (*DataRecordHeader, error)

type Store

+ func (s *Store) DataSize(key string) (int64, error)

+ func (s *Store) Exists(key string) (bool, error)

v0.2.0

Nov 23, 2020

Changes in this version

+ const MaxBlockSize

+ const MaxDataSize

+ const MaxKeySize

+ var ErrKeyMissing = errors.New("key missing")

+ var ErrKeyTooLarge = errors.New("key too large")

type DataRecordHeader

+ DataSize int64

+ Key []byte

+ KeySize uint16

+ func (d *DataRecordHeader) Size() int64

type Store

+ func (s *Store) Rate() float64

+ func (s *Store) RecordCount() int

type VerifyResult

+ RecordBytesInUse int64

+ RecordBytesTotal int64

v0.1.1

Nov 18, 2020

v0.1.0

Nov 18, 2020

Changes in this version

+ const BucketEntrySize

+ const BucketHeaderSize

+ const DatFileHeaderSize

+ const KeyFileHeaderSize

+ const LogFileHeaderSize

+ const MaxInt16

+ const MaxUint16

+ const MaxUint24

+ const MaxUint32

+ const MaxUint48

+ const MaxUint64

+ const SizeUint16

+ const SizeUint24

+ const SizeUint32

+ const SizeUint48

+ const SizeUint64

+ const SpillHeaderSize

+ var DatFileHeaderType = []byte("gonudbdt")

+ var ErrAppNumMismatch = errors.New("appnum mismatch")

+ var ErrDataMissing = errors.New("data missing")

+ var ErrDataTooLarge = errors.New("data too large")

+ var ErrDifferentVersion = errors.New("different version")

+ var ErrHashMismatch = errors.New("hash mismatch")

+ var ErrInvalidBlockSize = errors.New("invalid block size")

+ var ErrInvalidBucketCount = errors.New("invalid bucket count")

+ var ErrInvalidCapacity = errors.New("invalid capacity")

+ var ErrInvalidDataRecord = errors.New("not a data record: contains spill marker")

+ var ErrInvalidKeySize = errors.New("invalid key size")

+ var ErrInvalidLoadFactor = errors.New("invalid load factor")

+ var ErrInvalidRecordSize = errors.New("invalid record size")

+ var ErrInvalidSpill = errors.New("not a spill record: missing spill marker")

+ var ErrKeyExists = errors.New("key exists")

+ var ErrKeyMismatch = errors.New("key mismatch")

+ var ErrKeyNotFound = errors.New("key not found")

+ var ErrKeySizeMismatch = errors.New("key size mismatch")

+ var ErrKeyWrongSize = errors.New("key wrong size")

+ var ErrNotDataFile = errors.New("not a data file")

+ var ErrNotKeyFile = errors.New("not a key file")

+ var ErrNotLogFile = errors.New("not a log file")

+ var ErrShortKeyFile = errors.New("short key file")

+ var ErrUIDMismatch = errors.New("uid mismatch")

+ var GitVersion string = "unknown"

+ var KeyFileHeaderType = []byte("gonudbky")

+ var LogFileHeaderType = []byte("gonudblg")

+ func BucketCapacity(blockSize int) int

+ func BucketIndex(h uint64, buckets int, modulus uint64) int

+ func BucketSize(capacity int) int

+ func CreateDataFile(path string, appnum, uid uint64, keySize int) error

+ func CreateKeyFile(path string, uid uint64, appnum uint64, keySize int, salt uint64, ...) error

+ func CreateStore(datPath, keyPath, logPath string, appnum, uid, salt uint64, ...) error

+ func DecodeUint16(b []byte) uint16

+ func DecodeUint24(b []byte) uint32

+ func DecodeUint32(b []byte) uint32

+ func DecodeUint48(b []byte) uint64

+ func DecodeUint64(b []byte) uint64

+ func EncodeUint16(b []byte, v uint16)

+ func EncodeUint24(b []byte, v uint32)

+ func EncodeUint32(b []byte, v uint32)

+ func EncodeUint48(b []byte, v uint64)

+ func EncodeUint64(b []byte, v uint64)

+ func NewSalt() uint64

+ func NewUID() uint64

+ func Version() string

+ type Bucket struct

+ func NewBucket(blockSize int, blob []byte) *Bucket

+ func (b *Bucket) ActualSize() int

+ func (b *Bucket) BlockSize() int

+ func (b *Bucket) Capacity() int

+ func (b *Bucket) CopyInto(b2 *Bucket)

+ func (b *Bucket) Count() int

+ func (b *Bucket) Entry(idx int) Entry

+ func (b *Bucket) Has(h uint64) bool

+ func (b *Bucket) HighestHash() uint64

+ func (b *Bucket) IsEmpty() bool

+ func (b *Bucket) IsFull() bool

+ func (b *Bucket) LoadFrom(spill int64, s Spiller) error

+ func (b *Bucket) Lock()

+ func (b *Bucket) LowestHash() uint64

+ func (b *Bucket) SetSpill(v int64)

+ func (b *Bucket) Spill() int64

+ func (b *Bucket) Unlock()

+ func (b *Bucket) WriteTo(w io.Writer) (int64, error)

+ type BucketCache struct

+ func (c *BucketCache) BucketCount() int

+ func (c *BucketCache) EntryCount() int

+ func (c *BucketCache) Exists(hash uint64, key string, df *DataFile) (bool, error)

+ func (c *BucketCache) Fetch(hash uint64, key string, df *DataFile) (io.Reader, error)

+ func (c *BucketCache) Get(idx int) *Bucket

+ func (c *BucketCache) Has(hash uint64, sp Spiller) (bool, error)

+ func (c *BucketCache) Insert(offset int64, size int64, hash uint64, df Spiller) error

+ func (c *BucketCache) WriteDirty(lf *LogFile, kf *KeyFile) (int64, error)

+ type BucketRecord struct

+ type BucketScanner struct

+ func (b *BucketScanner) Bucket() *Bucket

+ func (b *BucketScanner) Close() error

+ func (b *BucketScanner) Err() error

+ func (b *BucketScanner) Index() int

+ func (b *BucketScanner) IsSpill() bool

+ func (b *BucketScanner) Next() bool

+ type Cache struct

+ func NewCache(keySize int, blockSize int, sizeHint int) *Cache

+ func (c *Cache) Clear()

+ func (c *Cache) Count() int

+ func (c *Cache) Find(n int) (*Bucket, bool)

+ func (c *Cache) Has(n int) bool

+ func (c *Cache) Insert(idx int, b *Bucket)

+ func (c *Cache) TakeData() *CacheData

+ func (c *Cache) WithBuckets(fn func(bs []BucketRecord) error) error

+ type CacheData struct

+ func (c *CacheData) Count() int

+ func (c *CacheData) Find(n int) (*Bucket, bool)

+ func (c *CacheData) Has(n int) bool

+ func (c *CacheData) WithBuckets(fn func(bs []BucketRecord) error) error

+ type CountWriter interface

+ Count func() int64

+ Offset func() int64

+ type DatFileHeader struct

+ AppNum uint64

+ KeySize int16

+ Type [8]byte

+ UID uint64

+ Version uint16

+ func (*DatFileHeader) Size() int

+ func (d *DatFileHeader) DecodeFrom(r io.Reader) error

+ func (d *DatFileHeader) EncodeTo(w io.Writer) error

+ func (d *DatFileHeader) Verify() error

+ func (d *DatFileHeader) VerifyMatchingKey(k *KeyFileHeader) error

+ type DataFile struct

+ Header DatFileHeader

+ Path string

+ func OpenDataFile(path string) (*DataFile, error)

+ func (d *DataFile) AppendBucketSpill(blob []byte) (int64, error)

+ func (d *DataFile) AppendRecord(dr *DataRecord) (int64, error)

+ func (d *DataFile) Close() error

+ func (d *DataFile) Flush() error

+ func (d *DataFile) LoadBucketSpill(offset int64, blob []byte) error

+ func (d *DataFile) LoadRecordHeader(offset int64) (*DataRecordHeader, error)

+ func (d *DataFile) Offset() int64

+ func (d *DataFile) RecordDataReader(offset int64, key string) (io.Reader, error)

+ func (d *DataFile) RecordScanner() *RecordScanner

+ func (d *DataFile) Size() (int64, error)

+ func (d *DataFile) Sync() error

+ type DataRecord struct

+ type DataRecordHeader struct

+ func (d *DataRecordHeader) IsData() bool

+ func (d *DataRecordHeader) IsSpill() bool

+ type Entry struct

+ Hash uint64

+ Offset int64

+ Size int64

+ type Hasher uint64

+ func (h Hasher) Hash(data []byte) uint64

+ func (h Hasher) HashString(data string) uint64

+ type KeyFile struct

+ Header KeyFileHeader

+ Path string

+ func OpenKeyFile(path string) (*KeyFile, error)

+ func (k *KeyFile) BlockSize() uint16

+ func (k *KeyFile) BucketScanner(df *DataFile) *BucketScanner

+ func (k *KeyFile) Close() error

+ func (k *KeyFile) Hash(key []byte) uint64

+ func (k *KeyFile) HashString(key string) uint64

+ func (k *KeyFile) LoadBucket(idx int) (*Bucket, error)

+ func (k *KeyFile) PutBucket(idx int, b *Bucket) error

+ func (k *KeyFile) Size() (int64, error)

+ func (k *KeyFile) Sync() error

+ type KeyFileHeader struct

+ AppNum uint64

+ BlockSize uint16

+ Buckets int

+ Capacity int

+ KeySize int16

+ LoadFactor uint16

+ Modulus uint64

+ Pepper uint64

+ Salt uint64

+ Type [8]byte

+ UID uint64

+ Version uint16

+ func (k *KeyFileHeader) DecodeFrom(r io.Reader, fileSize int64) error

+ func (k *KeyFileHeader) EncodeTo(w io.Writer) error

+ func (k *KeyFileHeader) Size() int

+ func (k *KeyFileHeader) Verify() error

+ type LogFile struct

+ Header LogFileHeader

+ Path string

+ func OpenLogFile(path string) (*LogFile, error)

+ func (l *LogFile) AppendBucket(idx int, b *Bucket) (int64, error)

+ func (l *LogFile) Close() error

+ func (l *LogFile) Flush() error

+ func (l *LogFile) Prepare(df *DataFile, kf *KeyFile) error

+ func (l *LogFile) Sync() error

+ func (l *LogFile) Truncate() error

+ type LogFileHeader struct

+ AppNum uint64

+ BlockSize uint16

+ DatFileSize int64

+ KeyFileSize int64

+ KeySize int16

+ Pepper uint64

+ Salt uint64

+ Type [8]byte

+ UID uint64

+ Version uint16

+ func (l *LogFileHeader) DecodeFrom(r io.Reader) error

+ func (l *LogFileHeader) EncodeTo(w io.Writer) error

+ func (l *LogFileHeader) Size() int

+ type Pool struct

+ func NewPool(sizeHint int) *Pool

+ func (p *Pool) Clear()

+ func (p *Pool) Count() int

+ func (p *Pool) DataSize() int

+ func (p *Pool) Find(key string) ([]byte, bool)

+ func (p *Pool) Has(key string) bool

+ func (p *Pool) Insert(hash uint64, key string, value []byte)

+ func (p *Pool) IsEmpty() bool

+ func (p *Pool) WithRecords(fn func([]DataRecord) error) error

+ func (p *Pool) WriteRecords(df *DataFile) (int64, error)

+ type RecordScanner struct

+ func (s *RecordScanner) Close() error

+ func (s *RecordScanner) Err() error

+ func (s *RecordScanner) IsData() bool

+ func (s *RecordScanner) IsSpill() bool

+ func (s *RecordScanner) Key() string

+ func (s *RecordScanner) Next() bool

+ func (s *RecordScanner) Reader() io.Reader

+ func (s *RecordScanner) RecordSize() int64

+ func (s *RecordScanner) Size() int64

+ type SectionWriter struct

+ func NewSectionWriter(w io.WriterAt, offset int64, size int64) *SectionWriter

+ func (s *SectionWriter) Write(v []byte) (int, error)

+ type Spiller interface

+ AppendBucketSpill func([]byte) (int64, error)

+ Flush func() error

+ LoadBucketSpill func(int64, []byte) error

+ type Store struct

+ func OpenStore(datPath, keyPath, logPath string, syncInterval time.Duration, ...) (*Store, error)

+ func (s *Store) Close() error

+ func (s *Store) DataFile() *DataFile

+ func (s *Store) Err() error

+ func (s *Store) FetchReader(key string, fn func(io.Reader)) error

+ func (s *Store) Flush()

+ func (s *Store) Insert(key string, data []byte) error

+ func (s *Store) KeyFile() *KeyFile

+ func (s *Store) LogFile() *LogFile

+ type VerifyResult struct

+ ActualLoad float64

+ AppNum uint64

+ AverageFetch float64

+ BlockSize uint16

+ BucketSize int64

+ Buckets int

+ Capacity int

+ DatFileSize int64

+ DatPath string

+ KeyCount int64

+ KeyFileSize int64

+ KeyPath string

+ KeySize int16

+ LoadFactor float64

+ Modulus uint64

+ Overhead float64

+ Pepper uint64

+ Salt uint64

+ SpillBytesInUse int64

+ SpillBytesTotal int64

+ SpillCountInUse int64

+ SpillCountTotal int64

+ UID uint64

+ ValueBytesInUse int64

+ ValueBytesTotal int64

+ ValueCountInUse int64

+ ValueCountTotal int64

+ Version uint16

+ Waste float64

+ func VerifyStore(datPath, keyPath string) (*VerifyResult, error)

+ type WriterFlusher interface

+ Flush func() error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL