btree

type BTree struct {
	Config
	// contains filtered or unexported fields
}

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

type Config struct {
	//-- file store
	Idxfile string
	Kvfile  string
	IndexConfig

	// maximum number of levels btree can grow, this information is used as a
	// cue in calculating couple of limits within the algorithm.
	Maxlevel int

	// if number of entries within a node goes below this threshold, then a
	// rebalance will be triggered on its parent node.
	RebalanceThrs int

	// when free nodes are not available to record btree mutations, then a new
	// set of btree blocks will be appended to the index file.
	//  count of appended blocks = freelist-size * AppendRatio
	AppendRatio float32

	// MVCC snapshots are flushed in batches. DrainRate defines the maximum
	// number of snapshots to accumulate in-memory, after which they are
	// flushed to disk.
	DrainRate int

	// all intermediate nodes are cached in memory, there are no upper limit
	// to that. But number of leaf nodes can be really large and
	// `MaxLeafCache` limits the number of leaf nodes to be cached.
	MaxLeafCache int

	// MVCC throttle rate in milliseconds
	MVCCThrottleRate time.Duration

	// enables O_SYNC flag for indexfile and kvfile.
	Sync bool

	// enables O_DIRECT flag for indexfile and kvfile.
	Nocache bool

	// Debug
	Debug bool
}

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

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

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

type Emitter func([]byte) // Internal type

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

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

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

type IndexConfig struct {
	Sectorsize int64 // head sector-size in bytes.
	Flistsize  int64 // free-list size in bytes.
	Blocksize  int64 // btree block size in bytes.
}

type Indexer interface {
	// Insert {key,value} pairs into the index. key type is expected to
	// implement `Key` interface and value type is expected to implement
	// `Value` interface. If the key is successfuly inserted it returns true.
	Insert(Key, Value) bool

	// Count number of key,value pairs in this index.
	Count() int64

	// Return key-bytes, docid-bytes, and value bytes of the first
	// element in the list.
	Front() ([]byte, []byte, []byte)

	// Check whether `key` is present in the index.
	Contains(Key) bool

	// Check whether `key` and `docid` is present in the index.
	Equals(Key) bool

	// Return a channel on which the caller can receive key bytes, docid-
	// bytes and value-bytes for each entry in the index.
	//      ch := bt.FullSet()
	//      keybytes := <-ch
	//      valbytes := <-ch
	//      docidbytes := <-ch
	FullSet() <-chan []byte

	// Return a channel on which the caller can receive key-bytes.
	KeySet() <-chan []byte

	// Return a channel on which the caller can receive docid-bytes
	DocidSet() <-chan []byte

	// Return a channel on which the caller can receive value-bytes
	ValueSet() <-chan []byte

	// Return a channel that will transmit all values associated with `key`,
	// make sure the `docid` is set to minimum value to lookup all values
	// greater that `key` && `docid`
	Lookup(Key) (chan []byte, error)

	// Remove an entry identified by {key,docid}
	Remove(Key) bool

	//-- Meant for debugging.
	Drain()      // flush the MVCC snapshots into disk.
	Check()      // check the btree data structure for anamolies.
	Show()       // displays in-memory btree structure on stdout.
	ShowKeys()   // list keys and docids inside the tree.
	Stats(bool)  // display statistics so far.
	LevelCount() // count number of inodes, knodes and number of entries.
}

type Key interface {
	// transform actual key content into byte slice, that can be persisted in
	// file.
	Bytes() []byte

	// every key carries the document-id that emitted this {key,value} tupele,
	// transform the document-id into byte slice, that can be persisted in file.
	Docid() []byte

	// this is the call-back hook that `Key` types can use to sort themself.
	// kfpos : file-position inside kv-file that contains key-content.
	// dfpos : file-position inside kv-file that contains docid-content.
	// isD : boolean that says whether comparision needs to be done on
	//       document-id as well
	//
	// Example:
	//
	//      otherkey = s.fetchKey(kfpos)
	//      if cmp = bytes.Compare(thiskey, otherkey); cmp == 0 && isD {
	//          otherdocid = s.fetchKey(dfpos)
	//          cmp = bytes.Compare(thisdocid, otherdocid)
	//          if cmp == 0 {
	//              return cmp, kfpos, dfpos
	//          } else {
	//              return cmp, kfpos, -1
	//          }
	//      } else if cmp == 0 {
	//          return cmp, kfpos, -1
	//      } else {
	//          return cmp, -1, -1
	//      }
	//
	// Returns:
	//    - cmp, result of comparision, either -1, 0, 1.
	//    - kfpos, if > -1, it means the keys are equal and specifies the
	//      offset in kv-file that contains the key.
	//    - dfpos, if > -1, it means the docids are equal and specifies the
	//      offset in kv-file that contains the docid.
	CompareLess(s *Store, kfpos int64, dfpos int64, isD bool) (int, int64, int64)

	// check whether both key and document-id compares equal.
	Equal([]byte, []byte) (bool, bool)
}

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

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

type Node interface {
	// contains filtered or unexported methods
}

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

type RecycleData ReclaimData

type Store struct {
	//Config
	*WStore // Reference to write-store.
	// contains filtered or unexported fields
}

type TestKey struct {
	K  string
	Id int64
}

type TestValue struct {
	V string
}

type Value interface {
	// transform actual value content into byte slice, that can be persisted in
	// file.
	Bytes() []byte
}

type WStore struct {
	Config

	MVCC  // MVCC concurrency control go-routine
	IO    // IO flusher
	DEFER // kv-cache

	WStoreStats
	// contains filtered or unexported fields
}

type WStoreStats struct {
	MVloadCounts int64
	// contains filtered or unexported fields
}