Beispiel #1
0
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
}
Beispiel #2
0
func (tbl *Table) zScanSortScore(in *proto.PkgScanReq, out *proto.PkgScanResp) {
	var it = tbl.db.NewIterator(nil)
	defer it.Destroy()

	var scanAsc = (in.PkgFlag&proto.FlagScanAsc != 0)
	var startSeek = (in.PkgFlag&proto.FlagScanKeyStart != 0)
	var scanColSpace uint8 = proto.ColSpaceScore1
	if scanAsc {
		if startSeek {
			// Seek to the first element
			it.Seek(getRawKey(in.DbId, in.TableId, scanColSpace,
				in.RowKey, nil))
		} else {
			it.Seek(getRawKey(in.DbId, in.TableId, scanColSpace,
				in.RowKey, newScoreColKey(in.Score, in.ColKey)))
		}
	} else {
		if startSeek {
			// Seek to the last element
			it.Seek(getRawKey(in.DbId, in.TableId, scanColSpace+1,
				in.RowKey, nil))
		} else {
			it.Seek(getRawKey(in.DbId, in.TableId, scanColSpace,
				in.RowKey, newScoreColKey(in.Score, in.ColKey)))
		}
		if !it.Valid() {
			it.SeekToLast()
		}
	}

	out.PkgFlag |= proto.FlagScanEnd
	var first = true
	var scanNum = int(in.Num)
	var pkgLen = proto.HeadSize + 1000
	for i := 0; it.Valid() && i < scanNum+1; iterMove(it, scanAsc) {
		_, dbId, tableId, colSpace, rowKey, colKey := parseRawKey(it.Key())
		if dbId != in.DbId || tableId != in.TableId ||
			colSpace != scanColSpace || bytes.Compare(rowKey, in.RowKey) != 0 {
			if first {
				first = false
				continue
			} else {
				break
			}
		}

		if first {
			first = false
		}

		if len(colKey) < 8 {
			continue //  skip invalid record
		}
		zColKey, zScore := parseZColKey(colKey)
		if !startSeek {
			if scanAsc {
				if zScore < in.Score {
					continue
				}
				if zScore == in.Score && bytes.Compare(zColKey, in.ColKey) <= 0 {
					continue
				}
			} else {
				if zScore > in.Score {
					continue
				}
				if zScore == in.Score && bytes.Compare(zColKey, in.ColKey) >= 0 {
					continue
				}
			}
		}

		if i < scanNum {
			var kv proto.KeyValue
			kv.TableId = in.TableId
			kv.RowKey = in.RowKey
			kv.ColKey = zColKey
			kv.Value, _ = parseRawValue(it.Value())
			kv.Score = zScore
			if len(kv.Value) > 0 {
				kv.CtrlFlag |= proto.CtrlValue
			}
			if kv.Score != 0 {
				kv.CtrlFlag |= proto.CtrlScore
			}
			out.Kvs = append(out.Kvs, kv)

			pkgLen += kv.Length()
			if pkgLen > proto.MaxPkgLen/2 {
				out.PkgFlag &^= proto.FlagScanEnd
				break
			}
		} else {
			out.PkgFlag &^= proto.FlagScanEnd
			break
		}
		i++
	}
}