CSHARP-5655: Support regular expressions in $replaceAll search string and $split delimiter by sanych-sun · Pull Request #1955 · mongodb/mongo-csharp-driver

sanych-sun · 2026-04-15T22:24:52Z

No description provided.

… and $split delimiter

Copilot

Pull request overview

Adds LINQ3 translation support for using regular expressions as the $replaceAll.find argument and as the $split delimiter, along with accompanying serializer deduction and test coverage.

Changes:

Implemented $replaceAll translation for string.Replace(...) and Regex.Replace(...) (including regex literals and regex values stored as BSON regular expressions).
Extended $split translation to support regex delimiters via Regex.Split(...) and regex instance .Split(...) when stored as BSON regular expressions, plus additional string.Split overload handling.
Added/updated unit + integration tests and updated expression preprocessing in test helpers.

Reviewed changes

Copilot reviewed 18 out of 18 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
tests/MongoDB.Driver.Tests/Linq/TestHelpers.cs	Preprocesses test expressions using `LinqExpressionPreprocessor` before serializer finding/translation.
tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Translators/…/SplitMethodToAggregationExpressionTranslatorTests.cs	New unit tests for `$split` translation across many `string.Split` overloads and regex delimiters.
tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Translators/…/ReplaceMethodToAggregationExpressionTranslatorTests.cs	New unit tests for `$replaceAll` translation including regex-based replace.
tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/SerializerFinders/StringTests.cs	Expands serializer-finder coverage for `Replace`/`Split` and adds unsupported-case assertions.
tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/SerializerFinders/RegexTests.cs	Expands serializer-finder coverage for regex `Replace`/`Split` and adds unsupported-case assertions.
tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp5928Tests.cs	Updates a non-translatable-expression regression to use unsupported `Regex.Replace` overload and asserts message content.
tests/MongoDB.Driver.Tests/Linq/Integration/StringSplitTests.cs	New integration tests validating `$split` output for supported `string.Split` shapes.
tests/MongoDB.Driver.Tests/Linq/Integration/StringReplaceTests.cs	New integration tests validating `$replaceAll` for `string.Replace` (feature-gated).
tests/MongoDB.Driver.Tests/Linq/Integration/RegexSplitTests.cs	New integration tests validating regex delimiter support in `$split` (feature-gated).
tests/MongoDB.Driver.Tests/Linq/Integration/RegexReplaceTests.cs	New integration tests validating regex find support in `$replaceAll` (feature-gated).
src/MongoDB.Driver/Linq/Linq3Implementation/Translators/…/SplitMethodToAggregationExpressionTranslator.cs	Adds regex delimiter support and extends handling of additional `string.Split` overloads.
src/MongoDB.Driver/Linq/Linq3Implementation/Translators/…/ReplaceMethodToAggregationExpressionTranslator.cs	New translator implementing `$replaceAll` for string/regex replace operations.
src/MongoDB.Driver/Linq/Linq3Implementation/Translators/…/MethodCallExpressionToAggregationExpressionTranslator.cs	Routes method calls named `Replace` to the new replace translator.
src/MongoDB.Driver/Linq/Linq3Implementation/SerializerFinders/SerializerFinderVisitMethodCall.cs	Deduces serializers for `Replace` and extends `Split` deduction to regex splits.
src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/StringMethod.cs	Adds `Replace` reflection metadata and expands split overload sets (char + string separator overloads).
src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/RegexMethod.cs	Adds `Replace`/`Split` reflection metadata and overload sets for serializer finding/translation.
src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstExpression.cs	Adds `AstExpression.ReplaceAll(...)` factory method.
src/MongoDB.Driver/Core/Misc/Feature.cs	Fixes lookup feature typos and introduces `ReplaceAll`, `ReplaceAllWithRegex`, and `SplitWithRegex` feature flags.

Comments suppressed due to low confidence (1)

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/SplitMethodToAggregationExpressionTranslator.cs:73

For the string separator overloads, a null or empty separator has special meaning in .NET (and MongoDB $split also rejects empty delimiters). Currently separatorString/separatorStrings[0] are used without validating null/empty, which can generate an invalid $split delimiter or change semantics. Please add explicit validation (e.g., reject null/empty with ExpressionNotSupportedException, or implement equivalent semantics if intended).

                else if (method.IsOneOf(StringMethod.SplitWithStringOverloads))
                {
                    var separatorsExpression = arguments[0];
                    var separatorString = separatorsExpression.GetConstantValue<string>(containingExpression: expression);
                    delimiter = separatorString;
                }
                else if (method.IsOneOf(StringMethod.SplitWithStringsOverloads))
                {
                    var separatorsExpression = arguments[0];
                    var separatorStrings = separatorsExpression.GetConstantValue<string[]>(containingExpression: expression);
                    if (separatorStrings.Length != 1)
                    {
                        goto notSupported;
                    }
                    delimiter = separatorStrings[0];
                }

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-15T23:04:16Z

+            if (method.Is(StringMethod.ReplaceWithString))
+            {
+                inputAst = ExpressionToAggregationExpressionTranslator.Translate(context, expression.Object).Ast;
+                findAst = ExpressionToAggregationExpressionTranslator.Translate(context, arguments[0]).Ast;
+                replacementAst = ExpressionToAggregationExpressionTranslator.Translate(context, arguments[1]).Ast;
+            }


