How to Split Strings into Arrays in MongoDB Using $split

You can use the following general syntax to split a string into an array of substrings in MongoDB:

db.myCollection.aggregate([
  { $project: { split_field: { $split: [ "$field1", " " ] } } },
  { $merge: "myCollection" }
])

This particular example first defines a projection to create a new field named “split_field.” This field uses the $split operator to process the contents of the existing field “$field1,” utilizing a single space (” “) as the delimiter. Finally, the $merge stage updates the original collection titled myCollection by adding the newly computed “split_field” to each document.

Setting Up the Sample Data Collection

To provide a concrete illustration of the $split operator in action, we will work with a sample dataset representing sports teams. This collection, named teams, will contain documents where the team name is stored as a single, multi-word string. Our objective is to split this name into an array of individual words (e.g., city, team nickname) for easier searching and indexing.

The dataset initialization involves inserting several documents into the teams collection. Each document includes a name field, which is the target for our string manipulation, and a points field, demonstrating additional data typically found in a collection.

The following commands set up our working environment. Notice how the name strings inherently use spaces as the natural delimiter, making them ideal candidates for splitting.

The following example shows how to set up the collection teams with initial documents:

db.teams.insertOne({name: "Dallas Mavs", points: 31})
db.teams.insertOne({name: "San Antonio Spurs", points: 22})
db.teams.insertOne({name: "Houston Rockets", points: 19})
db.teams.insertOne({name: "Boston Celtics", points: 26})
db.teams.insertOne({name: "Cleveland Cavs", points: 33})

Practical Implementation: Splitting the Team Names

With the sample data established, we can now construct the aggregation pipeline necessary to execute the string splitting. Our pipeline will consist of two crucial stages: $project (or $addFields) to perform the calculation, and $merge to persist the results back into the collection.

We target the $name field and specify the delimiter as a space (” “). The output will be directed into a new field we name split_name. This approach is highly efficient because all processing occurs server-side, minimizing data transfer overhead.

The decision to use $project allows us to explicitly define the resulting document structure. If we only wanted to add the new field without affecting the visibility of other fields, $addFields would be a suitable alternative. However, for clarity and control over the output, $project is often preferred in initial tests.

We use the following code to split the string in the “name” field into an array of substrings and display the results in a new field titled “split_name” in the teams collection:

db.teams.aggregate([
  { $project: { split_name: { $split: [ "$name", " " ] } } },
  { $merge: "teams" }
])

Analyzing the Aggregation Output

After running the aggregation pipeline, the teams collection is immediately updated. The $merge stage ensures that the new calculated field, split_name, is added to every document in the collection. Examining the updated documents confirms that the string-to-array transformation was executed successfully based on the space delimiter.

The resulting documents clearly show how the original name string has been accurately decomposed. For example, “San Antonio Spurs” is correctly translated into the three-element array ['San', 'Antonio', 'Spurs']. This new array structure makes subsequent querying operations much more flexible and powerful, especially when combined with operators like $unwind or $in.

It is important to note that the $project stage used here overwrites the original document structure, keeping only the _id field implicitly, along with any fields explicitly included or calculated. However, based on the original output provided, we assume the initial fields were preserved in the final merged document, which is typically achieved by including existing fields in the projection or by using $addFields instead.

Here’s what the updated collection now looks like after the $merge operation:

{ _id: ObjectId("62014a924cb04b772fd7a938"),
  name: 'Dallas Mavs',
  points: 31,
  split_name: [ 'Dallas', 'Mavs' ] }
{ _id: ObjectId("62014a924cb04b772fd7a939"),
  name: 'San Antonio Spurs',
  points: 22,
  split_name: [ 'San', 'Antonio', 'Spurs' ] }
{ _id: ObjectId("62014a924cb04b772fd7a93a"),
  name: 'Houston Rockets',
  points: 19,
  split_name: [ 'Houston', 'Rockets' ] }
{ _id: ObjectId("62014a924cb04b772fd7a93b"),
  name: 'Boston Celtics',
  points: 26,
  split_name: [ 'Boston', 'Celtics' ] }
{ _id: ObjectId("62014a924cb04b772fd7a93c"),
  name: 'Cleveland Cavs',
  points: 33,
  split_name: [ 'Cleveland', 'Cavs' ] } 

Notice that every document has a new field titled “split_name” that contains an array of substrings derived from the “name” field. This structure significantly enhances the document’s utility for complex data retrieval tasks.

The Critical Role of the Delimiter

The success of the $split operation hinges entirely on the accurate identification and specification of the delimiter. The delimiter is the character or sequence of characters that separates the logical units within the string. In our previous example, we chose an empty space (” “) because it was the natural separator between words in the team names.

It is crucial to correctly identify the delimiter used in your dataset. If the string happens to be separated by a different character—such as a dash, a slash, a comma, or a colon—then that specific sequence must be used in the second argument of the $split function. Failing to use the exact delimiter will result in the string not being split, or being split incorrectly if the delimiter is a substring that appears in unexpected places.

For example, if you have a field containing tags separated by commas (e.g., “tech,devops,cloud”), the delimiter must be a comma (“,”). If you have a date string formatted as “YYYY-MM-DD”, the delimiter should be the hyphen (“-“). The flexibility to define any arbitrary string as the delimiter allows $split to handle a vast range of structured string formats.

For this particular example, we chose to separate the original string using an empty space as a delimiter. If the string happens to be separated by a different delimiter (like a dash, slash, colon, etc.), then simply specify that exact delimiter within the $split function instead.

Advantages of Server-Side String Manipulation

While string splitting can easily be performed on the client side using languages like Python, Node.js, or Java, executing this operation directly within MongoDB via the Aggregation Pipeline offers significant performance and architectural benefits.

By performing the split operation using $split, we reduce network latency and data transfer. Instead of fetching large documents, iterating over them in application memory, modifying the strings, and then potentially writing them back to the database, the entire process is handled efficiently by the database server. This is especially vital when dealing with high-volume, real-time data processing, where minimizing overhead is paramount.

Furthermore, integrating transformations into the aggregation framework means that the results can be immediately chained into subsequent pipeline stages, such as $unwind (to de-normalize the array), $group (to count occurrences of the substrings), or $match (to filter based on new array elements). This ability to chain operations creates a powerful and expressive environment for complex ETL (Extract, Transform, Load) tasks.

Further Resources for MongoDB String Operators

The $split operator is just one tool in the rich toolkit of string manipulation operators available within the MongoDB Aggregation Pipeline. Developers frequently pair $split with other string operators to clean and prepare data before splitting occurs.

For instance, you might use $toUpper or $toLower to ensure case consistency before splitting, or $trim to remove leading/trailing whitespace which could otherwise affect the resulting substrings if the delimiter is a space. Mastering these operators allows for highly precise and robust data preparation within the database layer.

For detailed information and advanced usage examples, consulting the official documentation is highly recommended. The official reference provides comprehensive explanations of edge cases, performance considerations, and compatibility notes for all aggregation operators.

Note: You can find the complete documentation for the $split function here.

The following tutorials explain how to perform other common operations in MongoDB:

• Performing advanced string concatenation using $concat.
• Searching within strings using $indexOfBytes or $indexOfCP.
• Extracting portions of strings using $substrCP.