func myDump(in proto.PkgDumpReq, au Authorize, t *testing.T) proto.PkgDumpResp {
var pkg = make([]byte, in.Length())
_, err := in.Encode(pkg)
if err != nil {
t.Fatalf("Encode failed: ", err)
}
pkg = testTbl.Dump(&PkgArgs{in.Cmd, in.DbId, in.Seq, pkg}, au)
var out proto.PkgDumpResp
_, err = out.Decode(pkg)
if err != nil {
t.Fatalf("Decode failed: ", err)
}
if out.ErrCode != 0 {
t.Fatalf("Failed with ErrCode %d", out.ErrCode)
}
if out.DbId != in.DbId || out.Seq != in.Seq {
t.Fatalf("DbId/Seq mismatch")
}
return out
}
func (tbl *Table) Dump(req *PkgArgs, au Authorize) []byte {
var out proto.PkgDumpResp
out.Cmd = req.Cmd
out.DbId = req.DbId
out.Seq = req.Seq
var in proto.PkgDumpReq
n, err := in.Decode(req.Pkg)
if err != nil || n != len(req.Pkg) {
return errorHandle(&out, table.EcDecodeFail)
}
out.StartSlotId = in.StartSlotId
out.EndSlotId = in.EndSlotId
out.LastSlotId = in.StartSlotId
out.PkgFlag = in.PkgFlag
out.PkgFlag &^= (proto.FlagDumpSlotStart | proto.FlagDumpEnd)
if in.DbId == proto.AdminDbId {
return errorHandle(&out, table.EcInvDbId)
}
if !au.IsAuth(in.DbId) {
return errorHandle(&out, table.EcNoPrivilege)
}
var onlyOneTable = (out.PkgFlag&proto.FlagDumpTable != 0)
var rOpt = tbl.db.NewReadOptions(false)
rOpt.SetFillCache(false)
defer rOpt.Destroy()
var it = tbl.db.NewIterator(rOpt)
defer it.Destroy()
if len(in.RowKey) == 0 {
it.Seek(getRawSlotKey(in.StartSlotId, in.DbId, in.TableId))
} else {
var rawColKey = in.ColKey
if in.ColSpace == proto.ColSpaceScore1 {
rawColKey = newScoreColKey(in.Score, in.ColKey)
}
it.Seek(getRawKey(in.DbId, in.TableId, in.ColSpace, in.RowKey, rawColKey))
if it.Valid() {
_, dbId, tableId, colSpace, rowKey, colKey := parseRawKey(it.Key())
if dbId == in.DbId && tableId == in.TableId &&
bytes.Compare(rowKey, in.RowKey) == 0 &&
colSpace == in.ColSpace &&
bytes.Compare(colKey, rawColKey) == 0 {
it.Next()
}
}
}
const maxScanNum = 1000
const maxTrySlotNum = 10
var triedSlotNum = 0
var pkgLen = proto.HeadSize + 1000
for it.Valid() && len(out.Kvs) < maxScanNum {
slotId, dbId, tableId, colSpace, rowKey, colKey := parseRawKey(it.Key())
if slotId < in.StartSlotId || slotId > in.EndSlotId {
out.PkgFlag |= proto.FlagDumpEnd
break
}
var misMatch bool
var nextSlotTableId uint8
// Dump only the selected TableId?
if onlyOneTable {
if dbId != in.DbId || tableId != in.TableId {
misMatch = true
nextSlotTableId = in.TableId
}
} else {
if dbId != in.DbId {
misMatch = true
}
}
if misMatch {
if triedSlotNum >= maxTrySlotNum {
break
}
var nextSlotId = out.LastSlotId + 1
if nextSlotId < slotId && slotId <= in.EndSlotId {
nextSlotId = slotId
}
if nextSlotId <= in.EndSlotId {
triedSlotNum++
out.LastSlotId = nextSlotId
out.PkgFlag |= proto.FlagDumpSlotStart
seekToSlot(it, nextSlotId, in.DbId, nextSlotTableId)
continue
} else {
out.PkgFlag |= proto.FlagDumpEnd
break
}
}
if colSpace == proto.ColSpaceScore2 {
it.Seek(getRawKey(dbId, tableId, colSpace+1, rowKey, nil))
continue // No need to dup dump
}
var kv proto.KeyValue
if colSpace != proto.ColSpaceScore1 {
kv.ColKey = colKey
kv.Value, kv.Score = parseRawValue(it.Value())
} else {
if len(colKey) < 8 {
it.Next()
continue // Skip invalid record
}
kv.Score = int64(binary.BigEndian.Uint64(colKey) - zopScoreUp)
kv.ColKey = colKey[8:]
kv.Value, _ = parseRawValue(it.Value())
}
kv.TableId = tableId
kv.RowKey = rowKey
kv.SetColSpace(colSpace)
if len(kv.Value) > 0 {
kv.CtrlFlag |= proto.CtrlValue
}
if kv.Score != 0 {
kv.CtrlFlag |= proto.CtrlScore
}
out.Kvs = append(out.Kvs, kv)
out.LastSlotId = slotId
out.PkgFlag &^= proto.FlagDumpSlotStart
pkgLen += kv.Length()
if pkgLen > proto.MaxPkgLen/2 {
out.PkgFlag &^= proto.FlagDumpEnd
break
}
it.Next()
}
if !it.Valid() {
out.PkgFlag |= proto.FlagDumpEnd
}
var pkg = make([]byte, out.Length())
_, err = out.Encode(pkg)
if err != nil {
log.Fatalf("Encode failed: %s\n", err)
}
return pkg
}