Refactor types.Path a bit

FerretDB · chilagrow · Aug 4, 2023 · Jul 20, 2023 · Jul 20, 2023 · Jul 20, 2023
commit ae4f67d067f348905eaf3f13c1149c9a82c55b36
@@ -32,7 +32,7 @@ import (
 	"github.com/FerretDB/FerretDB/internal/util/testutil/testtb"
 )
 
-//go:generate ../bin/stringer  -type compatTestCaseResultType
+//go:generate ../bin/stringer -linecomment -type compatTestCaseResultType
 
 // compatTestCaseResultType represents compatibility test case result type.
 //

@@ -23,7 +23,7 @@ import (
 	"github.com/FerretDB/FerretDB/internal/util/debugbuild"
 )
 
-//go:generate ../../bin/stringer -type ErrorCode
+//go:generate ../../bin/stringer -linecomment -type ErrorCode
 
 // ErrorCode represent a backend error code.
 type ErrorCode int

@@ -16,7 +16,6 @@ package stages
 
 import (
 	"context"
-	"errors"
 
 	"github.com/FerretDB/FerretDB/internal/handlers/common"
 	"github.com/FerretDB/FerretDB/internal/handlers/common/aggregations"
@@ -59,19 +58,10 @@ func newSort(stage *types.Document) (aggregations.Stage, error) {
 
 // Process implements Stage interface.
 //
-// If sort path is invalid, it returns a possibly wrapped types.DocumentPathError.
+// If sort path is invalid, it returns a possibly wrapped types.PathError.
 func (s *sort) Process(ctx context.Context, iter types.DocumentsIterator, closer *iterator.MultiCloser) (types.DocumentsIterator, error) { //nolint:lll // for readability
-	var err error
-	if iter, err = common.SortIterator(iter, closer, s.fields); err != nil {
-		var pathErr *types.DocumentPathError
-		if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
-			return nil, commonerrors.NewCommandErrorMsgWithArgument(
-				commonerrors.ErrPathContainsEmptyElement,
-				"FieldPath field names may not be empty strings.",
-				"$sort (stage)",
-			)
-		}
-
+	iter, err := common.SortIterator(iter, closer, s.fields)
+	if err != nil {
 		return nil, lazyerrors.Error(err)
 	}
 

@@ -85,10 +85,10 @@ func newUnset(stage *types.Document) (aggregations.Stage, error) {
 			}
 
 			err = types.IsConflictPath(visitedPaths, *path)
-			var pathErr *types.DocumentPathError
+			var pathErr *types.PathError
 
 			if errors.As(err, &pathErr) {
-				if pathErr.Code() == types.ErrDocumentPathConflictOverwrite {
+				if pathErr.Code() == types.ErrPathConflictOverwrite {
 					// the path overwrites one of visitedPaths.
 					return nil, commonerrors.NewCommandErrorMsgWithArgument(
 						commonerrors.ErrUnsetPathOverwrite,
@@ -97,7 +97,7 @@ func newUnset(stage *types.Document) (aggregations.Stage, error) {
 					)
 				}
 
-				if pathErr.Code() == types.ErrDocumentPathConflictCollision {
+				if pathErr.Code() == types.ErrPathConflictCollision {
 					// the path creates collision at one of visitedPaths.
 					return nil, commonerrors.NewCommandErrorMsgWithArgument(
 						commonerrors.ErrUnsetPathCollision,

@@ -29,7 +29,7 @@ import (
 
 // SortDocuments sorts given documents in place according to the given sorting conditions.
 //
-// If sort path is invalid, it returns a possibly wrapped types.DocumentPathError.
+// If sort path is invalid, it returns a possibly wrapped types.PathError.
 func SortDocuments(docs []*types.Document, sortDoc *types.Document) error {
 	if sortDoc.Len() == 0 {
 		return nil

@@ -260,8 +260,8 @@ func processRenameFieldExpression(command string, doc *types.Document, update *t
 
 		sourcePath, err := types.NewPathFromString(key)
 		if err != nil {
-			var pathErr *types.DocumentPathError
-			if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
+			var pathErr *types.PathError
+			if errors.As(err, &pathErr) && pathErr.Code() == types.ErrPathElementEmpty {
 				return false, newUpdateError(
 					commonerrors.ErrEmptyName,
 					fmt.Sprintf(
@@ -281,16 +281,16 @@ func processRenameFieldExpression(command string, doc *types.Document, update *t
 		// Get value to move
 		val, err := doc.GetByPath(sourcePath)
 		if err != nil {
-			var dpe *types.DocumentPathError
+			var dpe *types.PathError
 			if !errors.As(err, &dpe) {
 				panic("getByPath returned error with invalid type")
 			}
 
-			if dpe.Code() == types.ErrDocumentPathKeyNotFound || dpe.Code() == types.ErrDocumentPathIndexOutOfBound {
+			if dpe.Code() == types.ErrPathKeyNotFound || dpe.Code() == types.ErrPathIndexOutOfBound {
 				continue
 			}
 
-			if dpe.Code() == types.ErrDocumentPathArrayInvalidIndex {
+			if dpe.Code() == types.ErrPathIndexInvalid {
 				return false, newUpdateError(
 					commonerrors.ErrUnsuitableValueType,
 					fmt.Sprintf("cannot use path '%s' to traverse the document", sourcePath),
@@ -918,11 +918,11 @@ func validateOperatorKeys(command string, docs ...*types.Document) error {
 			}
 
 			err = types.IsConflictPath(visitedPaths, nextPath)
-			var pathErr *types.DocumentPathError
+			var pathErr *types.PathError
 
 			if errors.As(err, &pathErr) {
-				if pathErr.Code() == types.ErrDocumentPathConflictOverwrite ||
-					pathErr.Code() == types.ErrDocumentPathConflictCollision {
+				if pathErr.Code() == types.ErrPathConflictOverwrite ||
+					pathErr.Code() == types.ErrPathConflictCollision {
 					return newUpdateError(
 						commonerrors.ErrConflictingUpdateOperators,
 						fmt.Sprintf(

@@ -108,8 +108,8 @@ func (h *Handler) MsgFind(ctx context.Context, msg *wire.OpMsg) (*wire.OpMsg, er
 		if !queryRes.SortPushdown {
 			iter, err = common.SortIterator(iter, closer, params.Sort)
 			if err != nil {
-				var pathErr *types.DocumentPathError
-				if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
+				var pathErr *types.PathError
+				if errors.As(err, &pathErr) && pathErr.Code() == types.ErrPathElementEmpty {
 					return commonerrors.NewCommandErrorMsgWithArgument(
 						commonerrors.ErrPathContainsEmptyElement,
 						"Empty field names in path are not allowed",

@@ -79,8 +79,8 @@ func (h *Handler) MsgFindAndModify(ctx context.Context, msg *wire.OpMsg) (*wire.
 		}
 
 		if err = common.SortDocuments(resDocs, params.Sort); err != nil {
-			var pathErr *types.DocumentPathError
-			if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
+			var pathErr *types.PathError
+			if errors.As(err, &pathErr) && pathErr.Code() == types.ErrPathElementEmpty {
 				return commonerrors.NewCommandErrorMsgWithArgument(
 					commonerrors.ErrPathContainsEmptyElement,
 					"FieldPath field names may not be empty strings.",

@@ -254,7 +254,7 @@ func prepareWhereClause(p *Placeholder, sqlFilters *types.Document) (string, []a
 
 		path, err := types.NewPathFromString(rootKey)
 
-		var pe *types.DocumentPathError
+		var pe *types.PathError
 
 		switch {
 		case err == nil:
@@ -264,11 +264,11 @@ func prepareWhereClause(p *Placeholder, sqlFilters *types.Document) (string, []a
 			}
 		case errors.As(err, &pe):
 			// ignore empty key error, otherwise return error
-			if pe.Code() != types.ErrDocumentPathEmptyKey {
+			if pe.Code() != types.ErrPathElementEmpty {
 				return "", nil, lazyerrors.Error(err)
 			}
 		default:
-			panic("Invalid error type: DocumentPathError expected ")
+			panic("Invalid error type: PathError expected")
 		}
 
 		switch v := rootVal.(type) {

@@ -71,8 +71,8 @@ func (h *Handler) MsgFind(ctx context.Context, msg *wire.OpMsg) (*wire.OpMsg, er
 	if err != nil {
 		closer.Close()
 
-		var pathErr *types.DocumentPathError
-		if errors.As(err, &pathErr) && pathErr.Code() == types.ErrDocumentPathEmptyKey {
+		var pathErr *types.PathError
+		if errors.As(err, &pathErr) && pathErr.Code() == types.ErrPathElementEmpty {
 			return nil, commonerrors.NewCommandErrorMsgWithArgument(
 				commonerrors.ErrPathContainsEmptyElement,
 				"Empty field names in path are not allowed",

@@ -0,0 +1,109 @@
+// Copyright 2021 FerretDB Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+)
+
+// FormatAnyValue formats value for error message output.
+func FormatAnyValue(v any) string {
+	switch v := v.(type) {
+	case *Document:
+		return formatDocument(v)
+	case *Array:
+		return formatArray(v)
+	case float64:
+		switch {
+		case math.IsNaN(v):
+			return "nan.0"
+
+		case math.IsInf(v, -1):
+			return "-inf.0"
+		case math.IsInf(v, +1):
+			return "inf.0"
+		case v == 0 && math.Signbit(v):
+			return "-0.0"
+		case v == 0.0:
+			return "0.0"
+		case v > 1000 || v < -1000 || v == math.SmallestNonzeroFloat64:
+			return fmt.Sprintf("%.15e", v)
+		case math.Trunc(v) == v:
+			return fmt.Sprintf("%d.0", int64(v))
+		default:
+			res := fmt.Sprintf("%.2f", v)
+
+			return strings.TrimSuffix(res, "0")
+		}
+
+	case string:
+		return fmt.Sprintf(`"%v"`, v)
+	case Binary:
+		return fmt.Sprintf("BinData(%d, %X)", v.Subtype, v.B)
+	case ObjectID:
+		return fmt.Sprintf("ObjectId('%x')", v)
+	case bool:
+		return fmt.Sprintf("%v", v)
+	case time.Time:
+		return fmt.Sprintf("new Date(%d)", v.UnixMilli())
+	case NullType:
+		return "null"
+	case Regex:
+		return fmt.Sprintf("/%s/%s", v.Pattern, v.Options)
+	case int32:
+		return fmt.Sprintf("%d", v)
+	case Timestamp:
+		return fmt.Sprintf("Timestamp(%v, %v)", int64(v)>>32, int32(v))
+	case int64:
+		return fmt.Sprintf("%d", v)
+	default:
+		panic(fmt.Sprintf("unknown type %T", v))
+	}
+}
+
+// formatDocument formats Document for error output.
+func formatDocument(doc *Document) string {
+	result := "{ "
+
+	for i, f := range doc.fields {
+		if i > 0 {
+			result += ", "
+		}
+
+		result += fmt.Sprintf("%s: %s", f.key, FormatAnyValue(f.value))
+	}
+
+	return result + " }"
+}
+
+// formatArray formats Array for error output.
+func formatArray(array *Array) string {
+	if len(array.s) == 0 {
+		return "[]"
+	}
+
+	result := "[ "
+
+	for _, elem := range array.s {
+		result += fmt.Sprintf("%s, ", FormatAnyValue(elem))
+	}
+
+	result = strings.TrimSuffix(result, ", ")
+
+	return result + " ]"
+}