func typeValueFromNQuad(nq *graph.NQuad) (types.Value, error) {
if nq.Value == nil || nq.Value.Val == nil {
return nil, nil
}
switch v := nq.Value.Val.(type) {
case *graph.Value_BytesVal:
b := types.Bytes(v.BytesVal)
return &b, nil
case *graph.Value_IntVal:
i := types.Int32(v.IntVal)
return &i, nil
case *graph.Value_StrVal:
s := types.String(v.StrVal)
return &s, nil
case *graph.Value_BoolVal:
b := types.Bool(v.BoolVal)
return &b, nil
case *graph.Value_DoubleVal:
f := types.Float(v.DoubleVal)
return &f, nil
case *graph.Value_GeoVal:
var geom types.Geo
err := geom.UnmarshalBinary(v.GeoVal)
if err != nil {
return nil, err
}
return &geom, nil
case nil:
log.Fatalf("Val being nil is already handled")
return nil, nil
default:
// Unknown type
return nil, x.Errorf("Unknown value type %T", v)
}
}
func populateGraph(t *testing.T) (string, string, *store.Store) {
// logrus.SetLevel(logrus.DebugLevel)
dir, err := ioutil.TempDir("", "storetest_")
require.NoError(t, err)
ps, err := store.NewStore(dir)
require.NoError(t, err)
schema.ParseBytes([]byte(schemaStr))
posting.Init(ps)
worker.Init(ps)
group.ParseGroupConfig("")
dir2, err := ioutil.TempDir("", "wal_")
require.NoError(t, err)
worker.StartRaftNodes(dir2)
// So, user we're interested in has uid: 1.
// She has 5 friends: 23, 24, 25, 31, and 101
addEdgeToUID(t, ps, "friend", 1, 23)
addEdgeToUID(t, ps, "friend", 1, 24)
addEdgeToUID(t, ps, "friend", 1, 25)
addEdgeToUID(t, ps, "friend", 1, 31)
addEdgeToUID(t, ps, "friend", 1, 101)
// Now let's add a few properties for the main user.
addEdgeToValue(t, ps, "name", 1, "Michonne")
addEdgeToValue(t, ps, "gender", 1, "female")
var coord types.Geo
err = coord.UnmarshalText([]byte("{\"Type\":\"Point\", \"Coordinates\":[1.1,2.0]}"))
require.NoError(t, err)
gData, err := coord.MarshalBinary()
require.NoError(t, err)
addEdgeToTypedValue(t, ps, "loc", 1, types.GeoID, gData)
data, err := types.Int32(15).MarshalBinary()
require.NoError(t, err)
addEdgeToTypedValue(t, ps, "age", 1, types.Int32ID, data)
addEdgeToValue(t, ps, "address", 1, "31, 32 street, Jupiter")
data, err = types.Bool(true).MarshalBinary()
require.NoError(t, err)
addEdgeToTypedValue(t, ps, "alive", 1, types.BoolID, data)
addEdgeToValue(t, ps, "age", 1, "38")
addEdgeToValue(t, ps, "survival_rate", 1, "98.99")
addEdgeToValue(t, ps, "sword_present", 1, "true")
addEdgeToValue(t, ps, "_xid_", 1, "mich")
// Now let's add a name for each of the friends, except 101.
addEdgeToTypedValue(t, ps, "name", 23, types.StringID, []byte("Rick Grimes"))
addEdgeToValue(t, ps, "age", 23, "15")
err = coord.UnmarshalText([]byte(`{"Type":"Polygon", "Coordinates":[[[0.0,0.0], [2.0,0.0], [2.0, 2.0], [0.0, 2.0]]]}`))
require.NoError(t, err)
gData, err = coord.MarshalBinary()
require.NoError(t, err)
addEdgeToTypedValue(t, ps, "loc", 23, types.GeoID, gData)
addEdgeToValue(t, ps, "address", 23, "21, mark street, Mars")
addEdgeToValue(t, ps, "name", 24, "Glenn Rhee")
addEdgeToValue(t, ps, "name", 25, "Daryl Dixon")
addEdgeToValue(t, ps, "name", 31, "Andrea")
addEdgeToValue(t, ps, "dob", 23, "1910-01-02")
addEdgeToValue(t, ps, "dob", 24, "1909-05-05")
addEdgeToValue(t, ps, "dob", 25, "1909-01-10")
addEdgeToValue(t, ps, "dob", 31, "1901-01-15")
return dir, dir2, ps
}
// This method gets the values and children for a subgraph.
func (sg *SubGraph) preTraverse(uid uint64, dst outputNode) error {
invalidUids := make(map[uint64]bool)
// We go through all predicate children of the subgraph.
for _, pc := range sg.Children {
idx := algo.IndexOf(pc.SrcUIDs, uid)
if idx < 0 {
continue
}
ul := pc.uidMatrix[idx]
fieldName := pc.Attr
if pc.Params.Alias != "" {
fieldName = pc.Params.Alias
}
if sg.Params.GetUID || sg.Params.isDebug {
dst.SetUID(uid)
}
if len(pc.counts) > 0 {
c := types.Int32(pc.counts[idx])
uc := dst.New(fieldName)
uc.AddValue("_count_", &c)
dst.AddChild(fieldName, uc)
} else if len(ul.Uids) > 0 || len(pc.Children) > 0 {
// We create as many predicate entity children as the length of uids for
// this predicate.
for _, childUID := range ul.Uids {
if invalidUids[childUID] {
continue
}
uc := dst.New(fieldName)
// Doing check for UID here is no good because some of these might be
// invalid nodes.
// if pc.Params.GetUID || pc.Params.isDebug {
// dst.SetUID(uid)
// }
if rerr := pc.preTraverse(childUID, uc); rerr != nil {
if rerr.Error() == "_INV_" {
invalidUids[childUID] = true
continue // next UID.
}
// Some other error.
log.Printf("Error while traversal: %v", rerr)
return rerr
}
if !uc.IsEmpty() {
dst.AddChild(fieldName, uc)
}
}
} else {
tv := pc.values[idx]
v, err := getValue(tv)
if err != nil {
return err
}
if pc.Attr == "_xid_" {
txt, err := v.MarshalText()
if err != nil {
return err
}
dst.SetXID(string(txt))
} else {
globalType := schema.TypeOf(pc.Attr)
schemaType := pc.Params.AttrType
sv := v
if schemaType != nil {
// Do type checking on response values
if !schemaType.IsScalar() {
return x.Errorf("Unknown Scalar:%v. Leaf predicate:'%v' must be"+
" one of the scalar types defined in the schema.", pc.Params.AttrType, pc.Attr)
}
st := schemaType.(types.Scalar)
// Convert to schema type.
sv, err = st.Convert(v)
if bytes.Equal(tv.Val, nil) || err != nil {
// skip values that don't convert.
return x.Errorf("_INV_")
}
} else if globalType != nil {
// Try to coerce types if this is an optional scalar outside an
// object definition.
if !globalType.IsScalar() {
return x.Errorf("Leaf predicate:'%v' must be a scalar.", pc.Attr)
}
gt := globalType.(types.Scalar)
// Convert to schema type.
sv, err = gt.Convert(v)
if bytes.Equal(tv.Val, nil) || err != nil {
continue
}
}
if bytes.Equal(tv.Val, nil) {
continue
}
dst.AddValue(fieldName, sv)
}
}
}
return nil
}