Improved performance of recursive descent search, and other minor improvements

Author: AsaiYusuke

jsonpath_parser.go

@@ -238,13 +238,25 @@ func (p *jsonPathParser) pushChildWildcardIdentifier() {
 }
 
 func (p *jsonPathParser) pushRecursiveChildIdentifier(node syntaxNode) {
+	var nextMapRequired, nextListRequired bool
+	switch node.(type) {
+	case *syntaxChildWildcardIdentifier, *syntaxChildMultiIdentifier, *syntaxFilterQualifier:
+		nextMapRequired = true
+		nextListRequired = true
+	case *syntaxChildSingleIdentifier:
+		nextMapRequired = true
+	case *syntaxUnionQualifier:
+		nextListRequired = true
+	}
 	p.push(&syntaxRecursiveChildIdentifier{
 		syntaxBasicNode: &syntaxBasicNode{
 			text:         `..`,
 			valueGroup:   true,
 			next:         node,
 			accessorMode: p.accessorMode,
 		},
+		nextMapRequired:  nextMapRequired,
+		nextListRequired: nextListRequired,
 	})
 }
 
@@ -269,12 +281,9 @@ func (p *jsonPathParser) pushFilterQualifier(query syntaxQuery) {
 }
 
 func (p *jsonPathParser) pushScriptQualifier(text string) {
-	p.push(&syntaxScriptQualifier{
-		syntaxBasicNode: &syntaxBasicNode{
-			valueGroup:   true,
-			accessorMode: p.accessorMode,
-		},
-		command: text,
+	panic(ErrorNotSupported{
+		feature: `script`,
+		path:    `[(` + text + `)]`,
 	})
 }
 

syntax_node_identifier_child_wildcard.go

@@ -46,7 +46,9 @@ func (i *syntaxChildWildcardIdentifier) retrieveMap(
 		keys[index] = key
 		index++
 	}
-	keys.Sort()
+	if len(keys) > 1 {
+		keys.Sort()
+	}
 	for _, key := range keys {
 		if err := i.retrieveMapNext(root, srcMap, key, result); err != nil {
 			childErrorMap[err] = struct{}{}

syntax_node_identifier_recursive_child.go

@@ -4,30 +4,44 @@ import "sort"
 
 type syntaxRecursiveChildIdentifier struct {
 	*syntaxBasicNode
+
+	nextMapRequired  bool
+	nextListRequired bool
 }
 
 func (i *syntaxRecursiveChildIdentifier) retrieve(
 	root, current interface{}, result *[]interface{}) error {
 
-	switch typedNodes := current.(type) {
-	case map[string]interface{}:
-		i.retrieveAnyValueNext(root, typedNodes, result)
-
-		index, keys := 0, make(sort.StringSlice, len(typedNodes))
-		for key := range typedNodes {
-			keys[index] = key
-			index++
-		}
-		keys.Sort()
-		for _, key := range keys {
-			i.retrieve(root, typedNodes[key], result)
-		}
-
-	case []interface{}:
-		i.retrieveAnyValueNext(root, typedNodes, result)
-
-		for _, node := range typedNodes {
-			i.retrieve(root, node, result)
+	targetNodes := make([]interface{}, 1, 5)
+	targetNodes[0] = current
+
+	keys := make(sort.StringSlice, 0, 2)
+
+	for len(targetNodes) > 0 {
+		currentNode := targetNodes[len(targetNodes)-1]
+		targetNodes = targetNodes[:len(targetNodes)-1]
+		switch typedNodes := currentNode.(type) {
+		case map[string]interface{}:
+			if i.nextMapRequired {
+				i.retrieveAnyValueNext(root, typedNodes, result)
+			}
+			keys = keys[:0]
+			for key := range typedNodes {
+				keys = append(keys, key)
+			}
+			if len(keys) > 1 {
+				keys.Sort()
+			}
+			for index := len(typedNodes) - 1; index >= 0; index-- {
+				targetNodes = append(targetNodes, typedNodes[keys[index]])
+			}
+		case []interface{}:
+			if i.nextListRequired {
+				i.retrieveAnyValueNext(root, typedNodes, result)
+			}
+			for index := len(typedNodes) - 1; index >= 0; index-- {
+				targetNodes = append(targetNodes, typedNodes[index])
+			}
 		}
 	}
 

syntax_node_qualifier_filter.go

@@ -49,7 +49,9 @@ func (f *syntaxFilterQualifier) retrieveMap(
 		keys[index] = key
 		index++
 	}
-	keys.Sort()
+	if len(keys) > 1 {
+		keys.Sort()
+	}
 	valueList := make([]interface{}, len(keys))
 	for index := range keys {
 		valueList[index] = srcMap[keys[index]]

syntax_node_qualifier_script.go

@@ -41,132 +41,6 @@ func execParserFunc(jsonPath, srcJSON string, b *testing.B) {
 	}
 }
 
-// =====================================================================
-// Retrieve
-
-func BenchmarkRetrieve_dotNotation(b *testing.B) {
-	jsonPath := `$.a`
-	srcJSON := `{"a":123.456}`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_bracketNotation(b *testing.B) {
-	jsonPath := `$['a']`
-	srcJSON := `{"a":123.456}`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_wildcard_identifier_dotNotation(b *testing.B) {
-	jsonPath := `$.*`
-	srcJSON := `{"a":123.456}`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_wildcard_identifier_bracketNotation(b *testing.B) {
-	jsonPath := `$[*]`
-	srcJSON := `{"a":123.456}`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_multi_identifier(b *testing.B) {
-	jsonPath := `$['a','a']`
-	srcJSON := `{"a":123.456}`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_qualifier_index(b *testing.B) {
-	jsonPath := `$[0]`
-	srcJSON := `[{"a":123.456}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_qualifier_slice(b *testing.B) {
-	jsonPath := `$[0:1]`
-	srcJSON := `[{"a":123.456}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_qualifier_wildcard(b *testing.B) {
-	jsonPath := `$[*]`
-	srcJSON := `[{"a":123.456}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_qualifier_union(b *testing.B) {
-	jsonPath := `$[0,0]`
-	srcJSON := `[{"a":123.456}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_logicalOR(b *testing.B) {
-	jsonPath := `$[?(@||@)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_logicalAND(b *testing.B) {
-	jsonPath := `$[?(@&&@)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_nodeFilter(b *testing.B) {
-	jsonPath := `$[?(@.a)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_logicalNOT(b *testing.B) {
-	jsonPath := `$[?(!@.a)]`
-	srcJSON := `[{"a":1},{"b":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_compareEQ(b *testing.B) {
-	jsonPath := `$[?(@.a==1)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_compareNE(b *testing.B) {
-	jsonPath := `$[?(@.a!=2)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_compareGE(b *testing.B) {
-	jsonPath := `$[?(@.a<=2)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_compareGT(b *testing.B) {
-	jsonPath := `$[?(@.a<2)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_compareLE(b *testing.B) {
-	jsonPath := `$[?(@.a>=0)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_compareLT(b *testing.B) {
-	jsonPath := `$[?(@.a>0)]`
-	srcJSON := `[{"a":1}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-func BenchmarkRetrieve_filter_regex(b *testing.B) {
-	jsonPath := `$[?(@.a =~ /ab/)]`
-	srcJSON := `[{"a":"abc"}]`
-	execRetrieve(jsonPath, srcJSON, b)
-}
-
-// =====================================================================
-// ParserFunc
-
 func BenchmarkParserFunc_dotNotation(b *testing.B) {
 	jsonPath := `$.a`
 	srcJSON := `{"a":123.456}`
@@ -286,3 +160,40 @@ func BenchmarkParserFunc_filter_regex(b *testing.B) {
 	srcJSON := `[{"a":"abc"}]`
 	execParserFunc(jsonPath, srcJSON, b)
 }
+
+func BenchmarkParserFunc_recursive(b *testing.B) {
+	jsonPath := `$..price`
+	srcJSON := `{ "store": {
+		"book": [ 
+		  { "category": "reference",
+			"author": "Nigel Rees",
+			"title": "Sayings of the Century",
+			"price": 8.95
+		  },
+		  { "category": "fiction",
+			"author": "Evelyn Waugh",
+			"title": "Sword of Honour",
+			"price": 12.99
+		  },
+		  { "category": "fiction",
+			"author": "Herman Melville",
+			"title": "Moby Dick",
+			"isbn": "0-553-21311-3",
+			"price": 8.99
+		  },
+		  { "category": "fiction",
+			"author": "J. R. R. Tolkien",
+			"title": "The Lord of the Rings",
+			"isbn": "0-395-19395-8",
+			"price": 22.99
+		  }
+		],
+		"bicycle": {
+		  "color": "red",
+		  "price": 19.95
+		}
+	  }
+	}`
+
+	execParserFunc(jsonPath, srcJSON, b)
+}