util/json: remove AllPathsWithDepth

This commit reverts a65115d.
`AllPathsWithDepth` was initially created to iterate through the
children of a json array or object, but due to performance reasons
(jsonEncoded would decode the entire object on each call), another
approach was taken to use `json.ObjectIter` and `json.FetchValIdx`, thus
eliminating the need for `AllPathsWithDepth`.

Release note: None

Author: normanchenn

pkg/util/json/encoded.go

@@ -797,12 +797,12 @@ func (j *jsonEncoded) numInvertedIndexEntries() (int, error) {
 	return decoded.numInvertedIndexEntries()
 }
 
-func (j *jsonEncoded) allPathsWithDepth(depth int) ([]JSON, error) {
+func (j *jsonEncoded) allPaths() ([]JSON, error) {
 	decoded, err := j.decode()
 	if err != nil {
 		return nil, err
 	}
-	return decoded.allPathsWithDepth(depth)
+	return decoded.allPaths()
 }
 
 // HasContainerLeaf implements the JSON interface.

pkg/util/json/json.go

@@ -138,12 +138,10 @@ type JSON interface {
 	// produced if this JSON gets included in an inverted index.
 	numInvertedIndexEntries() (int, error)
 
-	// allPathsWithDepth returns a slice of new JSON documents, each a path
-	// through the receiver. The depth parameter specifies the maximum depth of
-	// the paths to return. If the depth is negative, all paths of any depth are
-	// returned. If the depth is 0, the receiver itself is returned. Note that
-	// leaves include the empty object and array in addition to scalars.
-	allPathsWithDepth(depth int) ([]JSON, error)
+	// allPaths returns a slice of new JSON documents, each a path to a leaf
+	// through the receiver. Note that leaves include the empty object and array
+	// in addition to scalars.
+	allPaths() ([]JSON, error)
 
 	// FetchValKey implements the `->` operator for strings, returning nil if the
 	// key is not found.
@@ -1795,51 +1793,36 @@ func (j jsonObject) numInvertedIndexEntries() (int, error) {
 // through the input. Note that leaves include the empty object and array
 // in addition to scalars.
 func AllPaths(j JSON) ([]JSON, error) {
-	return j.allPathsWithDepth(-1)
+	return j.allPaths()
 }
 
-// AllPathsWithDepth returns a slice of new JSON documents, each a path
-// through the receiver. The depth parameter specifies the maximum depth of
-// the paths to return. If the depth is negative, all paths of any depth are
-// returned. If the depth is 0, the receiver itself is returned. Note that
-// leaves include the empty object and array in addition to scalars.
-func AllPathsWithDepth(j JSON, depth int) ([]JSON, error) {
-	return j.allPathsWithDepth(depth)
-}
-
-func (j jsonNull) allPathsWithDepth(depth int) ([]JSON, error) {
+func (j jsonNull) allPaths() ([]JSON, error) {
 	return []JSON{j}, nil
 }
 
-func (j jsonTrue) allPathsWithDepth(depth int) ([]JSON, error) {
+func (j jsonTrue) allPaths() ([]JSON, error) {
 	return []JSON{j}, nil
 }
 
-func (j jsonFalse) allPathsWithDepth(depth int) ([]JSON, error) {
+func (j jsonFalse) allPaths() ([]JSON, error) {
 	return []JSON{j}, nil
 }
 
-func (j jsonString) allPathsWithDepth(depth int) ([]JSON, error) {
+func (j jsonString) allPaths() ([]JSON, error) {
 	return []JSON{j}, nil
 }
 
-func (j jsonNumber) allPathsWithDepth(depth int) ([]JSON, error) {
+func (j jsonNumber) allPaths() ([]JSON, error) {
 	return []JSON{j}, nil
 }
 
-func (j jsonArray) allPathsWithDepth(depth int) ([]JSON, error) {
-	if len(j) == 0 || depth == 0 {
+func (j jsonArray) allPaths() ([]JSON, error) {
+	if len(j) == 0 {
 		return []JSON{j}, nil
 	}
 	ret := make([]JSON, 0, len(j))
 	for i := range j {
-		var paths []JSON
-		var err error
-		if depth > 0 {
-			paths, err = j[i].allPathsWithDepth(depth - 1)
-		} else {
-			paths, err = j[i].allPathsWithDepth(depth)
-		}
+		paths, err := j[i].allPaths()
 		if err != nil {
 			return nil, err
 		}
@@ -1850,19 +1833,13 @@ func (j jsonArray) allPathsWithDepth(depth int) ([]JSON, error) {
 	return ret, nil
 }
 
-func (j jsonObject) allPathsWithDepth(depth int) ([]JSON, error) {
-	if len(j) == 0 || depth == 0 {
+func (j jsonObject) allPaths() ([]JSON, error) {
+	if len(j) == 0 {
 		return []JSON{j}, nil
 	}
 	ret := make([]JSON, 0, len(j))
 	for i := range j {
-		var paths []JSON
-		var err error
-		if depth > 0 {
-			paths, err = j[i].v.allPathsWithDepth(depth - 1)
-		} else {
-			paths, err = j[i].v.allPathsWithDepth(depth)
-		}
+		paths, err := j[i].v.allPaths()
 		if err != nil {
 			return nil, err
 		}

pkg/util/json/json_test.go

@@ -2898,104 +2898,3 @@ func TestToDecimal(t *testing.T) {
 		})
 	}
 }
-
-func TestAllPaths(t *testing.T) {
-	cases := []struct {
-		json     string
-		expected []string
-	}{
-		{`{}`, []string{`{}`}},
-		{`[]`, []string{`[]`}},
-		{`[1, 2, 3]`, []string{`[1]`, `[2]`, `[3]`}},
-		{`{"foo": {"bar": [1, 2, 3]}}`, []string{`{"foo": {"bar": [1]}}`, `{"foo": {"bar": [2]}}`, `{"foo": {"bar": [3]}}`}},
-		{
-			`{"a": [1, 2, true, false], "b": {"ba": 0, "bb": null}, "c": {}}`,
-			[]string{`{"a": [1]}`, `{"a": [2]}`, `{"a": [true]}`, `{"a": [false]}`, `{"b": {"ba": 0}}`, `{"b": {"bb": null}}`, `{"c": {}}`},
-		},
-	}
-
-	for i, tc := range cases {
-		t.Run(fmt.Sprintf("all paths - %d", i), func(t *testing.T) {
-			j := parseJSON(t, tc.json)
-			paths, err := AllPaths(j)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if len(paths) != len(tc.expected) {
-				t.Fatalf("expected %d paths, got %d", len(tc.expected), len(paths))
-			}
-			for k, p := range paths {
-				cmp, err := p.Compare(parseJSON(t, tc.expected[k]))
-				if err != nil {
-					t.Fatal(err)
-				}
-				if cmp != 0 {
-					t.Fatalf("expected %s, got %s", tc.expected[k], p.String())
-				}
-			}
-		})
-	}
-}
-
-func TestAllPathsWithDepth(t *testing.T) {
-	cases := []struct {
-		json            string
-		depthToExpected map[int][]string
-	}{
-		{`{}`, map[int][]string{
-			-1: {`{}`},
-			0:  {`{}`},
-			1:  {`{}`},
-			2:  {`{}`},
-		}},
-		{`[]`, map[int][]string{
-			-1: {`[]`},
-			0:  {`[]`},
-			1:  {`[]`},
-			2:  {`[]`},
-		}},
-		{`[1, 2, 3]`, map[int][]string{
-			-1: {`[1]`, `[2]`, `[3]`},
-			0:  {`[1, 2, 3]`},
-			1:  {`[1]`, `[2]`, `[3]`},
-			2:  {`[1]`, `[2]`, `[3]`},
-		}},
-		{`{"foo": {"bar": [1, 2, 3]}}`, map[int][]string{
-			-1: {`{"foo": {"bar": [1]}}`, `{"foo": {"bar": [2]}}`, `{"foo": {"bar": [3]}}`},
-			0:  {`{"foo": {"bar": [1, 2, 3]}}`},
-			1:  {`{"foo": {"bar": [1, 2, 3]}}`},
-			2:  {`{"foo": {"bar": [1, 2, 3]}}`},
-			3:  {`{"foo": {"bar": [1]}}`, `{"foo": {"bar": [2]}}`, `{"foo": {"bar": [3]}}`},
-		}},
-		{`{"a": [1, 2, true, false], "b": {"ba": 0, "bb": null}, "c": {}}`, map[int][]string{
-			-1: {`{"a": [1]}`, `{"a": [2]}`, `{"a": [true]}`, `{"a": [false]}`, `{"b": {"ba": 0}}`, `{"b": {"bb": null}}`, `{"c": {}}`},
-			0:  {`{"a": [1, 2, true, false], "b": {"ba": 0, "bb": null}, "c": {}}`},
-			1:  {`{"a": [1, 2, true, false]}`, `{"b": {"ba": 0, "bb": null}}`, `{"c": {}}`},
-			2:  {`{"a": [1]}`, `{"a": [2]}`, `{"a": [true]}`, `{"a": [false]}`, `{"b": {"ba": 0}}`, `{"b": {"bb": null}}`, `{"c": {}}`},
-		}},
-	}
-
-	for i, tc := range cases {
-		t.Run(fmt.Sprintf("all paths with depth - %d", i), func(t *testing.T) {
-			j := parseJSON(t, tc.json)
-			for depth, expected := range tc.depthToExpected {
-				paths, err := AllPathsWithDepth(j, depth)
-				if err != nil {
-					t.Fatal(err)
-				}
-				if len(paths) != len(expected) {
-					t.Fatalf("expected %d paths, got %d", len(expected), len(paths))
-				}
-				for k, p := range paths {
-					cmp, err := p.Compare(parseJSON(t, expected[k]))
-					if err != nil {
-						t.Fatal(err)
-					}
-					if cmp != 0 {
-						t.Fatalf("expected %s, got %s", expected[k], p.String())
-					}
-				}
-			}
-		})
-	}
-}