wbtiger
/
foundationdb
mirror of https://github.com/apple/foundationdb.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

reformatted go recipes as well

This commit is contained in:
Alec Grieser 2018-01-24 18:45:08 -08:00
parent fa5e7fca38
commit c00df6e43c
8 changed files with 230 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
recipes/go-recipes/blob.go
View File

@ -21,11 +21,11 @@
package main
import (
"fmt"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"fmt"
)
const CHUNK_SIZE int = 5
@ -34,10 +34,12 @@ func write_blob(t fdb.Transactor, blob_subspace subspace.Subspace, blob []byte)
_, err = t.Transact(func(tr fdb.Transaction) (interface{}, error) {
if len(blob) == 0 { return nil, nil }
if len(blob) == 0 {
return nil, nil
}
for i := 0; i < len(blob); i+=CHUNK_SIZE {
if i + CHUNK_SIZE <= len(blob) {
for i := 0; i < len(blob); i += CHUNK_SIZE {
if i+CHUNK_SIZE <= len(blob) {
tr.Set(blob_subspace.Pack(tuple.Tuple{i}), blob[i:i+CHUNK_SIZE])
} else {
tr.Set(blob_subspace.Pack(tuple.Tuple{i}), blob[i:])
@ -54,7 +56,7 @@ func read_blob(t fdb.ReadTransactor, blob_subspace subspace.Subspace) ([]byte, e
var blob []byte
ri := rtr.GetRange(blob_subspace, fdb.RangeOptions{}).Iterator();
ri := rtr.GetRange(blob_subspace, fdb.RangeOptions{}).Iterator()
for ri.Advance() {

121
recipes/go-recipes/doc.go
View File

@ -21,14 +21,14 @@
package main
import (
"fmt"
"io/ioutil"
"math/rand"
"encoding/json"
"fmt"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"io/ioutil"
"math/rand"
)
func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@ -50,14 +50,15 @@ func print_subspace(trtr fdb.Transactor, sub subspace.Subspace) {
})
}
func _pack(t interface{}) []byte {
return tuple.Tuple{t}.Pack()
}
func _unpack(t []byte) tuple.Tuple {
i, e := tuple.Unpack(t)
if e != nil {return nil}
if e != nil {
return nil
}
return i
}
@ -67,7 +68,9 @@ const EmptyList int = -2
func ToTuples(item interface{}) []tuple.Tuple {
switch i := item.(type) {
case []interface{}:
if len(i) == 0 {return []tuple.Tuple{tuple.Tuple{EmptyList}}}
if len(i) == 0 {
return []tuple.Tuple{tuple.Tuple{EmptyList}}
}
tuples := make([]tuple.Tuple, 0)
for i, v := range i {
for _, t := range ToTuples(v) {
@ -76,7 +79,9 @@ func ToTuples(item interface{}) []tuple.Tuple {
}
return tuples
case map[string]interface{}:
if len(i) == 0 {return []tuple.Tuple{tuple.Tuple{EmptyObject}}}
if len(i) == 0 {
return []tuple.Tuple{tuple.Tuple{EmptyObject}}
}
tuples := make([]tuple.Tuple, 0)
for k, v := range i {
for _, t := range ToTuples(v) {
@ -92,42 +97,52 @@ func ToTuples(item interface{}) []tuple.Tuple {
func FromTuples(tuples []tuple.Tuple) interface{} {
//fmt.Println(tuples)
if len(tuples) == 0 {return nil}
if len(tuples) == 0 {
return nil
}
first := tuples[0]
if len(first) == 1 {return first[0]}
if first[0] == EmptyObject {return make(map[string]interface{}, 0)}
if first[0] == EmptyList {return make([]interface{}, 0)}
if len(first) == 1 {
return first[0]
}
if first[0] == EmptyObject {
return make(map[string]interface{}, 0)
}
if first[0] == EmptyList {
return make([]interface{}, 0)
}
group := make(map[string][]tuple.Tuple)
for _, t := range tuples {
k := string(_pack(t[0]))
_, ok := group[k]
if !ok {group[k] = make([]tuple.Tuple, 0)}
if !ok {
group[k] = make([]tuple.Tuple, 0)
}
group[k] = append(group[k], t[0:len(t)])
}
switch first[0].(type) {
case int64:
res := make([]interface{}, 0)
for _, g := range group {
subtup := make([]tuple.Tuple, 0)
for _, t := range g {
subtup = append(subtup, t[1:len(t)])
}
res = append(res, FromTuples(subtup))
case int64:
res := make([]interface{}, 0)
for _, g := range group {
subtup := make([]tuple.Tuple, 0)
for _, t := range g {
subtup = append(subtup, t[1:len(t)])
}
return res
default:
res := make(map[string]interface{})
for _, g := range group {
subtup := make([]tuple.Tuple, 0)
for _, t := range g {
subtup = append(subtup, t[1:len(t)])
}
res[g[0][0].(string)] = FromTuples(subtup)
res = append(res, FromTuples(subtup))
}
return res
default:
res := make(map[string]interface{})
for _, g := range group {
subtup := make([]tuple.Tuple, 0)
for _, t := range g {
subtup = append(subtup, t[1:len(t)])
}
return res
res[g[0][0].(string)] = FromTuples(subtup)
}
return res
}
}
@ -140,23 +155,23 @@ func (doc Doc) InsertDoc(trtr fdb.Transactor, docdata []byte) int {
json.Unmarshal(docdata, &data)
docid := 0
switch d := data.(type) {
case map[string]interface{}:
temp, ok := d["doc_id"]
if !ok {
docid = doc._GetNewID(trtr)
d["doc_id"] = docid
} else {
docid = temp.(int)
case map[string]interface{}:
temp, ok := d["doc_id"]
if !ok {
docid = doc._GetNewID(trtr)
d["doc_id"] = docid
} else {
docid = temp.(int)
}
tuples := ToTuples(d)
trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
for _, t := range tuples {
tr.Set(doc.DocSS.Pack(append(tuple.Tuple{d["doc_id"]}, t[0:len(t)-1]...)), _pack(t[len(t)-1]))
}
tuples := ToTuples(d)
trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
for _, t := range tuples {
tr.Set(doc.DocSS.Pack(append(tuple.Tuple{d["doc_id"]}, t[0:len(t)-1]...)), _pack(t[len(t)-1]))
}
return nil, nil
})
return nil, nil
})
}
return docid
return docid
}
func (doc Doc) _GetNewID(trtr fdb.Transactor) int {
@ -165,7 +180,9 @@ func (doc Doc) _GetNewID(trtr fdb.Transactor) int {
for true {
new_id = rand.Intn(100000007)
rp, err := fdb.PrefixRange(doc.DocSS.Pack(tuple.Tuple{new_id}))
if err != nil {continue}
if err != nil {
continue
}
res, err := tr.GetRange(rp, fdb.RangeOptions{1, -1, false}).GetSliceWithError()
if len(res) == 0 {
@ -181,14 +198,18 @@ func (doc Doc) GetDoc(trtr fdb.Transactor, doc_id int) interface{} {
tuples := make([]tuple.Tuple, 0)
trtr.ReadTransact(func(tr fdb.ReadTransaction) (interface{}, error) {
kr, err := fdb.PrefixRange(doc.DocSS.Pack(tuple.Tuple{doc_id}))
if err != nil {panic(err)}
if err != nil {
panic(err)
}
items := tr.GetRange(kr, fdb.RangeOptions{}).Iterator()
for items.Advance() {
v := items.MustGet()
tup, err := doc.DocSS.Unpack(v.Key)
if err != nil {panic(err)}
if err != nil {
panic(err)
}
tuples = append(tuples, append(tup[1:len(tup)], _unpack(v.Value)))
}
return nil, nil
@ -203,7 +224,9 @@ func main() {
db := fdb.MustOpenDefault()
DocDemoDir, err := directory.CreateOrOpen(db, []string{"docdemo"}, nil)
if err != nil {panic(err)}
if err != nil {
panic(err)
}
clear_subspace(db, DocDemoDir)

54
recipes/go-recipes/graph.go
View File

@ -21,12 +21,12 @@
package main
import (
"fmt"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"log"
"fmt"
)
func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@ -50,8 +50,8 @@ func (graph *Graph) NewGraph(dir subspace.Subspace, name string) {
func (graph *Graph) set_edge(trtr fdb.Transactor, node, neighbor int) (inter interface{}, err error) {
inter, err = trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
tr.Set(graph.EdgeSpace.Pack( tuple.Tuple{ node, neighbor } ), []byte(""))
tr.Set(graph.InvSpace.Pack( tuple.Tuple{ neighbor, node } ), []byte(""))
tr.Set(graph.EdgeSpace.Pack(tuple.Tuple{node, neighbor}), []byte(""))
tr.Set(graph.InvSpace.Pack(tuple.Tuple{neighbor, node}), []byte(""))
return nil, nil
})
return
@ -59,8 +59,8 @@ func (graph *Graph) set_edge(trtr fdb.Transactor, node, neighbor int) (inter int
func (graph *Graph) del_edge(trtr fdb.Transactor, node, neighbor int) (inter interface{}, err error) {
inter, err = trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
tr.Clear(graph.EdgeSpace.Pack( tuple.Tuple{ node, neighbor } ))
tr.Clear(graph.InvSpace.Pack( tuple.Tuple{ neighbor, node } ))
tr.Clear(graph.EdgeSpace.Pack(tuple.Tuple{node, neighbor}))
tr.Clear(graph.InvSpace.Pack(tuple.Tuple{neighbor, node}))
return nil, nil
})
return
@ -70,10 +70,12 @@ func (graph *Graph) get_out_neighbors(trtr fdb.Transactor, node int) ([]int, err
val, err := trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
kr, err := fdb.PrefixRange(graph.EdgeSpace.Pack( tuple.Tuple{ node } ))
if err != nil { return nil, err }
kr, err := fdb.PrefixRange(graph.EdgeSpace.Pack(tuple.Tuple{node}))
if err != nil {
return nil, err
}
ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator();
ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator()
neighbors := make([]int, 0)
for ri.Advance() {
@ -81,7 +83,9 @@ func (graph *Graph) get_out_neighbors(trtr fdb.Transactor, node int) ([]int, err
kv := ri.MustGet()
t, err := graph.EdgeSpace.Unpack(kv.Key)
if err != nil { return nil, err }
if err != nil {
return nil, err
}
neighbors = append(neighbors, int(t[1].(int64)))
}
@ -94,10 +98,12 @@ func (graph *Graph) get_out_neighbors(trtr fdb.Transactor, node int) ([]int, err
func (graph *Graph) get_in_neighbors(trtr fdb.Transactor, node int) ([]int, error) {
val, err := trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
kr, err := fdb.PrefixRange(graph.InvSpace.Pack( tuple.Tuple{ node } ))
if err != nil { return nil, err }
kr, err := fdb.PrefixRange(graph.InvSpace.Pack(tuple.Tuple{node}))
if err != nil {
return nil, err
}
ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator();
ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator()
neighbors := make([]int, 0)
for ri.Advance() {
@ -105,7 +111,9 @@ func (graph *Graph) get_in_neighbors(trtr fdb.Transactor, node int) ([]int, erro
t, err := graph.InvSpace.Unpack(kv.Key)
if err != nil { return nil, err }
if err != nil {
return nil, err
}
neighbors = append(neighbors, int(t[1].(int64)))
}
@ -121,7 +129,9 @@ func main() {
db := fdb.MustOpenDefault()
GraphDemoDir, err := directory.CreateOrOpen(db, []string{"Graph"}, nil)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
clear_subspace(db, GraphDemoDir)
@ -134,22 +144,30 @@ func main() {
g.set_edge(db, 1, 2)
i, err := g.get_out_neighbors(db, 0)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
fmt.Println(i)
_, err = g.del_edge(db, 0, 2)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
i, err = g.get_in_neighbors(db, 2)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
fmt.Println(i)
clear_subspace(db, GraphDemoDir)
i, err = g.get_in_neighbors(db, 2)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
fmt.Println(i)
}

25
recipes/go-recipes/indirect.go
View File

@ -21,12 +21,12 @@
package main
import (
"log"
"fmt"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"log"
)
func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@ -54,19 +54,23 @@ func _pack(t interface{}) []byte {
func _unpack(t []byte) tuple.Tuple {
i, e := tuple.Unpack(t)
if e != nil {return nil}
if e != nil {
return nil
}
return i
}
type Workspace struct {
Dir directory.Directory
db fdb.Database
db fdb.Database
}
func (wrkspc Workspace) _Update(trtr fdb.Transactor) {
trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
_, err := wrkspc.Dir.Remove(tr, []string{"current"})
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
_, err = wrkspc.Dir.Move(tr, []string{"new"}, []string{"current"})
return nil, err
@ -80,7 +84,9 @@ func (wrkspc Workspace) GetCurrent() (dir directory.DirectorySubspace, err error
func (wrkspc Workspace) Session(foo func(directory.DirectorySubspace)) (err error) {
newdir, err := wrkspc.Dir.CreateOrOpen(wrkspc.db, []string{"new"}, nil)
if err != nil {return}
if err != nil {
return
}
foo(newdir)
wrkspc._Update(wrkspc.db)
return
@ -92,7 +98,9 @@ func main() {
db := fdb.MustOpenDefault()
WorkspaceDemoDir, err := directory.CreateOrOpen(db, []string{"Workspace"}, nil)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
clear_subspace(db, WorkspaceDemoDir)
@ -108,7 +116,6 @@ func main() {
print_subspace(db, current)
w.Session(func(dir directory.DirectorySubspace) {
db.Transact(func(tr fdb.Transaction) (interface{}, error) {
tr.Set(dir.Pack(tuple.Tuple{"b"}), _pack("World"))
@ -116,6 +123,8 @@ func main() {
})
})
current, err = w.GetCurrent()
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
print_subspace(db, current)
}

26
recipes/go-recipes/multi.go
View File

@ -34,13 +34,13 @@ func clear_subspace(db fdb.Transactor, ss subspace.Subspace) {
db.Transact(func(tr fdb.Transaction) (interface{}, error) {
tr.ClearRange(ss)
return nil, nil
})
})
return
}
type MultiMap struct {
MapSS subspace.Subspace
MapSS subspace.Subspace
Pos, Neg []byte
}
@ -72,13 +72,17 @@ func (multi MultiMap) MultiSubtract(trtr fdb.Transactor, index, value interface{
func (multi MultiMap) MultiGet(tr fdb.ReadTransactor, index int) (ret []interface{}, e error) {
_, e = tr.ReadTransact(func(tr fdb.ReadTransaction) (interface{}, error) {
pr, err := fdb.PrefixRange(multi.MapSS.Pack(tuple.Tuple{index}))
if err != nil {return nil, err}
if err != nil {
return nil, err
}
kvs := tr.GetRange(pr, fdb.RangeOptions{0, -1, false}).GetSliceOrPanic()
ret := make([]interface{}, len(kvs))
i := 0
for _, kv := range kvs {
temp, err := multi.MapSS.Unpack(kv.Key)
if err != nil {return nil, err}
if err != nil {
return nil, err
}
ret[i] = temp[1]
i++
}
@ -89,8 +93,10 @@ func (multi MultiMap) MultiGet(tr fdb.ReadTransactor, index int) (ret []interfac
func (multi MultiMap) MultiGetCounts(trtr fdb.Transactor, index interface{}) (map[interface{}]int, error) {
i, e := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
kr, err := fdb.PrefixRange(multi.MapSS.Pack( tuple.Tuple{}))
if err != nil {return nil, err}
kr, err := fdb.PrefixRange(multi.MapSS.Pack(tuple.Tuple{}))
if err != nil {
return nil, err
}
ks, err := tr.GetRange(kr, fdb.RangeOptions{}).GetSliceWithError()
@ -99,10 +105,12 @@ func (multi MultiMap) MultiGetCounts(trtr fdb.Transactor, index interface{}) (ma
for _, v := range ks {
bs := v.Value
k, err := multi.MapSS.Unpack(v.Key)
if err != nil {return nil, err}
if err != nil {
return nil, err
}
counts[k[1]] = 0
for i, j := 0, 1; i < len(bs); i++ {
counts[k[1]] += int(bs[i])*j
counts[k[1]] += int(bs[i]) * j
j = j << 4
}
}
@ -113,7 +121,7 @@ func (multi MultiMap) MultiGetCounts(trtr fdb.Transactor, index interface{}) (ma
func (multi MultiMap) MultiIsElement(trtr fdb.Transactor, index, value interface{}) bool {
item, _ := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
r := tr.Get(multi.MapSS.Pack(tuple.Tuple{ index, value } )).MustGet()
r := tr.Get(multi.MapSS.Pack(tuple.Tuple{index, value})).MustGet()
if r == nil {
return false, nil
}

49
recipes/go-recipes/priority.go
View File

@ -21,13 +21,13 @@
package main
import (
"log"
"fmt"
"math/rand"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"log"
"math/rand"
)
func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@ -44,7 +44,9 @@ func _pack(t interface{}) []byte {
func _unpack(t []byte) tuple.Tuple {
i, e := tuple.Unpack(t)
if e != nil {return nil}
if e != nil {
return nil
}
return i
}
@ -61,26 +63,38 @@ func (prty Priority) Push(trtr fdb.Transactor, value interface{}, priority int)
func (prty Priority) _NextCount(trtr fdb.Transactor, priority int) int {
res, err := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
kr, e := fdb.PrefixRange(prty.PrioritySS.Pack( tuple.Tuple{priority} ))
if e != nil {return nil, e}
kr, e := fdb.PrefixRange(prty.PrioritySS.Pack(tuple.Tuple{priority}))
if e != nil {
return nil, e
}
ks, e := tr.Snapshot().GetRange(kr, fdb.RangeOptions{1, -1, true}).GetSliceWithError()
if e != nil {return nil, e}
if e != nil {
return nil, e
}
if len(ks) == 0 {return 0, nil}
if len(ks) == 0 {
return 0, nil
}
k, e := prty.PrioritySS.Unpack(ks[0].Key)
return k[0].(int)+1, nil
return k[0].(int) + 1, nil
})
if err != nil {return 0}
if err != nil {
return 0
}
return res.(int)
}
func (prty Priority) Pop(trtr fdb.Transactor, max bool) interface{} {
res, _ := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
ks, err := tr.GetRange(prty.PrioritySS, fdb.RangeOptions{1, -1, max}).GetSliceWithError()
if err != nil {return nil, err}
if err != nil {
return nil, err
}
if len(ks) == 0 {return nil, nil}
if len(ks) == 0 {
return nil, nil
}
tr.Clear(ks[0].Key)
return _unpack(ks[0].Value)[0], nil
})
@ -90,22 +104,27 @@ func (prty Priority) Pop(trtr fdb.Transactor, max bool) interface{} {
func (prty Priority) Peek(trtr fdb.Transactor, max bool) interface{} {
res, _ := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
ks, err := tr.GetRange(prty.PrioritySS, fdb.RangeOptions{1, -1, max}).GetSliceWithError()
if err != nil {return nil, err}
if len(ks) == 0 {return nil, nil}
if err != nil {
return nil, err
}
if len(ks) == 0 {
return nil, nil
}
return _unpack(ks[0].Value)[0], nil
})
return res
}
func main() {
fdb.MustAPIVersion(510)
db := fdb.MustOpenDefault()
PriorityDemoDir, err := directory.CreateOrOpen(db, []string{"Priority"}, nil)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
clear_subspace(db, PriorityDemoDir)

26
recipes/go-recipes/queue.go
View File

@ -21,15 +21,15 @@
package main
import (
"fmt"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"log"
"fmt"
)
type EmptyQueueError struct {}
type EmptyQueueError struct{}
func (q EmptyQueueError) Error() string {
return "Queue is Empty"
@ -54,7 +54,9 @@ func (q *Queue) NewQueue(ss subspace.Subspace) {
func (q *Queue) Dequeue(trtr fdb.Transactor) (interface{}, error) {
i, e := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
item, err := q.FirstItem(tr)
if err != nil {return nil, err}
if err != nil {
return nil, err
}
tr.Clear(item.(fdb.KeyValue).Key)
return item.(fdb.KeyValue).Value, err
})
@ -64,12 +66,16 @@ func (q *Queue) Dequeue(trtr fdb.Transactor) (interface{}, error) {
func (q *Queue) Enqueue(trtr fdb.Transactor, item interface{}) (interface{}, error) {
i, e := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
index, err := q.LastIndex(tr)
if err != nil {return nil, err}
if err != nil {
return nil, err
}
ki, err := q.QueueSS.Unpack(index.(fdb.Key))
if err != nil {return nil, err}
if err != nil {
return nil, err
}
tr.Set(q.QueueSS.Pack(tuple.Tuple{ki[0].(int64)+1}), []byte(item.(string)))
tr.Set(q.QueueSS.Pack(tuple.Tuple{ki[0].(int64) + 1}), []byte(item.(string)))
return nil, nil
})
@ -106,7 +112,9 @@ func main() {
db := fdb.MustOpenDefault()
QueueDemoDir, err := directory.CreateOrOpen(db, []string{"Queue"}, nil)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
clear_subspace(db, QueueDemoDir)
@ -119,7 +127,9 @@ func main() {
q.Enqueue(db, "test3")
for i := 0; i < 5; i++ {
item, e := q.Dequeue(db)
if e != nil {log.Fatal(e)}
if e != nil {
log.Fatal(e)
}
fmt.Println(string(item.([]byte)))
}

40
recipes/go-recipes/table.go
View File

@ -21,12 +21,12 @@
package main
import (
"log"
"fmt"
"github.com/apple/foundationdb/bindings/go/src/fdb"
"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
"log"
)
func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@ -43,7 +43,9 @@ func _pack(t interface{}) []byte {
func _unpack(t []byte) tuple.Tuple {
i, e := tuple.Unpack(t)
if e != nil {return nil}
if e != nil {
return nil
}
return i
}
@ -65,7 +67,7 @@ func (tbl Table) TableSetCell(trtr fdb.Transactor, row, column int, value interf
}
func (tbl Table) TableGetCell(trtr fdb.Transactor, row, column int) interface{} {
item, _:= trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
item, _ := trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
i := rtr.Get(tbl.row.Pack(tuple.Tuple{row, column})).MustGet()
return i, nil
})
@ -75,7 +77,9 @@ func (tbl Table) TableGetCell(trtr fdb.Transactor, row, column int) interface{}
func (tbl Table) TableSetRow(trtr fdb.Transactor, row int, cols ...interface{}) {
trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
kr, err := fdb.PrefixRange(tbl.row.Pack(tuple.Tuple{row}))
if err != nil {return nil, err}
if err != nil {
return nil, err
}
tr.ClearRange(kr)
@ -90,10 +94,14 @@ func (tbl Table) TableSetRow(trtr fdb.Transactor, row int, cols ...interface{})
func (tbl Table) TableGetRow(tr fdb.ReadTransactor, row int) ([]interface{}, error) {
item, err := tr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
kr, e := fdb.PrefixRange(tbl.row.Pack(tuple.Tuple{row}))
if e != nil {return nil, e}
if e != nil {
return nil, e
}
slice, e := rtr.GetRange(kr, fdb.RangeOptions{0, -1, false}).GetSliceWithError()
if e != nil {return nil, e}
if e != nil {
return nil, e
}
ret := make([]interface{}, len(slice))
@ -103,17 +111,23 @@ func (tbl Table) TableGetRow(tr fdb.ReadTransactor, row int) ([]interface{}, err
return ret, nil
})
if err != nil {return nil, err}
if err != nil {
return nil, err
}
return item.([]interface{}), nil
}
func (tbl Table) TableGetCol(tr fdb.ReadTransactor, col int) ([]interface{}, error) {
item, err := tr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
kr, e := fdb.PrefixRange(tbl.col.Pack(tuple.Tuple{col}))
if e != nil {return nil, e}
if e != nil {
return nil, e
}
slice, e := rtr.GetRange(kr, fdb.RangeOptions{0, -1, false}).GetSliceWithError()
if e != nil {return nil, e}
if e != nil {
return nil, e
}
ret := make([]interface{}, len(slice))
@ -123,7 +137,9 @@ func (tbl Table) TableGetCol(tr fdb.ReadTransactor, col int) ([]interface{}, err
return ret, nil
})
if err != nil {return nil, err}
if err != nil {
return nil, err
}
return item.([]interface{}), nil
}
@ -133,7 +149,9 @@ func main() {
db := fdb.MustOpenDefault()
TableDemoDir, err := directory.CreateOrOpen(db, []string{"Graph"}, nil)
if err != nil {log.Fatal(err)}
if err != nil {
log.Fatal(err)
}
clear_subspace(db, TableDemoDir)