FerretDB · noisersup · Jan 13, 2023 · Jan 4, 2023 · Jan 4, 2023 · Jan 5, 2023
@@ -185,6 +185,7 @@ tasks:
     cmds:
       - >
         go test -count=1 {{.RACEFLAG}} -tags={{.BUILDTAGS}} -shuffle=on -coverpkg=../...
+        -timeout=15m
         -coverprofile=integration-tigris.txt .
         -handler=tigris
         -records-dir=../records

@@ -357,6 +357,7 @@ func tigrisSchema(typeString string) string {
 				"primary_key": ["_id"],
 				"properties": {
 					"v": {%%type%%},
+					"boo": {%%type%%},
 					"_id": {"type": "string"}
 				}
 			}`

@@ -481,6 +481,80 @@ func TestUpdateFieldCompatMin(t *testing.T) {
 	testUpdateCompat(t, testCases)
 }
 
+func TestUpdateFieldCompatRename(t *testing.T) {
+	testCases := map[string]updateCompatTestCase{
+		"Simple": {
+			update: bson.D{{"$rename", bson.D{{"v", "foo"}}}},
+		},
+		"DuplicateField": {
+			update:     bson.D{{"$rename", bson.D{{"v", "v"}}}},
+			resultType: emptyResult,
+		},
+		"NonExistingField": {
+			update:     bson.D{{"$rename", bson.D{{"foo", "bar"}}}},
+			resultType: emptyResult,
+		},
+		"EmptyField": {
+			update:     bson.D{{"$rename", bson.D{{"", "v"}}}},
+			resultType: emptyResult,
+		},
+		"EmptyDest": {
+			update:     bson.D{{"$rename", bson.D{{"v", ""}}}},
+			resultType: emptyResult,
+		},
+		"DotDocumentMove": {
+			update:        bson.D{{"$rename", bson.D{{"v.foo", "boo"}}}},
+			skipForTigris: "https://github.com/FerretDB/FerretDB/issues/1776",
+		},
+		"DotDocumentDuplicate": {
+			update:        bson.D{{"$rename", bson.D{{"v.foo", "v.array"}}}},
+			skipForTigris: "https://github.com/FerretDB/FerretDB/issues/1776",
+		},
+		"DotDocumentNonExisting": {
+			update:     bson.D{{"$rename", bson.D{{"foo.bar", ""}}}},
+			resultType: emptyResult,
+		},
+		"DotArrayField": {
+			update:     bson.D{{"$rename", bson.D{{"v.array.0", ""}}}},
+			resultType: emptyResult,
+		},
+		"DotArrayNonExisting": {
+			update:     bson.D{{"$rename", bson.D{{"foo.0.baz", int32(1)}}}},
+			resultType: emptyResult,
+		},
+		"Multiple": {
+			update:        bson.D{{"$rename", bson.D{{"v.foo", "v.bar"}, {"v.42", "v.43"}}}},
+			skipForTigris: "https://github.com/FerretDB/FerretDB/issues/1776",
+		},
+		"MultipleConflictDestSource": {
+			update:     bson.D{{"$rename", bson.D{{"v", "foo"}, {"foo", "bar"}}}},
+			resultType: emptyResult,
+		},
+		"MultipleConflictDestFields": {
+			update:     bson.D{{"$rename", bson.D{{"v", "foo"}, {"v", "bar"}}}},
+			resultType: emptyResult,
+		},
+		"MultipleSecondInvalid": {
+			update:     bson.D{{"$rename", bson.D{{"v.foo", "boo"}, {"v.array", 1}}}},
+			resultType: emptyResult,
+		},
+		"FieldEmpty": {
+			update:     bson.D{{"$rename", bson.D{}}},
+			resultType: emptyResult,
+		},
+		"InvalidString": {
+			update:     bson.D{{"$rename", "string"}},
+			resultType: emptyResult,
+		},
+		"InvalidDoc": {
+			update:     bson.D{{"$rename", primitive.D{}}},
+			resultType: emptyResult,
+		},
+	}
+
+	testUpdateCompat(t, testCases)
+}
+
 func TestUpdateFieldCompatUnset(t *testing.T) {
 	t.Parallel()
 

@@ -58,6 +58,9 @@ const (
 	// ErrInvalidID indicates that _id field is invalid.
 	ErrInvalidID = ErrorCode(53) // InvalidID
 
+	// ErrEmptyName indicates that the field name is empty.
+	ErrEmptyName = ErrorCode(56) // EmptyName
+
 	// ErrCommandNotFound indicates unknown command input.
 	ErrCommandNotFound = ErrorCode(59) // CommandNotFound
 

@@ -15,6 +15,7 @@
 package common
 
 import (
+	"errors"
 	"fmt"
 	"math"
 	"sort"
@@ -24,6 +25,7 @@ import (
 	"golang.org/x/exp/slices"
 
 	"github.com/FerretDB/FerretDB/internal/types"
+	"github.com/FerretDB/FerretDB/internal/util/iterator"
 	"github.com/FerretDB/FerretDB/internal/util/must"
 )
 
@@ -103,6 +105,12 @@ func UpdateDocument(doc, update *types.Document) (bool, error) {
 				return false, err
 			}
 
+		case "$rename":
+			changed, err = processRenameFieldExpression(doc, updateV.(*types.Document))
+			if err != nil {
+				return false, err
+			}
+
 		default:
 			if strings.HasPrefix(updateOp, "$") {
 				return false, NewCommandError(ErrNotImplemented, fmt.Errorf("UpdateDocument: unhandled operation %q", updateOp))
@@ -236,6 +244,63 @@ func processPopFieldExpression(doc *types.Document, update *types.Document) (boo
 	return changed, nil
 }
 
+// processRenameFieldExpression changes document according to $rename operator.
+// If the document was changed it returns true.
+func processRenameFieldExpression(doc *types.Document, update *types.Document) (bool, error) {
+	renameExpression := update.SortFieldsByKey()
+
+	var changed bool
+
+	for _, key := range renameExpression.Keys() {
+		renameRawValue := must.NotFail(renameExpression.Get(key))
+
+		if key == "" || renameRawValue == "" {
+			return changed, NewWriteErrorMsg(ErrEmptyName, "An empty update path is not valid.")
+		}
+
+		// this is covered in validateRenameExpression
+		renameValue := renameRawValue.(string)
+
+		if key == renameRawValue {
+			return changed, NewWriteErrorMsg(
+				ErrBadValue,
+				fmt.Sprintf("The source and target field for $rename must differ: %s: %#v", key, renameValue),
+			)
+		}
+
+		sourcePath := types.NewPathFromString(key)
+		targetPath := types.NewPathFromString(renameValue)
+
+		// Get value to move
+		val, err := doc.GetByPath(sourcePath)
+		if err != nil {
+			var dpe *types.DocumentPathError
+			if !errors.As(err, &dpe) {
+				panic("getByPath returned error with invalid type")
+			}
+
+			if dpe.Code() == types.ErrDocumentPathKeyNotFound {
+				continue
+			}
+
+			return changed, NewWriteErrorMsg(ErrUnsuitableValueType, dpe.Error())
+		}
+
+		// Remove old document
+		doc.RemoveByPath(sourcePath)
+
+		// Set new path with old value
+		err = doc.SetByPath(targetPath, val)
+		if err != nil {
+			return changed, err
+		}
+
+		changed = true
+	}
+
+	return changed, nil
+}
+
 // processIncFieldExpression changes document according to $inc operator.
 // If the document was changed it returns true.
 func processIncFieldExpression(doc *types.Document, updateV any) (bool, error) {
@@ -522,13 +587,23 @@ func ValidateUpdateOperators(update *types.Document) error {
 		return err
 	}
 
+	_, err = extractValueFromUpdateOperator("$rename", update)
+	if err != nil {
+		return err
+	}
+
 	if err = checkConflictingChanges(set, inc); err != nil {
 		return err
 	}
 
 	if err = validateCurrentDateExpression(update); err != nil {
 		return err
 	}
+
+	if err = validateRenameExpression(update); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -552,8 +627,10 @@ func HasSupportedUpdateModifiers(update *types.Document) (bool, error) {
 		case "$unset":
 			fallthrough
 		case "$pop":
+			fallthrough
+		case "$rename":
 			updateModifier = true
-		case "$mul", "$rename":
+		case "$mul":
 			return false, NewCommandErrorMsgWithArgument(
 				ErrNotImplemented,
 				fmt.Sprintf("update operator %s is not implemented", updateOp),
@@ -611,6 +688,8 @@ func checkConflictingChanges(a, b *types.Document) error {
 // The result returned for "$setOnInsert" operator is
 //
 //	bson.D{{"v", nil}}.
+//
+// It also checks for path collisions and returns the error if there's any.
 func extractValueFromUpdateOperator(op string, update *types.Document) (*types.Document, error) {
 	if !update.Has(op) {
 		return nil, nil
@@ -635,6 +714,71 @@ func extractValueFromUpdateOperator(op string, update *types.Document) (*types.D
 	return doc, nil
 }
 
+// validateRenameExpression validates $rename input on correctness.
+func validateRenameExpression(update *types.Document) error {
+	if !update.Has("$rename") {
+		return nil
+	}
+
+	updateExpression := must.NotFail(update.Get("$rename"))
+
+	doc, ok := updateExpression.(*types.Document)
+	if !ok {
+		return NewWriteErrorMsg(ErrFailedToParse, "Modifiers operate on fields but we found another type instead")
+	}
+
+	iter := doc.Iterator()
+	keys := map[string]struct{}{}
+
+	for {
+		k, v, err := iter.Next()
+		if err != nil {
+			if errors.Is(err, iterator.ErrIteratorDone) {
+				break
+			}
+
+			return err
+		}
+
+		var vStr string
+
+		vStr, ok = v.(string)
+		if !ok {
+			return NewWriteErrorMsg(
+				ErrBadValue,
+				fmt.Sprintf("The 'to' field for $rename must be a string: %s: %v", k, vStr),
+			)
+		}
+
+		if k == vStr {
+			return NewWriteErrorMsg(
+				ErrBadValue,
+				fmt.Sprintf("The source and target field for $rename must differ: %s: %v", k, vStr),
+			)
+		}
+
+		if _, ok = keys[k]; ok {
+			return NewWriteErrorMsg(
+				ErrConflictingUpdateOperators,
+				fmt.Sprintf("Updating the '%s' would create a conflict at '%s'", k, k),
+			)
+		}
+
+		keys[k] = struct{}{}
+
+		if _, ok = keys[vStr]; ok {
+			return NewWriteErrorMsg(
+				ErrConflictingUpdateOperators,
+				fmt.Sprintf("Updating the '%s' would create a conflict at '%s'", vStr, vStr),
+			)
+		}
+
+		keys[vStr] = struct{}{}
+	}
+
+	return nil
+}
+
 // validateCurrentDateExpression validates $currentDate input on correctness.
 func validateCurrentDateExpression(update *types.Document) error {
 	currentDateTopField, err := update.Get("$currentDate")