Переименовать поле сложного типа, расположенное в массиве

Question

Я делаю рефакторинг в производственной базе данных и мне нужно сделать несколько переименований. Версия mongodb - 1.8.0. Я использую драйвер C # для рефакторинга базы данных. Столкнулся с проблемой при попытке переименовать поле сложного типа, расположенное в массиве.

Например, у меня есть такой документ:

FoobarCollection:

{
  Field1: "",
  Field2: [
    { NestedField1: "", NestedField2: "" },
    { NestedField1: "", NestedField2: "" },
    ... 
  ]
}

Мне нужно переименовать NestedField2 в NestedField3, например. Документация MongoDB гласит:

$ * переименование 1011 *

Только версия 1.7.2+.

{$ rename: {old_field_name: new_field_name}} Переименовывает поле с именем «old_field_name» в «new_field_name». Не расширяет массивы, чтобы найти совпадение для 'old_field_name' .

Как я понимаю, простое использование Update.Rename() не дало бы результата, потому что, как сказано в документации, "переименовывать - не расширять массивы, чтобы найти соответствие старому имени поля"

Какой код C # я должен написать, чтобы переименовать NestedField2 в NestedField3?

Answer 1

Я реализовал специальный тип для переименования произвольного поля в MongoDB. Вот оно:

using System.Linq;
using MongoDB.Bson;
using MongoDB.Driver;

namespace DatabaseManagementTools
{
    public class MongoDbRefactorer
    {
        protected MongoDatabase MongoDatabase { get; set; }

        public MongoDbRefactorer(MongoDatabase mongoDatabase)
        {
            MongoDatabase = mongoDatabase;
        }

        /// <summary>
        /// Renames field
        /// </summary>
        /// <param name="collectionName"></param>
        /// <param name="oldFieldNamePath">Supports nested types, even in array. Separate nest level with '$': "FooField1$FooFieldNested$FooFieldNestedNested"</param>
        /// <param name="newFieldName">Specify only field name without path to it: "NewFieldName", but not "FooField1$NewFieldName"</param>
        public void RenameField(string collectionName, string oldFieldNamePath, string newFieldName)
        {
            MongoCollection<BsonDocument> mongoCollection = MongoDatabase.GetCollection(collectionName);
            MongoCursor<BsonDocument> collectionCursor = mongoCollection.FindAll();

            PathSegments pathSegments = new PathSegments(oldFieldNamePath);

            // Rename field in each document of collection
            foreach (BsonDocument document in collectionCursor)
            {
                int currentSegmentIndex = 0;
                RenameField(document, pathSegments, currentSegmentIndex, newFieldName);

                // Now document is modified in memory - replace old document with new in mongo:
                mongoCollection.Save(document);
            }
        }

        private void RenameField(BsonValue bsonValue, PathSegments pathSegments, int currentSegmentIndex, string newFieldName)
        {
            string currentSegmentName = pathSegments[currentSegmentIndex];

            if (bsonValue.IsBsonArray)
            {
                var array = bsonValue.AsBsonArray;
                foreach (var arrayElement in array)
                {
                    RenameField(arrayElement.AsBsonDocument, pathSegments, currentSegmentIndex, newFieldName);
                }
                return;
            }

            bool isLastNameSegment = pathSegments.Count() == currentSegmentIndex + 1;
            if (isLastNameSegment)
            {
                RenameDirect(bsonValue, currentSegmentName, newFieldName);
                return;
            }

            var innerDocument = bsonValue.AsBsonDocument[currentSegmentName];
            RenameField(innerDocument, pathSegments, currentSegmentIndex + 1, newFieldName);
        }

        private void RenameDirect(BsonValue document, string from, string to)
        {
            BsonElement bsonValue;
            bool elementFound = document.AsBsonDocument.TryGetElement(from, out bsonValue);
            if (elementFound)
            {
                document.AsBsonDocument.Add(to, bsonValue.Value);
                document.AsBsonDocument.Remove(from);
            }
            else
            {
                // todo: log missing elements
            }
        }
    }
}

И вспомогательный тип для хранения сегментов пути:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace DatabaseManagementTools
{
    public class PathSegments : IEnumerable<string>
    {
        private List<string> Segments { get; set; }

        /// <summary>
        /// Split segment levels with '$'. For example: "School$CustomCodes"
        /// </summary>
        /// <param name="pathToParse"></param>
        public PathSegments(string pathToParse)
        {
            Segments = ParseSegments(pathToParse);
        }

        private static List<string> ParseSegments(string oldFieldNamePath)
        {
            string[] pathSegments = oldFieldNamePath.Trim(new []{'$', ' '})
                .Split(new [] {'$'}, StringSplitOptions.RemoveEmptyEntries);

            return pathSegments.ToList();
        }

        public IEnumerator<string> GetEnumerator()
        {
            return Segments.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public string this[int index]
        {
            get { return Segments[index]; }
        }
    }
}

Для разделения уровней вложения я использую знак '$' - единственный знак, который запрещен для имен коллекций в монго. Использование может быть примерно таким:

MongoDbRefactorer mongoDbRefactorer = new MongoDbRefactorer(Mongo.Database);
mongoDbRefactorer.RenameField("schools", "FoobarTypesCustom$FoobarDefaultName", "FoobarName");

Этот код найдет в коллекции schools FoobarTypesCustom свойство. Это может быть как сложный тип, так и массив. Затем найдет все свойства FoobarDefaultName (если FoobarTypesCustom - массив, он будет проходить через него) и переименует его в FoobarName. Уровни вложенности и количество вложенных массивов не имеет значения.