[query] Update Graphite find calls to complete unterminated queries with all possible path values for **

scripts/docker-integration-tests/carbon/expected/a_dot_starstar_dot_star.json

@@ -0,0 +1,23 @@
+[
+  {
+    "id": "a.**.daz",
+    "text": "daz",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a.**.cake",
+    "text": "cake",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a.**.caw",
+    "text": "caw",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  }
+]

scripts/docker-integration-tests/carbon/expected/a_starstar_dot_star.json

@@ -0,0 +1,44 @@
+[
+  {
+    "id": "a**.caw",
+    "text": "caw",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a**.daz",
+    "text": "daz",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a**.bag",
+    "text": "bag",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a**.bar",
+    "text": "bar",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a**.biz",
+    "text": "biz",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "a**.cake",
+    "text": "cake",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  }
+]

scripts/docker-integration-tests/carbon/expected/qux_dot_starstar_dot_star.json

@@ -0,0 +1,16 @@
+[
+  {
+    "id": "qux.**.pos2-1",
+    "text": "pos2-1",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "qux.**.pos2-0",
+    "text": "pos2-0",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  }
+]

scripts/docker-integration-tests/carbon/expected/qux_starstar_dot_star.json

@@ -0,0 +1,37 @@
+[
+  {
+    "id": "qux**.pos2-1",
+    "text": "pos2-1",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "qux**.pos1-a",
+    "text": "pos1-a",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "qux**.pos1-b",
+    "text": "pos1-b",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "qux**.pos1-c",
+    "text": "pos1-c",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  },
+  {
+    "id": "qux**.pos2-0",
+    "text": "pos2-0",
+    "leaf": 0,
+    "expandable": 1,
+    "allowChildren": 1
+  }
+]

scripts/docker-integration-tests/carbon/test.sh

@@ -136,6 +136,10 @@ ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'f.bar.*' fbaz.json"
 ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'g.bar.*' gbaz.json"
 ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'h.bar*' hbarbaz.json"
 ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'i.bar*' ibarbaz.json"
+ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'a**.*' a_starstar_dot_star.json"
+ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'a.**.*' a_dot_starstar_dot_star.json"
+ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'qux**.*' qux_starstar_dot_star.json"
+ATTEMPTS=2 TIMEOUT=1 retry_with_backoff "find_carbon 'qux.**.*' qux_dot_starstar_dot_star.json"
 
 # Test find limits from config of matching max docs of 200 with:
 # carbon:

src/query/api/v1/handler/graphite/find.go

