Function parseJSONGoStd

pkg/util/json/json.go:999–1030

parseJSONGoStd parses json using encoding/json library. TODO(yevgeniy): Remove this code once we get more confidence in lexer implementation.

(s string, _ parseConfig)

// parseJSONGoStd parses json using encoding/json library.
// TODO(yevgeniy): Remove this code once we get more confidence in lexer implementation.
func parseJSONGoStd(s string, _ parseConfig) (JSON, error) {
	// This goes in two phases - first it parses the string into raw interface{}s
	// using the Go encoding/json package, then it transforms that into a JSON.
	// This could be faster if we wrote a parser to go directly into the JSON.
	// Note: a better way to unmarshal a single JSON value would be to use
	// json.Unmarshal; however, we cannot do that because we want to get numbers
	// as strings; Alas, json.Unmarshal does not support that, and so, we have
	// to use json.Decoder.
	var result interface{}
	decoder := json.NewDecoder(strings.NewReader(s))
	// We want arbitrary size/precision decimals, so we call UseNumber() to tell
	// the decoder to decode numbers into strings instead of float64s (which we
	// later parse using apd).
	decoder.UseNumber()
	err := decoder.Decode(&result)
	if err != nil {
		return nil, jsonDecodeError(err)
	}

	// Check to see if input has more data.
	// Note: using decoder.More() is wrong since it allows `]` and '}'
	// characters (i.e. '{}]this is BAD' will be parsed fine, and More will return
	// false -- thus allowing invalid JSON data to be parsed correctly). The
	// decoder is meant to be used in the streaming applications; not in a one-off
	// Unmarshal mode we are using here.  Therefore, to check if input has
	// trailing characters, we have to attempt to decode the next value.
	var more interface{}
	if err := decoder.Decode(&more); err != io.EOF {
		return nil, errTrailingCharacters
	}
	return MakeJSON(result)
}

func jsonDecodeError(err error) error {
	return pgerror.Wrapf(