Method Reader.nextChunk has 55 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (r *Reader) nextChunk(first bool) error {
    for {
        if r.j+headerSize <= r.n {
            checksum := binary.LittleEndian.Uint32(r.buf[r.j+0 : r.j+4])
            length := binary.LittleEndian.Uint16(r.buf[r.j+4 : r.j+6])

Method DB.recoverJournal has 12 return statements (exceeds 4 allowed).

Open

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

Function NewReader has 12 return statements (exceeds 4 allowed).

Open

func NewReader(f io.ReaderAt, size int64, fd storage.FileDesc, cache *cache.NamespaceGetter, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
    if f == nil {
        return nil, errors.New("leveldb/table: nil file")
    }

Method tFiles.getOverlaps has 54 lines of code (exceeds 50 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
    }

Function KeyValue_Generate has 54 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func KeyValue_Generate(rnd *rand.Rand, n, incr, minlen, maxlen, vminlen, vmaxlen int) *KeyValue {
    if rnd == nil {
        rnd = NewRand()
    }
    if maxlen < minlen {

Method DB.checkAndCleanFiles has 54 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (db *DB) checkAndCleanFiles() error {
    v := db.s.version()
    defer v.release()

    tmap := make(map[int64]bool)

Method mBucket.delete has 53 lines of code (exceeds 50 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()

Method DB.checkAndCleanFiles has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.

Open

func (db *DB) checkAndCleanFiles() error {
    v := db.s.version()
    defer v.release()

    tmap := make(map[int64]bool)

• Read up
  Read up

Method Reader.nextChunk has 11 return statements (exceeds 4 allowed).

Open

func (r *Reader) nextChunk(first bool) error {
    for {
        if r.j+headerSize <= r.n {
            checksum := binary.LittleEndian.Uint32(r.buf[r.j+0 : r.j+4])
            length := binary.LittleEndian.Uint16(r.buf[r.j+4 : r.j+6])

Method Cache.Get has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.

Open

func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
    r.mu.RLock()
    defer r.mu.RUnlock()
    if r.closed {
        return nil

• Read up
  Read up

Method Reader.find has 11 return statements (exceeds 4 allowed).

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 {

Method blockIter.Prev has 10 return statements (exceeds 4 allowed).

Open

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

Method BufferPool.Get has 10 return statements (exceeds 4 allowed).

Open

func (p *BufferPool) Get(n int) []byte {
    if p == nil {
        return make([]byte, n)
    }

Method DB.Write has 10 return statements (exceeds 4 allowed).

Open

func (db *DB) Write(batch *Batch, wo *opt.WriteOptions) error {
    if err := db.ok(); err != nil || batch == nil || batch.Len() == 0 {
        return err
    }

Method session.recover has a Cognitive Complexity of 24 (exceeds 20 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.

• Read up
  Read up

Method version.get has 8 return statements (exceeds 4 allowed).

Open

func (v *version) get(aux tFiles, ikey internalKey, ro *opt.ReadOptions, noValue bool) (value []byte, tcomp bool, err error) {
    if v.closing {
        return nil, false, ErrClosed
    }

Method blockIter.Next has 8 return statements (exceeds 4 allowed).

Open

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

Avoid deeply nested control flow statements.

Open

                    if db.resumeWrite() {
                        x.ack(nil)
                    } else {
                        waitQ = append(waitQ, x)
                    }

Avoid deeply nested control flow statements.

Open

                    if ourBatch == nil {
                        ourBatch = db.batchPool.Get().(*Batch)
                        ourBatch.Reset()
                        batches = append(batches, ourBatch)
                    }

Method DB.putRec has 7 return statements (exceeds 4 allowed).

Open

func (db *DB) putRec(kt keyType, key, value []byte, wo *opt.WriteOptions) error {
    if err := db.ok(); err != nil {
        return err
    }