IteratorTesting has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

type IteratorTesting struct {
    KeyValue
    Iter         iterator.Iterator
    Rand         *rand.Rand
    PostFn       func(t *IteratorTesting)

Method DB.tCompaction has 77 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (db *DB) tCompaction() {
    var (
        x     cCmd
        waitQ []cCmd
    )

Method DB.writeLocked has 75 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (db *DB) writeLocked(batch, ourBatch *Batch, merge, sync bool) error {
    // Try to flush memdb. This method would also trying to throttle writes
    // if it is too fast and compaction cannot catch-up.
    mdb, mdbFree, err := db.flush(batch.internalLen)
    if err != nil {

Method tableCompactionBuilder.run has 74 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (b *tableCompactionBuilder) run(cnt *compactionTransactCounter) (err error) {
    snapResumed := b.snapIter > 0
    hasLastUkey := b.snapHasLastUkey // The key might has zero length, so this is necessary.
    lastUkey := append([]byte{}, b.snapLastUkey...)
    lastSeq := b.snapLastSeq

Method versionStaging.finish has 73 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (p *versionStaging) finish(trivial bool) *version {
    // Build new version.
    nv := newVersion(p.base.s)
    numLevel := len(p.levels)
    if len(p.base.levels) > numLevel {

Method Reader.find has 72 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (r *Reader) find(key []byte, filtered bool, ro *opt.ReadOptions, noValue bool) (rkey, value []byte, err error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    if r.err != nil {

Function KeyValueTesting has 70 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB, teardown func(DB)) {
    if rnd == nil {
        rnd = NewRand()
    }

Method DB.recoverJournalRO has 69 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (db *DB) recoverJournalRO() error {
    // Get all journals and sort it by file number.
    rawFds, err := db.s.stor.List(storage.TypeJournal)
    if err != nil {
        return err

Method blockIter.Prev has a Cognitive Complexity of 29 (exceeds 20 allowed). Consider refactoring.

Open

func (i *blockIter) Prev() bool {
    if i.dir == dirSOI || i.err != nil {
        return false
    } else if i.dir == dirReleased {
        i.err = ErrIterReleased

• Read up
  Read up

Method testingStorage.scanTable has 68 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (ts *testingStorage) scanTable(fd storage.FileDesc, checksum bool) (corrupted bool) {
    r, err := ts.Open(fd)
    if err != nil {
        log.Fatal(err)
    }

Function recoverTable has 18 return statements (exceeds 4 allowed).

Open

func recoverTable(s *session, o *opt.Options) error {
    o = dupOptions(o)
    // Mask StrictReader, lets StrictRecovery doing its job.
    o.Strict &= ^opt.StrictReader

Method session.recover has 66 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *session) recover() (err error) {
    defer func() {
        if os.IsNotExist(err) {
            // Don't return os.ErrNotExist if the underlying storage contains
            // other files that belong to LevelDB. So the DB won't get trashed.

Method mBucket.delete has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.

Open

func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
    b.mu.Lock()

    if b.frozen {
        b.mu.Unlock()

• Read up
  Read up

Method tFiles.getOverlaps has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.

Open

func (tf tFiles) getOverlaps(dst tFiles, icmp *iComparer, umin, umax []byte, overlapped bool) tFiles {
    // Short circuit if tf is empty
    if len(tf) == 0 {
        return nil
    }

• Read up
  Read up

Method sessionRecord.decode has 63 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (p *sessionRecord) decode(r io.Reader) error {
    br, ok := r.(byteReader)
    if !ok {
        br = bufio.NewReader(r)
    }

Method DB.flush has 62 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (db *DB) flush(n int) (mdb *memDB, mdbFree int, err error) {
    delayed := false
    slowdownTrigger := db.s.o.GetWriteL0SlowdownTrigger()
    pauseTrigger := db.s.o.GetWriteL0PauseTrigger()
    // 请问您知道这里为什么要用匿名函数吗，我理解的是直接用循环就可以

Method DB.memCompaction has 60 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (db *DB) memCompaction() {
    mdb := db.getFrozenMem()
    if mdb == nil {
        return
    }

Method mNode.initBucket has a Cognitive Complexity of 26 (exceeds 20 allowed). Consider refactoring.

Open

func (n *mNode) initBucket(i uint32) *mBucket {
    if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
        return b
    }

• Read up
  Read up

Method dbIter.prev has a Cognitive Complexity of 26 (exceeds 20 allowed). Consider refactoring.

Open

func (i *dbIter) prev() bool {
    i.dir = dirBackward
    del := true
    if i.iter.Valid() {
        for {

• Read up
  Read up

Method session.newManifest has 56 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (s *session) newManifest(rec *sessionRecord, v *version) (err error) {
    fd := storage.FileDesc{Type: storage.TypeManifest, Num: s.allocFileNum()}
    writer, err := s.stor.Create(fd)
    if err != nil {
        return