feat: Add ability to explain sortNode attribute(s). (sourcenetwork#558

)

- Relevant issue(s):
  Resolves sourcenetwork#481.
  Fixes sourcenetwork#584 ([2] case).

- Description
Adds the attributes for `sortNode` to be included in the returned explain graph response.
So far, we are only introducing 1 attribute, which represents a list containing all the `orderings` of each field requested to be sorted, with its corresponding direction.

- Request:
```
query @Explain {
  author(order: {age: ASC}) {
    name
    age
    verified
  }
}
```

- Response:
```
{
  "explain": {
    "selectTopNode": {
      "sortNode": {
        "selectNode": {
          "filter": null,
          "scanNode": {
            "filter":         null,
            "collectionID":   "3",
            "collectionName": "author",
            "spans": []{
              {
                "start": "/3",
                "end":   "/4",
              }
            }
          }
        }
        "orderings": []{
          {
            "direction": "ASC",
            "fields":     [ "age" ],
          }
        }
      }
    }
  }
}
```

core/doc.go

@@ -222,3 +222,27 @@ func (m *DocumentMapping) SetChildAt(index int, childMapping DocumentMapping) {
 	newMappings[index] = childMapping
 	m.ChildMappings = newMappings
 }
+
+// TryToFindNameFromIndex returns the corresponding name of the given index.
+//
+// Additionally, will also return true if the index was found, and false otherwise.
+func (mapping *DocumentMapping) TryToFindNameFromIndex(targetIndex int) (string, bool) {
+	// Try to find the name of this index in the IndexesByName.
+	for name, indexes := range mapping.IndexesByName {
+		for _, index := range indexes {
+			if index == targetIndex {
+				return name, true
+			}
+		}
+	}
+
+	// Try to find the name of this index in the ChildMappings.
+	for _, childMapping := range mapping.ChildMappings {
+		name, found := childMapping.TryToFindNameFromIndex(targetIndex)
+		if found {
+			return name, true
+		}
+	}
+
+	return "", false
+}

query/graphql/mapper/targetable.go

@@ -106,6 +106,13 @@ type OrderCondition struct {
 	Direction SortDirection
 }
 
+func (oc OrderCondition) IsEmpty() bool {
+	if oc.Direction == "" && len(oc.FieldIndexes) == 0 {
+		return true
+	}
+	return false
+}
+
 type OrderBy struct {
 	Conditions []OrderCondition
 }

query/graphql/planner/planner.go

@@ -455,7 +455,7 @@ func (p *Planner) explainRequest(
 
 	explainGraph, err := buildExplainGraph(plan)
 	if err != nil {
-		return nil, err
+		return nil, multiErr(err, plan.Close())
 	}
 
 	topExplainGraph := []map[string]interface{}{

query/graphql/planner/sort.go

@@ -11,6 +11,8 @@
 package planner
 
 import (
+	"fmt"
+
 	"github.com/sourcenetwork/defradb/core"
 	"github.com/sourcenetwork/defradb/query/graphql/mapper"
 )
@@ -54,6 +56,7 @@ type sortNode struct {
 	// that sorts, then provides the values
 	// sorted
 	sortStrategy sortingStrategy
+
 	// indicates if our underlying sortStrategy is still
 	// consuming and sorting data.
 	needSort bool
@@ -97,7 +100,38 @@ func (n *sortNode) Value() core.Doc {
 // Explain method returns a map containing all attributes of this node that
 // are to be explained, subscribes / opts-in this node to be an explainablePlanNode.
 func (n *sortNode) Explain() (map[string]interface{}, error) {
-	return map[string]interface{}{}, nil
+	orderings := []map[string]interface{}{}
+
+	for _, element := range n.ordering {
+		// Skip all empty elements.
+		if element.IsEmpty() {
+			continue
+		}
+
+		// Build the list containing the corresponding names of all the indexes.
+		fieldNames := []string{}
+		for _, fieldIndex := range element.FieldIndexes {
+			// Try to find the name of this index.
+			fieldName, found := n.documentMapping.TryToFindNameFromIndex(fieldIndex)
+			if !found {
+				return nil, fmt.Errorf("No corresponding name was found for index=%d", fieldIndex)
+			}
+
+			fieldNames = append(fieldNames, fieldName)
+		}
+
+		// Put it all together for this order element.
+		orderings = append(orderings,
+			map[string]interface{}{
+				"fields":    fieldNames,
+				"direction": string(element.Direction),
+			},
+		)
+	}
+
+	return map[string]interface{}{
+		"orderings": orderings,
+	}, nil
 }
 
 func (n *sortNode) Next() (bool, error) {
@@ -124,9 +158,6 @@ func (n *sortNode) Next() (bool, error) {
 		if err := n.sortStrategy.Add(n.plan.Value()); err != nil {
 			return false, err
 		}
-
-		// finalize, assign valueIter = sortStrategy
-		// break
 	}
 
 	next, err := n.valueIter.Next()