id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c175300 | lsmSize += info.Size()
} else if ext == ".vlog" {
vlogSize += info.Size()
}
return nil
})
if err != nil {
db.elog.Printf("Got error while calculating total size of directory: %s", dir)
}
return lsmSize, vlogSize
}
lsmSize, vlogSize := totalSize(db.opt.Dir)
y.LSMSize.Set(db.opt.Dir, newInt(lsmSize))
// If valueDir is different from dir, we'd have to do another walk.
if db.opt.ValueDir != db.opt.Dir {
_, vlogSize = totalSize(db.opt.ValueDir)
}
y.VlogSize.Set(db.opt.Dir, newInt(vlogSize))
} | |
c175301 | = y.LSMSize.Get(db.opt.Dir).(*expvar.Int).Value()
vlog = y.VlogSize.Get(db.opt.Dir).(*expvar.Int).Value()
return
} | |
c175302 | seq.leased {
if err := seq.updateLease(); err != nil {
return 0, err
}
}
val := seq.next
seq.next++
return val, nil
} | |
c175303 |
return txn.Set(seq.key, buf[:])
})
if err != nil {
return err
}
seq.leased = seq.next
return nil
} | |
c175304 | that has a tendency to store !badger
// keys.
if bytes.HasPrefix(ti.Right, prefix) {
splits = append(splits, string(ti.Right))
}
}
sort.Strings(splits)
return splits
} | |
c175305 | %8s Size. %8s Max.\n",
i, hbytes(l.getTotalSize()), hbytes(l.maxTotalSize))
if sz > 0 {
levels = append(levels, i)
}
}
if len(levels) <= 1 {
prios := db.lc.pickCompactLevels()
if len(prios) == 0 || prios[0].score <= 1.0 {
db.opt.Infof("All tables consolidated into one level. Flattening done.\n")
return nil
}
if err := compactAway(prios[0]); err != nil {
return err
}
continue
}
// Create an artificial compaction priority, to ensure that we compact the level.
cp := compactionPriority{level: levels[0], score: 1.71}
if err := compactAway(cp); err != nil {
return err
}
}
} | |
c175306 |
}
return unix.Mmap(int(fd.Fd()), 0, int(size), mtype, unix.MAP_SHARED)
} | |
c175307 |
if !readahead {
flags = unix.MADV_RANDOM
}
return madvise(b, flags)
} | |
c175308 | defer o.Unlock()
o.discardTs = ts
} | |
c175309 | a conflict.
if ts, has := o.commits[ro]; has && ts > txn.readTs {
return true
}
}
return false
} | |
c175310 | Value: val,
}
return txn.SetEntry(e)
} | |
c175311 | {
e := &Entry{Key: key, Value: val, UserMeta: meta}
return txn.SetEntry(e)
} | |
c175312 | bitDelete,
}
return txn.modify(e)
} | |
c175313 | err != nil {
return nil, errors.Wrapf(err, "DB::Get key: %q", key)
}
if vs.Value == nil && vs.Meta == 0 {
return nil, ErrKeyNotFound
}
if isDeletedOrExpired(vs.Meta, vs.ExpiresAt) {
return nil, ErrKeyNotFound
}
item.key = key
item.version = vs.Version
item.meta = vs.Meta
item.userMeta = vs.UserMeta
item.db = txn.db
item.vptr = vs.Value // TODO: Do we need to copy this over?
item.txn = txn
item.expiresAt = vs.ExpiresAt
return item, nil
} | |
c175314 | the CommitWith and the
// callback might be acquiring the same locks. Instead run the callback
// from another goroutine.
go runTxnCallback(&txnCb{user: cb, err: nil})
return
}
commitCb, err := txn.commitAndSend()
if err != nil {
go runTxnCallback(&txnCb{user: cb, err: err})
return
}
go runTxnCallback(&txnCb{user: cb, commit: commitCb})
} | |
c175315 | {
txn = db.NewTransaction(false)
}
defer txn.Discard()
return fn(txn)
} | |
c175316 |
defer txn.Discard()
if err := fn(txn); err != nil {
return err
}
return txn.Commit()
} | |
c175317 | >= 0 {
// We are done as k is >= key.
done = true
break
}
}
if !done {
itr.err = io.EOF
}
} | |
c175318 | itr.Init(); itr.Valid(); itr.Next() {
}
itr.Prev()
} | |
c175319 | errors.Errorf("Value exceeded size of block: %d %d %d %d %v",
itr.pos, h.klen, h.vlen, len(itr.data), h)
return
}
itr.val = y.SafeCopy(itr.val, itr.data[itr.pos:itr.pos+uint32(h.vlen)])
itr.pos += uint32(h.vlen)
} | |
c175320 | := &Iterator{t: t, reversed: reversed}
ti.next()
return ti
} | |
c175321 | idx == len(itr.t.blockIndex) {
// If idx == len(itr.t.blockIndex), then input key is greater than ANY element of table.
// There's nothing we can do. Valid() should return false as we seek to end of table.
return
}
// Since block[idx].smallest is > key. This is essentially a block[idx].SeekToFirst.
itr.seekHelper(idx, key)
}
// Case 2: No need to do anything. We already did the seek in block[idx-1].
} | |
c175322 | have to take a Prev step.
itr.seekFrom(key, origin)
if !bytes.Equal(itr.Key(), key) {
itr.prev()
}
} | |
c175323 | ret.Decode(itr.bi.Value())
return
} | |
c175324 |
} else {
itr.seekForPrev(key)
}
} | |
c175325 | iters,
tables: tbls,
idx: -1, // Not really necessary because s.it.Valid()=false, but good to have.
}
} | |
c175326 | s.cur != nil && s.cur.Valid()
} | |
c175327 | tables.
if !s.reversed {
s.setIdx(s.idx + 1)
} else {
s.setIdx(s.idx - 1)
}
if s.cur == nil {
// End of list. Valid will become false.
return
}
s.cur.Rewind()
if s.cur.Valid() {
break
}
}
} | |
c175328 | {
return errors.Wrap(err, "ConcatIterator")
}
}
return nil
} | |
c175329 | openFlags |= datasyncFileFlag
}
return os.OpenFile(filename, openFlags, 0)
} | |
c175330 | := make([]byte, len(a))
copy(b, a)
return b
} | |
c175331 | binary.BigEndian.PutUint64(out[len(key):], math.MaxUint64-ts)
return out
} | |
c175332 | binary.BigEndian.Uint64(key[len(key)-8:])
} | |
c175333 | AssertTrue(len(key) > 8)
return key[:len(key)-8]
} | |
c175334 | bytes.Equal(ParseKey(src), ParseKey(dst))
} | |
c175335 |
str = fmt.Sprintf("%02dm", int(d.Minutes())%60) + str
}
if d >= time.Hour {
str = fmt.Sprintf("%02dh", int(d.Hours())) + str
}
return str
} | |
c175336 | make(chan struct{})}
ret.waiting.Add(initial)
return ret
} | |
c175337 |
ch: make(chan struct{}, max),
errCh: make(chan error, max),
}
} | |
c175338 |
case err := <-t.errCh:
if err != nil {
return err
}
}
}
} | |
c175339 |
default:
panic("Throttle Do Done mismatch")
}
t.wg.Done()
} | |
c175340 | if err != nil {
return err
}
}
return nil
} | |
c175341 | {
panic("Cannot use SetDiscardTs with managedDB=false.")
}
db.orc.setDiscardTs(ts)
} | |
c175342 | %q", lf.path)
}
y.AssertTrue(fi.Size() <= math.MaxUint32)
lf.size = uint32(fi.Size())
if err = lf.mmap(fi.Size()); err != nil {
_ = lf.fd.Close()
return y.Wrapf(err, "Unable to map file")
}
return nil
} | |
c175343 |
break
}
} else if e.meta&bitFinTxn > 0 {
txnTs, err := strconv.ParseUint(string(e.Value), 10, 64)
if err != nil || lastCommit != txnTs {
break
}
// Got the end of txn. Now we can store them.
lastCommit = 0
validEndOffset = read.recordOffset
} else {
if lastCommit != 0 {
// This is most likely an entry which was moved as part of GC.
// We shouldn't get this entry in the middle of a transaction.
break
}
validEndOffset = read.recordOffset
}
if err := fn(*e, vp); err != nil {
if err == errStop {
break
}
return 0, errFile(err, lf.path, "Iteration function")
}
}
return validEndOffset, nil
} | |
c175344 | _, ok := toBeDeleted[fid]; !ok {
ret = append(ret, fid)
}
}
sort.Slice(ret, func(i, j int) bool {
return ret[i] < ret[j]
})
return ret
} | |
c175345 | plen, err := encodeEntry(e, &buf) // Now encode the entry into buffer.
if err != nil {
return err
}
p.Len = uint32(plen)
b.Ptrs = append(b.Ptrs, p)
}
vlog.numEntriesWritten += uint32(len(b.Entries))
// We write to disk here so that all entries that are part of the same transaction are
// written to the same vlog file.
writeNow :=
vlog.woffset()+uint32(buf.Len()) > uint32(vlog.opt.ValueLogFileSize) ||
vlog.numEntriesWritten > uint32(vlog.opt.ValueLogMaxEntries)
if writeNow {
if err := toDisk(); err != nil {
return err
}
}
}
return toDisk()
} | |
c175346 | }
var statsMap map[uint32]int64
if err := json.Unmarshal(vs.Value, &statsMap); err != nil {
return err
}
vlog.opt.Debugf("Value Log Discard stats: %v", statsMap)
vlog.lfDiscardStats = &lfDiscardStats{m: statsMap}
return nil
} | |
c175347 | {
stream := db.NewStream()
stream.LogPrefix = "DB.Backup"
return stream.Backup(w, since)
} | |
c175348 |
}
valCopy, err := item.ValueCopy(nil)
if err != nil {
return nil, err
}
kv := &pb.KV{
Key: item.KeyCopy(nil),
Value: valCopy,
UserMeta: []byte{item.UserMeta()},
Version: item.Version(),
ExpiresAt: item.ExpiresAt(),
}
list.Kv = append(list.Kv, kv)
if st.db.opt.NumVersionsToKeep == 1 {
break
}
if item.DiscardEarlierVersions() {
break
}
}
return list, nil
} | |
c175349 | empty and no splits exist. In that case, we should have at least one
// keyRange output.
st.rangeCh <- keyRange{left: start}
close(st.rangeCh)
} | |
c175350 | continue
}
prevKey = append(prevKey[:0], item.Key()...)
// Check if we reached the end of the key range.
if len(kr.right) > 0 && bytes.Compare(item.Key(), kr.right) >= 0 {
break
}
// Check if we should pick this key.
if st.ChooseKey != nil && !st.ChooseKey(item) {
continue
}
// Now convert to key value.
list, err := st.KeyToList(item.KeyCopy(nil), itr)
if err != nil {
return err
}
if list == nil || len(list.Kv) == 0 {
continue
}
outList.Kv = append(outList.Kv, list.Kv...)
size += list.Size()
if size >= pageSize {
st.kvChan <- outList
outList = new(pb.KVList)
size = 0
}
}
if len(outList.Kv) > 0 {
st.kvChan <- outList
}
return nil
}
for {
select {
case kr, ok := <-st.rangeCh:
if !ok {
// Done with the keys.
return nil
}
if err := iterate(kr); err != nil {
return err
}
case <-ctx.Done():
return ctx.Err()
}
}
} | |
c175351 |
case errCh <- err:
default:
}
}
}()
}
// Pick up key-values from kvChan and send to stream.
kvErr := make(chan error, 1)
go func() {
// Picks up KV lists from kvChan, and sends them to Output.
kvErr <- st.streamKVs(ctx)
}()
wg.Wait() // Wait for produceKVs to be over.
close(st.kvChan) // Now we can close kvChan.
select {
case err := <-errCh: // Check error from produceKVs.
return err
default:
}
// Wait for key streaming to be over.
err := <-kvErr
return err
} | |
c175352 | in managed mode.")
}
return db.newStream()
} | |
c175353 | }
stream := db.newStream()
stream.readTs = readTs
return stream
} | |
c175354 | the FS know that the file is deleted.
return err
}
filename := t.fd.Name()
if err := t.fd.Close(); err != nil {
return err
}
if err := os.Remove(filename); err != nil {
return err
}
}
return nil
} | |
c175355 | fileSuffix)
id, err := strconv.Atoi(name)
if err != nil {
return 0, false
}
y.AssertTrue(id >= 0)
return uint64(id), true
} | |
c175356 |
fmt.Printf("Histogram of key sizes (in bytes)\n")
histogram.keySizeHistogram.printHistogram()
fmt.Printf("Histogram of value sizes (in bytes)\n")
histogram.valueSizeHistogram.printHistogram()
} | |
c175357 | math.MaxInt64,
sum: 0,
},
valueSizeHistogram: histogramData{
bins: valueBins,
countPerBin: make([]int64, len(valueBins)+1),
max: math.MinInt64,
min: math.MaxInt64,
sum: 0,
},
}
} | |
c175358 | item := itr.Item()
badgerHistogram.keySizeHistogram.Update(item.KeySize())
badgerHistogram.valueSizeHistogram.Update(item.ValueSize())
}
return badgerHistogram
} | |
c175359 | count == 0 {
continue
}
// The last bin represents the bin that contains the range from
// the last bin up to infinity so it's processed differently than the
// other bins.
if index == len(histogram.countPerBin)-1 {
lowerBound := int(histogram.bins[numBins-1])
fmt.Printf("[%10d, %10s) %9d\n", lowerBound, "infinity", count)
continue
}
upperBound := int(histogram.bins[index])
lowerBound := 0
if index > 0 {
lowerBound = int(histogram.bins[index-1])
}
fmt.Printf("[%10d, %10d) %9d\n", lowerBound, upperBound, count)
}
fmt.Println()
} | |
c175360 | = trace.NewEventLog("Watermark", w.Name)
go w.process(closer)
} | |
c175361 | w.markCh <- mark{index: index, done: false}
} | |
c175362 | indices[len(indices)-1])
w.markCh <- mark{index: 0, indices: indices, done: false}
} | |
c175363 | mark{index: index, done: true}
} | |
c175364 | mark{index: 0, indices: indices, done: true}
} | |
c175365 | uint64) {
atomic.StoreUint64(&w.doneUntil, val)
} | |
c175366 | w.markCh <- mark{index: index, waiter: waitCh}
select {
case <-ctx.Done():
return ctx.Err()
case <-waitCh:
return nil
}
} | |
c175367 | binary.BigEndian.PutUint16(b[4:6], h.vlen)
binary.BigEndian.PutUint32(b[6:10], h.prev)
} | |
c175368 | binary.BigEndian.Uint16(buf[4:6])
h.prev = binary.BigEndian.Uint32(buf[6:10])
return h.Size()
} | |
c175369 | 20),
buf: newBuffer(1 << 20),
prevOffset: math.MaxUint32, // Used for the first element!
}
} | |
c175370 | if newKey[i] != b.baseKey[i] {
break
}
}
return newKey[i:]
} | |
c175371 | b.prevOffset = math.MaxUint32 // First key-value pair of block has header.prev=MaxInt.
}
b.addHelper(key, value)
return nil // Currently, there is no meaningful error.
} | |
c175372 | make([]byte, sz)
buf := out
for _, r := range b.restarts {
binary.BigEndian.PutUint32(buf[:4], r)
buf = buf[4:]
}
binary.BigEndian.PutUint32(buf[:4], uint32(len(b.restarts)))
return out
} | |
c175373 | This will never start a new block.
index := b.blockIndex()
b.buf.Write(index)
// Write bloom filter.
bdata := bf.JSONMarshal()
n, err := b.buf.Write(bdata)
y.Check(err)
var buf [4]byte
binary.BigEndian.PutUint32(buf[:], uint32(n))
b.buf.Write(buf[:])
return b.buf.Bytes()
} | |
c175374 | return
}
opt.Logger.Errorf(format, v...)
} | |
c175375 | return
}
opt.Logger.Infof(format, v...)
} | |
c175376 | are closed. Good for testing. Also, lets GC reclaim memory. Race condition
// here would suggest we are accessing skiplist when we are supposed to have no reference!
s.arena = nil
} | |
c175377 | return &Skiplist{
height: 1,
head: head,
arena: arena,
ref: 1,
}
} | |
c175378 | // the base level. But we know we are not on the base level.
y.AssertTrue(prev[i] != next[i])
}
nextOffset := s.arena.getNodeOffset(next[i])
x.tower[i] = nextOffset
if prev[i].casNextOffset(i, nextOffset, s.arena.getNodeOffset(x)) {
// Managed to insert x between prev[i] and next[i]. Go to the next level.
break
}
// CAS failed. We need to recompute prev and next.
// It is unlikely to be helpful to try to use a different level as we redo the search,
// because it is unlikely that lots of nodes are inserted between prev[i] and next[i].
prev[i], next[i] = s.findSpliceForLevel(key, prev[i], i)
if prev[i] == next[i] {
y.AssertTruef(i == 0, "Equality can happen only on base level: %d", i)
prev[i].setValue(s.arena, v)
return
}
}
}
} | |
c175379 | s.arena.getKey(n.keyOffset, n.keySize)
if !y.SameKey(key, nextKey) {
return y.ValueStruct{}
}
valOffset, valSize := n.getValueOffset()
vs := s.arena.getVal(valOffset, valSize)
vs.Version = y.ParseTs(nextKey)
return vs
} | |
c175380 | s.list.arena.getKey(s.n.keyOffset, s.n.keySize)
} | |
c175381 | return s.list.arena.getVal(valOffset, valSize)
} | |
c175382 | = s.list.getNext(s.n, 0)
} | |
c175383 | true, false) // find <. No equality allowed.
} | |
c175384 | s.list.findNear(target, false, true) // find >=.
} | |
c175385 | = s.list.findNear(target, true, true) // find <=.
} | |
c175386 | s.NewIterator(),
reversed: reversed,
}
} | |
c175387 |
} else {
s.iter.Prev()
}
} | |
c175388 |
} else {
s.iter.SeekForPrev(key)
}
} | |
c175389 | changes = append(changes, newCreateChange(id, int(tm.Level), tm.Checksum))
}
return changes
} | |
c175390 | nil {
return err
}
mf.fp = fp
mf.manifest.Creations = netCreations
mf.manifest.Deletions = 0
return nil
} | |
c175391 | }
if y.CompareKeys(s.tables[j].Smallest(), s.tables[j].Biggest()) > 0 {
return errors.Errorf(
"Intra: %q vs %q: level=%d j=%d numTables=%d",
s.tables[j].Smallest(), s.tables[j].Biggest(), s.level, j, numTables)
}
}
return nil
} | |
c175392 | ends, the file is deleted by the system.
// FILE_ATTRIBUTE_TEMPORARY is used to tell Windows to try to create the handle in memory.
// FILE_FLAG_DELETE_ON_CLOSE is not specified in syscall_windows.go but tells Windows to delete
// the file when all processes holding the handler are closed.
// XXX: this works but it's a bit klunky. i'd prefer to use LockFileEx but it needs unsafe pkg.
h, err := syscall.CreateFile(
syscall.StringToUTF16Ptr(absLockFilePath), 0, 0, nil,
syscall.OPEN_ALWAYS,
uint32(FILE_ATTRIBUTE_TEMPORARY|FILE_FLAG_DELETE_ON_CLOSE),
0)
if err != nil {
return nil, errors.Wrapf(err,
"Cannot create lock file %q. Another process is using this Badger database",
absLockFilePath)
}
return &directoryLockGuard{h: h, path: absLockFilePath}, nil
} | |
c175393 | error {
g.path = ""
return syscall.CloseHandle(g.h)
} | |
c175394 | {
if !b {
log.Fatalf("%+v", errors.Errorf(format, args...))
}
} | |
c175395 | {
return nil
}
return fmt.Errorf(format+" error: %+v", append(args, err)...)
}
return errors.Wrapf(err, format, args...)
} | |
c175396 | fileID in ascending order
// because newer tables are at the end of level 0.
sort.Slice(s.tables, func(i, j int) bool {
return s.tables[i].ID() < s.tables[j].ID()
})
} else {
// Sort tables by keys.
sort.Slice(s.tables, func(i, j int) bool {
return y.CompareKeys(s.tables[i].Smallest(), s.tables[j].Smallest()) < 0
})
}
} | |
c175397 | a slice of tables.
var newTables []*table.Table
for _, t := range s.tables {
_, found := toDelMap[t.ID()]
if !found {
newTables = append(newTables, t)
continue
}
s.totalSize -= t.Size()
}
s.tables = newTables
s.Unlock() // Unlock s _before_ we DecrRef our tables, which can be slow.
return decrRefs(toDel)
} | |
c175398 |
if len(s.tables) >= s.db.opt.NumLevelZeroTablesStall {
return false
}
s.tables = append(s.tables, t)
t.IncrRef()
s.totalSize += t.Size()
return true
} | |
c175399 | }
}
// For level >= 1, we can do a binary search as key range does not overlap.
idx := sort.Search(len(s.tables), func(i int) bool {
return y.CompareKeys(s.tables[i].Biggest(), key) >= 0
})
if idx >= len(s.tables) {
// Given key is strictly > than every element we have.
return nil, func() error { return nil }
}
tbl := s.tables[idx]
tbl.IncrRef()
return []*table.Table{tbl}, tbl.DecrRef
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.