示例#1
0
文件: table.go 项目: tradia/gotable
func seekAndCopySyncKV(it *Iterator, p *proto.KeyValue) (uint8, uint16, bool) {
	p.CtrlFlag &^= 0xFF

	slotId, dbId, tableId, colSpace, rowKey, colKey := parseRawKey(it.Key())

	switch colSpace {
	case proto.ColSpaceDefault:
		value, score := parseRawValue(it.Value())
		p.SetValue(value)
		p.SetScore(score)
	case proto.ColSpaceScore1:
		it.Seek(getRawKey(dbId, tableId, colSpace+1, rowKey, nil))
		if !it.Valid() {
			return dbId, slotId, false
		}
		return seekAndCopySyncKV(it, p)
	case proto.ColSpaceScore2:
		value, score := parseRawValue(it.Value())
		p.SetValue(value)
		p.SetScore(score)
	}

	p.TableId = tableId
	p.SetColSpace(colSpace)
	p.RowKey = rowKey
	p.ColKey = colKey

	return dbId, slotId, true
}
示例#2
0
文件: table.go 项目: tradia/gotable
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
}