Support @normalize directive for subqueries

gql/parser.go

@@ -2239,6 +2239,8 @@ func parseDirective(it *lex.ItemIterator, curp *GraphQuery) error {
 		}
 	} else if item.Val == "cascade" {
 		curp.Cascade = true
+	} else if item.Val == "normalize" {
+		curp.Normalize = true
 	} else if peek[0].Typ == itemLeftRound {
 		// this is directive
 		switch item.Val {

query/common_test.go

@@ -270,6 +270,10 @@ state                          : [uid] .
 county                         : [uid] .
 firstName                      : string .
 lastName                       : string .
+newname                        : string @index(exact, term) .
+newage                         : int .
+boss                           : uid .
+newfriend                      : [uid] .
 `
 
 func populateCluster() {
@@ -566,6 +570,45 @@ func populateCluster() {
 		_:har <lastName> "Ford" .
 		_:ss <firstName> "Steven" .
 		_:ss <lastName> "Spielberg" .
+
+		<501> <newname> "P1" .
+		<502> <newname> "P2" .
+		<503> <newname> "P3" .
+		<504> <newname> "P4" .
+		<505> <newname> "P5" .
+		<506> <newname> "P6" .
+		<507> <newname> "P7" .
+		<508> <newname> "P8" .
+		<509> <newname> "P9" .
+		<510> <newname> "P10" .
+		<511> <newname> "P11" .
+		<512> <newname> "P12" .
+
+		<501> <newage> "21" .
+		<502> <newage> "22" .
+		<503> <newage> "23" .
+		<504> <newage> "24" .
+		<505> <newage> "25" .
+		<506> <newage> "26" .
+		<507> <newage> "27" .
+		<508> <newage> "28" .
+		<509> <newage> "29" .
+		<510> <newage> "30" .
+		<511> <newage> "31" .
+		<512> <newage> "32" .
+
+		<501> <newfriend> <502> .
+		<501> <newfriend> <503> .
+		<501> <boss> <504> .
+		<502> <newfriend> <505> .
+		<502> <newfriend> <506> .
+		<503> <newfriend> <507> .
+		<503> <newfriend> <508> .
+		<504> <newfriend> <509> .
+		<504> <newfriend> <510> .
+		<502> <boss> <510> .
+		<510> <newfriend> <511> .
+		<510> <newfriend> <512> .
 	`)
 
 	addGeoPointToCluster(1, "loc", []float64{1.1, 2.0})

query/outputnode.go

@@ -295,10 +295,19 @@ func merge(parent [][]*fastJsonNode, child [][]*fastJsonNode) ([][]*fastJsonNode
 	return mergedList, nil
 }
 
+// normalize returns all attributes of fj and its children (if any).
 func (fj *fastJsonNode) normalize() ([][]*fastJsonNode, error) {
 	cnt := 0
 	for _, a := range fj.attrs {
-		if a.isChild {
+		// Here we are counting all non-scalar attributes of fj. If there are any such
+		// attributes, we will flatten it, otherwise we will return all attributes.
+
+		// When we call addMapChild it tries to find whether there is already an attribute
+		// with attr field same as attribute argument of addMapChild. If it doesn't find any
+		// such attribute, it creates an attribute with isChild = false. In those cases
+		// sometimes cnt remains zero  and normalize returns attributes without flattening.
+		// So we are using len(a.attrs) > 0 instead of a.isChild
+		if len(a.attrs) > 0 {
 			cnt++
 		}
 	}
@@ -314,25 +323,23 @@ func (fj *fastJsonNode) normalize() ([][]*fastJsonNode, error) {
 	// merged with children later.
 	attrs := make([]*fastJsonNode, 0, len(fj.attrs)-cnt)
 	for _, a := range fj.attrs {
-		if !a.isChild {
+		// Check comment at previous occurrence of len(a.attrs) > 0
+		if len(a.attrs) == 0 {
 			attrs = append(attrs, a)
 		}
 	}
 	parentSlice = append(parentSlice, attrs)
 
 	for ci := 0; ci < len(fj.attrs); {
 		childNode := fj.attrs[ci]
-		if !childNode.isChild {
+		// Check comment at previous occurrence of len(a.attrs) > 0
+		if len(childNode.attrs) == 0 {
 			ci++
 			continue
 		}
 		childSlice := make([][]*fastJsonNode, 0, 5)
 		for ci < len(fj.attrs) && childNode.attr == fj.attrs[ci].attr {
-			normalized, err := fj.attrs[ci].normalize()
-			if err != nil {
-				return nil, err
-			}
-			childSlice = append(childSlice, normalized...)
+			childSlice = append(childSlice, fj.attrs[ci].attrs)
 			ci++
 		}
 		// Merging with parent.
@@ -670,6 +677,7 @@ func (sg *SubGraph) preTraverse(uid uint64, dst outputNode) error {
 			if sg.Params.IgnoreReflex {
 				pc.Params.ParentIds = sg.Params.ParentIds
 			}
+
 			// We create as many predicate entity children as the length of uids for
 			// this predicate.
 			ul := pc.uidMatrix[idx]
@@ -708,13 +716,56 @@ func (sg *SubGraph) preTraverse(uid uint64, dst outputNode) error {
 					if sg.Params.GetUid {
 						uc.SetUID(childUID, "uid")
 					}
+					if pc.Params.Normalize {
+						// We will normalize at each level instead of
+						// calling normalize after pretraverse.
+						// Now normalize() only flattens one level,
+						// the expectation is that its children have
+						// already been normalized.
+						normAttrs, err := uc.(*fastJsonNode).normalize()
+						if err != nil {
+							return err
+						}
+
+						for _, c := range normAttrs {
+							// Adding as list child irrespective of the type of pc
+							// (list or non-list), otherwise result might be inconsistent or might
+							// depend on children and grandchildren of pc. Consider the case:
+							// 	boss: uid .
+							// 	friend: [uid] .
+							// 	name: string .
+							// For query like:
+							// {
+							// 	me(func: uid(0x1)) {
+							// 		boss @normalize {
+							// 			name
+							// 		}
+							// 	}
+							// }
+							// boss will be non list type in response, but for query like:
+							// {
+							// 	me(func: uid(0x1)) {
+							// 		boss @normalize {
+							// 			friend {
+							// 				name
+							// 			}
+							// 		}
+							// 	}
+							// }
+							// boss should be of list type because there can be mutliple friends of
+							// boss.
+							dst.AddListChild(fieldName, &fastJsonNode{attrs: c})
+						}
+						continue
+					}
 					if pc.List {
 						dst.AddListChild(fieldName, uc)
 					} else {
 						dst.AddMapChild(fieldName, uc, false)
 					}
 				}
 			}
+
 			if pc.Params.UidCount && !(pc.Params.UidCountAlias == "" && pc.Params.Normalize) {
 				uc := dst.New(fieldName)
 				c := types.ValueForType(types.IntID)

query/outputnode_test.go

@@ -94,68 +94,3 @@ func TestNormalizeJSONLimit(t *testing.T) {
 	_, err := n.(*fastJsonNode).normalize()
 	require.Error(t, err, "Couldn't evaluate @normalize directive - too many results")
 }
-
-func TestNormalizeJSONUid1(t *testing.T) {
-	// Set default normalize limit.
-	x.Config.NormalizeNodeLimit = 1e4
-
-	n := (&fastJsonNode{}).New("root")
-	require.NotNil(t, n)
-	child1 := n.New("child1")
-	child1.SetUID(uint64(1), "uid")
-	child1.AddValue("attr1", types.ValueForType(types.StringID))
-	n.AddListChild("child1", child1)
-
-	child2 := n.New("child2")
-	child2.SetUID(uint64(2), "uid")
-	child2.AddValue("attr2", types.ValueForType(types.StringID))
-	child1.AddListChild("child2", child2)
-
-	child3 := n.New("child3")
-	child3.SetUID(uint64(3), "uid")
-	child3.AddValue("attr3", types.ValueForType(types.StringID))
-	child2.AddListChild("child3", child3)
-
-	normalized, err := n.(*fastJsonNode).normalize()
-	require.NoError(t, err)
-	require.NotNil(t, normalized)
-	nn := (&fastJsonNode{}).New("root")
-	for _, c := range normalized {
-		nn.AddListChild("alias", &fastJsonNode{attrs: c})
-	}
-
-	var b bytes.Buffer
-	nn.(*fastJsonNode).encode(&b)
-	require.JSONEq(t, `{"alias":[{"uid":"0x3","attr1":"","attr2":"","attr3":""}]}`, b.String())
-}
-
-func TestNormalizeJSONUid2(t *testing.T) {
-	n := (&fastJsonNode{}).New("root")
-	require.NotNil(t, n)
-	child1 := n.New("child1")
-	child1.SetUID(uint64(1), "uid")
-	child1.AddValue("___attr1", types.ValueForType(types.StringID))
-	n.AddListChild("child1", child1)
-
-	child2 := n.New("child2")
-	child2.SetUID(uint64(2), "uid")
-	child2.AddValue("___attr2", types.ValueForType(types.StringID))
-	child1.AddListChild("child2", child2)
-
-	child3 := n.New("child3")
-	child3.SetUID(uint64(3), "uid")
-	child3.AddValue(fmt.Sprintf("attr3"), types.ValueForType(types.StringID))
-	child2.AddListChild("child3", child3)
-
-	normalized, err := n.(*fastJsonNode).normalize()
-	require.NoError(t, err)
-	require.NotNil(t, normalized)
-	nn := (&fastJsonNode{}).New("root")
-	for _, c := range normalized {
-		nn.AddListChild("alias", &fastJsonNode{attrs: c})
-	}
-
-	var b bytes.Buffer
-	nn.(*fastJsonNode).encode(&b)
-	require.JSONEq(t, `{"alias":[{"___attr1":"","___attr2":"","uid":"0x3","attr3":""}]}`, b.String())
-}

query/query.go

@@ -526,7 +526,7 @@ func treeCopy(gq *gql.GraphQuery, sg *SubGraph) error {
 			IgnoreReflex:   sg.Params.IgnoreReflex,
 			Langs:          gchild.Langs,
 			NeedsVar:       append(gchild.NeedsVar[:0:0], gchild.NeedsVar...),
-			Normalize:      sg.Params.Normalize,
+			Normalize:      gchild.Normalize || sg.Params.Normalize,
 			Order:          gchild.Order,
 			Var:            gchild.Var,
 			GroupbyAttrs:   gchild.GroupbyAttrs,