Rename MongoDB Child Collection Property [duplicate] - mongodb

Question

I'm doing refactoring on production database and need to make some renamings. Version of mongodb is 1.8.0. I use C# driver to do refactoring of database. Have faced with problem when I try to rename field of complex type that is located in array.
For example I have such document:
FoobarCollection:
{
Field1: "",
Field2: [
{ NestedField1: "", NestedField2: "" },
{ NestedField1: "", NestedField2: "" },
...
]
}
I Need to rename NestedField2 into NestedField3, for example.
MongoDB documentation says:
$rename
Version 1.7.2+ only.
{ $rename : { old_field_name : new_field_name } }
Renames the field with name 'old_field_name' to 'new_field_name'. Does not expand arrays to find a match for 'old_field_name'.
As I understand, simply using Update.Rename() wouldn't give result, because as documentation says "rename - doesn't expand arrays to find a match for old field name"
What C# code I should write to rename NestedField2 into NestedField3?

Answer 1

I have implemented special type to do renaming of arbitrary field in MongoDB. Here is it:
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
}
}
}
}
And helper type to keep path segments:
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]; }
}
}
}
To separate nest levels I use '$' sign - the only sign that is forbidden for collection names in mongo.
Usage can be something like this:
MongoDbRefactorer mongoDbRefactorer = new MongoDbRefactorer(Mongo.Database);
mongoDbRefactorer.RenameField("schools", "FoobarTypesCustom$FoobarDefaultName", "FoobarName");
This code will find in collection schools FoobarTypesCustom property. It can be as complex type so array. Then will find all FoobarDefaultName properties (if FoobarTypesCustom is array then it will iterate through it) and rename it to FoobarName. Nesting levels and number of nested arrays no matters.