本文整理汇总了Golang中github.com/FoundationDB/fdb-go/fdb.Transactor.Pack方法的典型用法代码示例。如果您正苦于以下问题:Golang Transactor.Pack方法的具体用法?Golang Transactor.Pack怎么用?Golang Transactor.Pack使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类github.com/FoundationDB/fdb-go/fdb.Transactor
的用法示例。
在下文中一共展示了Transactor.Pack方法的2个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: processOp
//.........这里部分代码省略.........
path := sm.maybePath()
// This ***HAS*** to call Transact to ensure that any directory version
// key set in the process of trying to remove this potentially
// non-existent directory, in the REMOVE but not REMOVE_IF_EXISTS case,
// doesn't end up committing the version key. (Other languages have
// separate remove() and remove_if_exists() so don't have this tricky
// issue).
_, e := t.Transact(func(tr fdb.Transaction) (interface{}, error) {
ok, e := de.cwd().Remove(tr, path)
if e != nil {
panic(e)
}
switch op[6:] {
case "":
if !ok {
panic("directory does not exist")
}
case "_IF_EXISTS":
}
return nil, nil
})
if e != nil {
panic(e)
}
case op == "LIST":
subs, e := de.cwd().List(rt, sm.maybePath())
if e != nil {
panic(e)
}
t := make(tuple.Tuple, len(subs))
for i, s := range subs {
t[i] = s
}
sm.store(idx, t.Pack())
case op == "EXISTS":
b, e := de.cwd().Exists(rt, sm.maybePath())
if e != nil {
panic(e)
}
if b {
sm.store(idx, int64(1))
} else {
sm.store(idx, int64(0))
}
case op == "PACK_KEY":
tuples := sm.popTuples(1)
sm.store(idx, de.css().Pack(tuples[0]))
case op == "UNPACK_KEY":
t, e := de.css().Unpack(fdb.Key(sm.waitAndPop().item.([]byte)))
if e != nil {
panic(e)
}
for _, el := range t {
sm.store(idx, el)
}
case op == "RANGE":
ss := de.css().Sub(sm.popTuples(1)[0]...)
bk, ek := ss.FDBRangeKeys()
sm.store(idx, bk)
sm.store(idx, ek)
case op == "CONTAINS":
k := sm.waitAndPop().item.([]byte)
b := de.css().Contains(fdb.Key(k))
if b {
sm.store(idx, int64(1))
} else {
示例2: processInst
func (sm *StackMachine) processInst(idx int, inst tuple.Tuple) {
defer func() {
if r := recover(); r != nil {
switch r := r.(type) {
case fdb.Error:
sm.store(idx, []byte(tuple.Tuple{[]byte("ERROR"), []byte(fmt.Sprintf("%d", r.Code))}.Pack()))
default:
panic(r)
}
}
}()
var e error
op := inst[0].(string)
if sm.verbose {
fmt.Printf("%d. Instruction is %s (%v)\n", idx, op, sm.prefix)
fmt.Printf("Stack from [")
sm.dumpStack()
fmt.Printf(" ]\n")
}
var t fdb.Transactor
var rt fdb.ReadTransactor
var isDB bool
switch {
case strings.HasSuffix(op, "_SNAPSHOT"):
rt = sm.tr.Snapshot()
op = op[:len(op)-9]
case strings.HasSuffix(op, "_DATABASE"):
t = db
rt = db
op = op[:len(op)-9]
isDB = true
default:
t = sm.tr
rt = sm.tr
}
switch {
case op == "PUSH":
sm.store(idx, inst[1])
case op == "DUP":
entry := sm.stack[len(sm.stack)-1]
sm.store(entry.idx, entry.item)
case op == "EMPTY_STACK":
sm.stack = []stackEntry{}
sm.stack = make([]stackEntry, 0)
case op == "SWAP":
idx := sm.waitAndPop().item.(int64)
sm.stack[len(sm.stack)-1], sm.stack[len(sm.stack)-1-int(idx)] = sm.stack[len(sm.stack)-1-int(idx)], sm.stack[len(sm.stack)-1]
case op == "POP":
sm.stack = sm.stack[:len(sm.stack)-1]
case op == "SUB":
sm.store(idx, sm.waitAndPop().item.(int64)-sm.waitAndPop().item.(int64))
case op == "NEW_TRANSACTION":
sm.tr, e = db.CreateTransaction()
if e != nil {
panic(e)
}
case op == "ON_ERROR":
sm.store(idx, sm.tr.OnError(fdb.Error{int(sm.waitAndPop().item.(int64))}))
case op == "GET_READ_VERSION":
_, e = rt.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
sm.lastVersion = rtr.GetReadVersion().MustGet()
sm.store(idx, []byte("GOT_READ_VERSION"))
return nil, nil
})
if e != nil {
panic(e)
}
case op == "SET":
sm.executeMutation(t, func(tr fdb.Transaction) (interface{}, error) {
tr.Set(fdb.Key(sm.waitAndPop().item.([]byte)), sm.waitAndPop().item.([]byte))
return nil, nil
}, isDB, idx)
case op == "LOG_STACK":
prefix := sm.waitAndPop().item.([]byte)
for i := len(sm.stack) - 1; i >= 0; i-- {
if i%100 == 0 {
sm.tr.Commit().MustGet()
}
el := sm.waitAndPop()
var keyt tuple.Tuple
keyt = append(keyt, int64(i))
keyt = append(keyt, int64(el.idx))
pk := append(prefix, keyt.Pack()...)
var valt tuple.Tuple
valt = append(valt, el.item)
pv := valt.Pack()
vl := 40000
if len(pv) < vl {
vl = len(pv)
}
//.........这里部分代码省略.........