For string.Replace(string oldValue, string newValue), .NET treats newValue == null as string.Empty. Translating a null replacement via ExpressionToAggregationExpressionTranslator will emit BSON null, which diverges from .NET semantics and is likely invalid for $replaceAll. Consider normalizing a constant null replacement to "" (or explicitly rejecting null with a clear ExpressionNotSupportedException).

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

adelinowona · 2026-04-17T00:10:51Z

+            TestHelpers.MakeLambda<MyModel, string[]>(model => model.StringField.Split(__singleCharsSeparator, 3, StringSplitOptions.RemoveEmptyEntries)),
+            "{ $slice: [{ $filter : { input : { $split : [{ $getField : { field : 'StringField', input : '$$ROOT' } }, ','] }, as : 'item', cond : { $ne : ['$$item', ''] } } }, 3]}"
+        ],
+        // TODO: Missed cases when StringSplitOptions.TrimEntries. Currently, it is silently ignored. Need jira ticket for that.


Was a ticket filed for this? Also why not do it in the current PR? Because currently I don't think we want to ship this code without TrimEntries or at least something that rejects unknown flag combinations

I'll file a ticket for this. String.Split translation is exiting functionality, so I don't want to introduce the changes just in this PR, because it theoretically can break someone's code.

Created: https://jira.mongodb.org/browse/CSHARP-5986

adelinowona · 2026-04-17T00:47:09Z

Compare to the pre-existing IsMatchMethodToAggregationExpressionTranslator.cs:35-39:

if (inputTranslation.Serializer is IRepresentationConfigurable representationConfigurable && representationConfigurable.Representation != BsonType.String) { throw new ExpressionNotSupportedException(inputExpression, expression, because: "input expression is not represented as a string"); }

The new Replace and Split translators never perform this check. For a field like [BsonRepresentation(BsonType.Int32)] string Code, a user calling d.Code.Replace("1", "2") gets a cryptic server-side error at query time instead of a clear translation-time error naming the representation mismatch.

Should the new code apply the same guard?

Good point, will do. BTW, I think we inconsistently checking for the representation in translators. We might want to add this as a best practice for all translators.

adelinowona · 2026-04-17T00:53:43Z

+                    var findTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, expression.Object);
+                    if (SerializationHelper.GetRepresentation(findTranslation.Serializer) != BsonType.RegularExpression)
+                    {
+                        throw new ExpressionNotSupportedException(expression);


This could benefit from an actionable error message. Maybe add a because context? something like "regex instance not represented as regex"

adelinowona · 2026-04-17T00:57:38Z

+                    var delimiterTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, expression.Object);
+                    if (SerializationHelper.GetRepresentation(delimiterTranslation.Serializer) != BsonType.RegularExpression)
+                    {
+                        goto notSupported;


I know goto notSupported flows to the generic ExpressionNotSupportedException but maybe some of this exceptions could benefit from a because context for a more actionable error.

adelinowona · 2026-04-17T01:11:43Z

        public static AstExpression RegexMatch(AstExpression input, string pattern, string options)
            => new AstRegexExpression(AstRegexOperator.Match, input, pattern, options);

+        public static AstExpression ReplaceAll(AstExpression input, AstExpression find, AstExpression replace)


I would rename replace to replacement for consistency since AstReplaceAllExpression uses that.

adelinowona · 2026-04-17T01:30:38Z

+                {
+                    var options = arguments.Count == 4 ? arguments[3].GetConstantValue<RegexOptions>(expression) : RegexOptions.None;
+                    var pattern = arguments[1].GetConstantValue<string>(expression);
+                    findAst = new BsonRegularExpression(new Regex(pattern, options));


Why are we creating a regex here? There is an existing BsonRegularExpression(string pattern, string options) overload.

Because options is enum here, not a string as BsonRegularExpression ctor wants.

sanych-sun · 2026-04-18T00:53:56Z

+                    // validate if replacement string uses substitutions: $1, ${1}, ${name}, etc
+                    // more details on https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference#substitutions
+                    var matches = Regex.Matches(replacement, @"(?<escaped>\$\$)|\$(?<substitutions>\d+|\{[^}]+\}|&|`|'|\+|_)");
+                    for (var i = 0; i < matches.Count; i++)


Cannot use foreach or LINQ here, because in net472 MatchesCollection does not implement IEnumerable.

CSHARP-5655: Support regular expressions in $replaceAll search string…

2f5d55a

… and $split delimiter

sanych-sun requested a review from a team as a code owner April 15, 2026 22:24

sanych-sun requested review from ajcvickers and Copilot and removed request for Copilot April 15, 2026 22:24

sanych-sun added the feature Adds new user-facing functionality. label Apr 15, 2026

Fix outdated test

9888303

Copilot AI review requested due to automatic review settings April 15, 2026 22:57

Copilot started reviewing on behalf of sanych-sun April 15, 2026 22:57 View session

Copilot AI reviewed Apr 15, 2026

View reviewed changes

sanych-sun requested a review from adelinowona April 16, 2026 00:20

Apply suggestions from code review

875eb47

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

adelinowona requested changes Apr 17, 2026

View reviewed changes

pr

769d55b

sanych-sun requested a review from adelinowona April 17, 2026 18:41

sanych-sun added 3 commits April 17, 2026 13:57

pr

ae47ced

pr

7cd0d50

More escaping for regex replacement

533e991

sanych-sun commented Apr 18, 2026

View reviewed changes

sanych-sun added 2 commits April 17, 2026 18:00

simplification

cf57999

ff

444d9d6

Conversation

sanych-sun commented Apr 15, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sanych-sun Apr 17, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

sanych-sun Apr 17, 2026 •

edited

Loading