johnsonjh/jleveldb

View on GitHub

Showing 142 of 166 total issues

Method Reader.readBlockCached has 6 return statements (exceeds 4 allowed).
Open

func (r *Reader) readBlockCached(bh blockHandle, verifyChecksum, fillCache bool) (*block, util.Releaser, error) {
    if r.cache != nil {
        var (
            err error
            ch  *cache.Handle
Severity: Major
Found in leveldb/table/reader.go - About 40 mins to fix

    Method testingStorage.scanTable has 6 return statements (exceeds 4 allowed).
    Open

    func (ts *testingStorage) scanTable(fd storage.FileDesc, checksum bool) (corrupted bool) {
        r, err := ts.Open(fd)
        if err != nil {
            log.Fatal(err)
        }
    Severity: Major
    Found in manualtest/dbstress/main.go - About 40 mins to fix

      Method indexedIterator.Last has 6 return statements (exceeds 4 allowed).
      Open

      func (i *indexedIterator) Last() bool {
          if i.err != nil {
              return false
          } else if i.Released() {
              i.err = ErrIterReleased
      Severity: Major
      Found in leveldb/iterator/indexed_iter.go - About 40 mins to fix

        Method singleReader.Read has 6 return statements (exceeds 4 allowed).
        Open

        func (x *singleReader) Read(p []byte) (int, error) {
            r := x.r
            if r.seq != x.seq {
                return 0, errors.New("leveldb/journal: stale reader")
            }
        Severity: Major
        Found in leveldb/journal/journal.go - About 40 mins to fix

          Method Reader.readRawBlock has 6 return statements (exceeds 4 allowed).
          Open

          func (r *Reader) readRawBlock(bh blockHandle, verifyChecksum bool) ([]byte, error) {
              data := r.bpool.Get(int(bh.length + blockTrailerLen))
              if _, err := r.reader.ReadAt(data, int64(bh.offset)); err != nil && err != io.EOF {
                  return nil, err
              }
          Severity: Major
          Found in leveldb/table/reader.go - About 40 mins to fix

            Method DB.flush has 6 return statements (exceeds 4 allowed).
            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()
                // 请问您知道这里为什么要用匿名函数吗,我理解的是直接用循环就可以
            Severity: Major
            Found in leveldb/db_write.go - About 40 mins to fix

              Method DB.OpenTransaction has 6 return statements (exceeds 4 allowed).
              Open

              func (db *DB) OpenTransaction() (*Transaction, error) {
                  if err := db.ok(); err != nil {
                      return nil, err
                  }
              
              
              Severity: Major
              Found in leveldb/db_transaction.go - About 40 mins to fix

                Method tableCompactionBuilder.run has 6 return statements (exceeds 4 allowed).
                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
                Severity: Major
                Found in leveldb/db_compaction.go - About 40 mins to fix

                  Method singleReader.ReadByte has 6 return statements (exceeds 4 allowed).
                  Open

                  func (x *singleReader) ReadByte() (byte, error) {
                      r := x.r
                      if r.seq != x.seq {
                          return 0, errors.New("leveldb/journal: stale reader")
                      }
                  Severity: Major
                  Found in leveldb/journal/journal.go - About 40 mins to fix

                    Method Transaction.Commit has 6 return statements (exceeds 4 allowed).
                    Open

                    func (tr *Transaction) Commit() error {
                        if err := tr.db.ok(); err != nil {
                            return err
                        }
                    
                    
                    Severity: Major
                    Found in leveldb/db_transaction.go - About 40 mins to fix

                      Method indexedIterator.Next has 6 return statements (exceeds 4 allowed).
                      Open

                      func (i *indexedIterator) Next() bool {
                          if i.err != nil {
                              return false
                          } else if i.Released() {
                              i.err = ErrIterReleased
                      Severity: Major
                      Found in leveldb/iterator/indexed_iter.go - About 40 mins to fix

                        Method indexedIterator.Seek has 6 return statements (exceeds 4 allowed).
                        Open

                        func (i *indexedIterator) Seek(key []byte) bool {
                            if i.err != nil {
                                return false
                            } else if i.Released() {
                                i.err = ErrIterReleased
                        Severity: Major
                        Found in leveldb/iterator/indexed_iter.go - About 40 mins to fix

                          Method Reader.readFilterBlockCached has 6 return statements (exceeds 4 allowed).
                          Open

                          func (r *Reader) readFilterBlockCached(bh blockHandle, fillCache bool) (*filterBlock, util.Releaser, error) {
                              if r.cache != nil {
                                  var (
                                      err error
                                      ch  *cache.Handle
                          Severity: Major
                          Found in leveldb/table/reader.go - About 40 mins to fix

                            Method session.newManifest has 6 return statements (exceeds 4 allowed).
                            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
                            Severity: Major
                            Found in leveldb/session_util.go - About 40 mins to fix

                              Method DB.recoverJournalRO has 6 return statements (exceeds 4 allowed).
                              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
                              Severity: Major
                              Found in leveldb/db.go - About 40 mins to fix

                                Method DB.SetReadOnly has 6 return statements (exceeds 4 allowed).
                                Open

                                func (db *DB) SetReadOnly() error {
                                    if err := db.ok(); err != nil {
                                        return err
                                    }
                                
                                
                                Severity: Major
                                Found in leveldb/db_write.go - About 40 mins to fix

                                  Method session.flushManifest has 6 return statements (exceeds 4 allowed).
                                  Open

                                  func (s *session) flushManifest(rec *sessionRecord) (err error) {
                                      if !s.o.GetNoSync() {
                                          err = s.manifestWriter.Sync()
                                          if err != nil {
                                              return
                                  Severity: Major
                                  Found in leveldb/session_util.go - About 40 mins to fix

                                    Function decodeBatchToMem has 6 return statements (exceeds 4 allowed).
                                    Open

                                    func decodeBatchToMem(data []byte, expectSeq uint64, mdb *memdb.DB) (seq uint64, batchLen int, err error) {
                                        seq, batchLen, err = decodeBatchHeader(data)
                                        if err != nil {
                                            return 0, 0, err
                                        }
                                    Severity: Major
                                    Found in leveldb/batch.go - About 40 mins to fix

                                      Method DB.get has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                      Open

                                      func (db *DB) get(auxm *memdb.DB, auxt tFiles, key []byte, seq uint64, ro *opt.ReadOptions) (value []byte, err error) {
                                      Severity: Minor
                                      Found in leveldb/db.go - About 35 mins to fix

                                        Method DB.newIterator has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                        Open

                                        func (db *DB) newIterator(auxm *memDB, auxt tFiles, seq uint64, slice *util.Range, ro *opt.ReadOptions) *dbIter {
                                        Severity: Minor
                                        Found in leveldb/db_iter.go - About 35 mins to fix
                                          Severity
                                          Category
                                          Status
                                          Source
                                          Language