@@ -73,31 +73,45 @@ func mergeTags(
 	terminatedResult *consolidators.CompleteTagsResult,
 	childResult *consolidators.CompleteTagsResult,
 ) (map[string]nodeDescriptor, error) {
-	// sanity check the case.
-	if terminatedResult.CompleteNameOnly {
-		return nil, errors.New("terminated result is completing name only")
-	}
+	var (
+		terminatedResultTags = 0
+		childResultTags      = 0
+	)
 
-	if childResult.CompleteNameOnly {
-		return nil, errors.New("child result is completing name only")
+	// Sanity check the queries aren't complete name only queries.
+	if terminatedResult != nil {
+		terminatedResultTags = len(terminatedResult.CompletedTags)
+		if terminatedResult.CompleteNameOnly {
+			return nil, errors.New("terminated result is completing name only")
+		}
 	}
 
-	mapLength := len(terminatedResult.CompletedTags) + len(childResult.CompletedTags)
-	tagMap := make(map[string]nodeDescriptor, mapLength)
+	if childResult != nil {
+		childResultTags = len(childResult.CompletedTags)
+		if childResult.CompleteNameOnly {
+			return nil, errors.New("child result is completing name only")
+		}
+	}
 
-	for _, tag := range terminatedResult.CompletedTags {
-		for _, value := range tag.Values {
-			descriptor := tagMap[string(value)]
-			descriptor.isLeaf = true
-			tagMap[string(value)] = descriptor
+	size := terminatedResultTags + childResultTags
+	tagMap := make(map[string]nodeDescriptor, size)
+	if terminatedResult != nil {
+		for _, tag := range terminatedResult.CompletedTags {
+			for _, value := range tag.Values {
+				descriptor := tagMap[string(value)]
+				descriptor.isLeaf = true
+				tagMap[string(value)] = descriptor
+			}
 		}
 	}
 
-	for _, tag := range childResult.CompletedTags {
-		for _, value := range tag.Values {
-			descriptor := tagMap[string(value)]
-			descriptor.hasChildren = true
-			tagMap[string(value)] = descriptor
+	if childResult != nil {
+		for _, tag := range childResult.CompletedTags {
+			for _, value := range tag.Values {
+				descriptor := tagMap[string(value)]
+				descriptor.hasChildren = true
+				tagMap[string(value)] = descriptor
+			}
 		}
 	}
 
@@ -120,7 +134,7 @@ func (h *grahiteFindHandler) ServeHTTP(
 	// NB: need to run two separate queries, one of which will match only the
 	// provided matchers, and one which will match the provided matchers with at
 	// least one more child node. For further information, refer to the comment
-	// for parseFindParamsToQueries
+	// for parseFindParamsToQueries.
 	terminatedQuery, childQuery, raw, err := parseFindParamsToQueries(r)
 	if err != nil {
 		xhttp.WriteError(w, err)
@@ -134,11 +148,17 @@ func (h *grahiteFindHandler) ServeHTTP(
 		cErr             error
 		wg               sync.WaitGroup
 	)
-	wg.Add(2)
-	go func() {
-		terminatedResult, tErr = h.storage.CompleteTags(ctx, terminatedQuery, opts)
-		wg.Done()
-	}()
+	if terminatedQuery != nil {
+		// Sometimes we only perform the child query, so only perform
+		// terminated query if not nil.
+		wg.Add(1)
+		go func() {
+			terminatedResult, tErr = h.storage.CompleteTags(ctx, terminatedQuery, opts)
+			wg.Done()
+		}()
+	}
+	// Always perform child query.
+	wg.Add(1)
 	go func() {
 		childResult, cErr = h.storage.CompleteTags(ctx, childQuery, opts)
 		wg.Done()
@@ -152,7 +172,11 @@ func (h *grahiteFindHandler) ServeHTTP(
 		return
 	}
 
-	meta := terminatedResult.Metadata.CombineMetadata(childResult.Metadata)
+	meta := childResult.Metadata
+	if terminatedResult != nil {
+		meta = terminatedResult.Metadata.CombineMetadata(childResult.Metadata)
+	}
+
 	// NB: merge results from both queries to specify which series have children
 	seenMap, err := mergeTags(terminatedResult, childResult)
 	if err != nil {

src/query/api/v1/handler/graphite/find_parser.go

@@ -24,6 +24,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/m3db/m3/src/query/errors"
@@ -96,12 +97,46 @@ func parseFindParamsToQueries(r *http.Request) (
 			xerrors.NewInvalidParamsError(fmt.Errorf("invalid 'until': %s", untilString))
 	}
 
-	matchers, err := graphitestorage.TranslateQueryToMatchersWithTerminator(query)
+	matchers, queryType, err := graphitestorage.TranslateQueryToMatchersWithTerminator(query)
 	if err != nil {
 		return nil, nil, "",
 			xerrors.NewInvalidParamsError(fmt.Errorf("invalid 'query': %s", query))
 	}
 
+	switch queryType {
+	case graphitestorage.StarStarUnterminatedTranslatedQuery:
+		// Translated query for "**" has unterminated search for children
+		// terms, we are only going to do a single search and assume all
+		// results that come back have also children in the graphite path
+		// tree (since it's very expensive to check if each result that comes
+		// back is a child or leaf node and "**" in a find query is typically
+		// only used for template variables rather than searching for metric
+		// results, which is the only use case isLeaf/hasChildren is useful).
+		// Note: Filter to all graphite tags that appears at the last node
+		// or greater than that (we use 100 as an arbitrary upper bound).
+		maxPathIndexes := 100
+		filter := make([][]byte, 0, maxPathIndexes)
+		parts := 1 + strings.Count(query, ".")
+		firstPathIndex := parts - 1
+		for i := firstPathIndex; i < firstPathIndex+maxPathIndexes; i++ {
+			filter = append(filter, graphite.TagName(i))
+		}
+		childQuery := &storage.CompleteTagsQuery{
+			CompleteNameOnly: false,
+			FilterNameTags:   filter,
+			TagMatchers:      matchers,
+			Start:            xtime.ToUnixNano(from),
+			End:              xtime.ToUnixNano(until),
+		}
+		return nil, childQuery, query, nil
+	case graphitestorage.TerminatedTranslatedQuery:
+		// Default type of translated query, explicitly craft queries for
+		// a terminated part of the query and a child part of the query.
+		break
+	default:
+		return nil, nil, "", fmt.Errorf("unknown query type: %v", queryType)
+	}
+
 	// NB: Filter will always be the second last term in the matchers, and the
 	// matchers should always have a length of at least 2 (term + terminator)
 	// so this is a sanity check and unexpected in actual execution.