$regexFind (aggregation)

Definition

  • $regexFind

New in version 4.2.

Provides regular expression (regex) pattern matching capability inaggregation expressions. If a match is found, returns a documentthat contains information on the first match. If a match is notfound, returns null.

MongoDB uses Perl compatible regular expressions (i.e. “PCRE” )version 8.41 with UTF-8 support.

Prior to MongoDB 4.2, aggregation pipeline can only use the queryoperator $regex in the $match stage. For moreinformation on using regex in a query, see $regex.

Syntax

The $regexFind operator has the following syntax:

  1. { $regexFind: { input: <expression> , regex: <expression>, options: <expression> } }

Operator Fields

FieldDescription
inputThe string on which you wish to apply the regex pattern.Can be a string or any valid expression that resolves to a string.
regexThe regex pattern to apply. Can be any valid expression that resolves to either a string or regexpattern /<pattern>/. When using the regex /<patthern>/, youcan also specify the regex options i and m (but not thes or x options):- "pattern"- /<pattern>/- /<pattern>/<options>Alternatively, you can also specify the regex options with theoptions field. To specify the s or x options, youmust use the options field.You cannot specify options in both the regex and the optionsfield.
optionsOptional. The following <options> are available for usewith regular expression.NoteYou cannot specify options in both the regex and theoptions field.
OptionDescription
iCase insensitivity to match both upper and lower cases. Youcan specify the option in the options field or as part ofthe regex field.
mFor patterns that include anchors (i.e. ^ for the start,$ for the end), match at the beginning or end of eachline for strings with multiline values. Without this option,these anchors match at beginning or end of the string.If the pattern contains no anchors or if the string value hasno newline characters (e.g. \n), the m option has noeffect.
x“Extended” capability to ignore all white space charactersin the pattern unless escaped or included in a characterclass.Additionally, it ignores characters in-between and includingan un-escaped hash/pound (#) character and the next newline, so that you may include comments in complicatedpatterns. This only applies to data characters; white spacecharacters may never appear within special charactersequences in a pattern.The x option does not affect the handling of the VTcharacter (i.e. code 11).You can specify the option only in the options field.
sAllows the dot character (i.e. .) to match allcharacters including newline characters.You can specify the option only in the options field.

Returns

If the operator does not find a match, the result of the operator is anull.

If the operator finds a match, the result of the operator is a documentthat contains:

  • the first matching string in the input,
  • the code point index(not byte index) of the matching string in the input, and
  • An array of the strings that corresponds to the groups captured bythe matching string. Capturing groups are specified with parenthesis() in the regex pattern.
  1. { "match" : <string>, "idx" : <num>, "captures" : <array of strings> }

See also

Behavior

$regexFind and Collation

$regexFind ignores the collation specified for thecollection, db.collection.aggregate(), and the index, if used.

For example, the create a sample collection with collation strength1 (i.e. compare base character only and ignore other differencessuch as case and diacritics):

  1. db.createCollection( "myColl", { collation: { locale: "fr", strength: 1 } } )

Insert the following documents:

  1. db.myColl.insertMany([
  2. { _id: 1, category: "café" },
  3. { _id: 2, category: "cafe" },
  4. { _id: 3, category: "cafE" }
  5. ])

Using the collection’s collation, the following operation performs acase-insensitive and diacritic-insensitive match:

  1. db.myColl.aggregate( [ { $match: { category: "cafe" } } ] )

The operation returns the following 3 documents:

  1. { "_id" : 1, "category" : "café" }
  2. { "_id" : 2, "category" : "cafe" }
  3. { "_id" : 3, "category" : "cafE" }

However, the aggregation expression $regexFind ignorescollation; that is, the following regular expression pattern matching examplesare case-sensitive and diacritic sensitive:

  1. db.myColl.aggregate( [ { $addFields: { resultObject: { $regexFind: { input: "$category", regex: /cafe/ } } } } ] )
  2. db.myColl.aggregate(
  3. [ { $addFields: { resultObject: { $regexFind: { input: "$category", regex: /cafe/ } } } } ],
  4. { collation: { locale: "fr", strength: 1 } } // Ignored in the $regexFind
  5. )

Both operations return the following:

  1. { "_id" : 1, "category" : "café", "resultObject" : null }
  2. { "_id" : 2, "category" : "cafe", "resultObject" : { "match" : "cafe", "idx" : 0, "captures" : [ ] } }
  3. { "_id" : 3, "category" : "cafE", "resultObject" : null }

To perform a case-insensitive regex pattern matching, use thei Option instead. Seei Option for an example.

Examples

$regexFind and Its Options

To illustrate the behavior of the $regexFind operator asdiscussed in this example, create a sample collection products withthe following documents:

  1. db.products.insertMany([
  2. { _id: 1, description: "Single LINE description." },
  3. { _id: 2, description: "First lines\nsecond line" },
  4. { _id: 3, description: "Many spaces before line" },
  5. { _id: 4, description: "Multiple\nline descriptions" },
  6. { _id: 5, description: "anchors, links and hyperlinks" },
  7. { _id: 6, description: "métier work vocation" }
  8. ])

By default, $regexFind performs a case-sensitive match.For example, the following aggregation performs a case-sensitive$regexFind on the description field. The regexpattern /line/ does not specify any grouping:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex: /line/ } } } }
  3. ])

The operation returns the following:

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : null }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : { "match" : "line", "idx" : 6, "captures" : [ ] } }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : { "match" : "line", "idx" : 23, "captures" : [ ] } }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : { "match" : "line", "idx" : 9, "captures" : [ ] } }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : null }
  6. { "_id" : 6, "description" : "métier work vocation", "returnObject" : null }

The following regex pattern /lin(e|k)/ specifies a grouping(e|k) in the pattern:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex: /lin(e|k)/ } } } }
  3. ])

The operation returns the following:

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : null }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : { "match" : "line", "idx" : 6, "captures" : [ "e" ] } }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : { "match" : "line", "idx" : 23, "captures" : [ "e" ] } }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : { "match" : "line", "idx" : 9, "captures" : [ "e" ] } }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : { "match" : "link", "idx" : 9, "captures" : [ "k" ] } }
  6. { "_id" : 6, "description" : "métier work vocation", "returnObject" : null }

In the return option, the idx field is the code point index and not the byteindex. To illustrate, consider the following example that uses theregex pattern /tier/:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex: /tier/ } } } }
  3. ])

The operation returns the following where only the last recordmatches the pattern and the returned idx is 2 (instead of 3if using a byte index)

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : null }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : null }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : null }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : null }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : null }
  6. { "_id" : 6, "description" : "métier work vocation",
  7. "returnObject" : { "match" : "tier", "idx" : 2, "captures" : [ ] } }

i Option

Note

You cannot specify options in both the regex and theoptions field.

To perform case-insensitive pattern matching, include the i option as part of the regex field orin the options field:

  1. // Specify i as part of the regex field
  2. { $regexFind: { input: "$description", regex: /line/i } }
  3.  
  4. // Specify i in the options field
  5. { $regexFind: { input: "$description", regex: /line/, options: "i" } }
  6. { $regexFind: { input: "$description", regex: "line", options: "i" } }

For example, the following aggregation performs a case-insensitive$regexFind on the description field. The regexpattern /line/ does not specify any grouping:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex: /line/i } } } }
  3. ])

The operation returns the following documents:

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : { "match" : "LINE", "idx" : 7, "captures" : [ ] } }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : { "match" : "line", "idx" : 6, "captures" : [ ] } }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : { "match" : "line", "idx" : 23, "captures" : [ ] } }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : { "match" : "line", "idx" : 9, "captures" : [ ] } }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : null }
  6. { "_id" : 6, "description" : "métier work vocation", "returnObject" : null }

m Option

Note

You cannot specify options in both the regex and theoptions field.

To match the specified anchors (e.g. ^, $) for each line of amultiline string, include the m option aspart of the regex field or in theoptions field:

  1. // Specify m as part of the regex field
  2. { $regexFind: { input: "$description", regex: /line/m } }
  3.  
  4. // Specify m in the options field
  5. { $regexFind: { input: "$description", regex: /line/, options: "m" } }
  6. { $regexFind: { input: "$description", regex: "line", options: "m" } }

The following example includes both the i and the m options tomatch lines starting with either the letter s or S formultiline strings:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex: /^s/im } } } }
  3. ])

The operation returns the following:

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : { "match" : "S", "idx" : 0, "captures" : [ ] } }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : { "match" : "s", "idx" : 12, "captures" : [ ] } }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : null }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : null }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : null }
  6. { "_id" : 6, "description" : "métier work vocation", "returnObject" : null }

x Option

Note

You cannot specify options in both the regex and theoptions field.

To ignore all unescaped white space characters and comments (denoted bythe un-escaped hash # character and the next new-line character) inthe pattern, include the s option in theoptions field:

  1. // Specify x in the options field
  2. { $regexFind: { input: "$description", regex: /line/, options: "x" } }
  3. { $regexFind: { input: "$description", regex: "line", options: "x" } }

The following example includes the x option to skip unescaped whitespaces and comments:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex: /lin(e|k) # matches line or link/, options:"x" } } } }
  3. ])

The operation returns the following:

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : null }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : { "match" : "line", "idx" : 6, "captures" : [ "e" ] } }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : { "match" : "line", "idx" : 23, "captures" : [ "e" ] } }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : { "match" : "line", "idx" : 9, "captures" : [ "e" ] } }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : { "match" : "link", "idx" : 9, "captures" : [ "k" ] } }
  6. { "_id" : 6, "description" : "métier work vocation", "returnObject" : null }

s Option

Note

You cannot specify options in both the regex and theoptions field.

To allow the dot character (i.e. .) in the pattern to match allcharacters including the new line character, include the s option in the optionsfield:

  1. // Specify s in the options field
  2. { $regexFind: { input: "$description", regex: /m.*line/, options: "s" } }
  3. { $regexFind: { input: "$description", regex: "m.*line", options: "s" } }

The following example includes the s option to allow the dotcharacter (i.e. .) to match all characters including new line as wellas the i option to perform a case-insensitive match:

  1. db.products.aggregate([
  2. { $addFields: { returnObject: { $regexFind: { input: "$description", regex:/m.*line/, options: "si" } } } }
  3. ])

The operation returns the following:

  1. { "_id" : 1, "description" : "Single LINE description.", "returnObject" : null }
  2. { "_id" : 2, "description" : "First lines\nsecond line", "returnObject" : null }
  3. { "_id" : 3, "description" : "Many spaces before line", "returnObject" : { "match" : "Many spaces before line", "idx" : 0, "captures" : [ ] } }
  4. { "_id" : 4, "description" : "Multiple\nline descriptions", "returnObject" : { "match" : "Multiple\nline", "idx" : 0, "captures" : [ ] } }
  5. { "_id" : 5, "description" : "anchors, links and hyperlinks", "returnObject" : null }
  6. { "_id" : 6, "description" : "métier work vocation", "returnObject" : null }

Use $regexFind to Parse Email from String

Create a sample collection feedback with the following documents:

  1. db.feedback.insertMany([
  2. { "_id" : 1, comment: "Hi, I'm just reading about MongoDB -- aunt.arc.tica@example.com" },
  3. { "_id" : 2, comment: "I wanted to concatenate a string" },
  4. { "_id" : 3, comment: "How do I convert a date to string? cam@mongodb.com" },
  5. { "_id" : 4, comment: "It's just me. I'm testing. fred@MongoDB.com" }
  6. ])

The following aggregation uses the $regexFind to extractthe email from the comment field (case insensitive).

  1. db.feedback.aggregate( [
  2. { $addFields: {
  3. "email": { $regexFind: { input: "$comment", regex: /[a-z0-9_.+-]+@[a-z0-9_.+-]+\.[a-z0-9_.+-]+/i } }
  4. } },
  5. { $set: { email: "$email.match"} }
  6. ] )
  • First Stage
  • The stage uses the $addFields stage to add a new fieldemail to the document. The new field contains the result ofperforming the $regexFind on the comment field:
  1. { "_id" : 1, "comment" : "Hi, I'm just reading about MongoDB -- aunt.arc.tica@example.com", "email" : { "match" : "aunt.arc.tica@example.com", "idx" : 38, "captures" : [ ] } }
  2. { "_id" : 2, "comment" : "I wanted to concatenate a string", "email" : null }
  3. { "_id" : 3, "comment" : "I can't find how to convert a date to string. cam@mongodb.com", "email" : { "match" : "cam@mongodb.com", "idx" : 46, "captures" : [ ] } }
  4. { "_id" : 4, "comment" : "It's just me. I'm testing. fred@MongoDB.com", "email" : { "match" : "fred@MongoDB.com", "idx" : 28, "captures" : [ ] } }
  • Second Stage
  • The stage use the $set stage to reset the email tothe current "$email.match" value. If the current value of emailis null, the new value of email is set to null.
  1. { "_id" : 1, "comment" : "Hi, I'm just reading about MongoDB -- aunt.arc.tica@example.com", "email" : "aunt.arc.tica@example.com" }
  2. { "_id" : 2, "comment" : "I wanted to concatenate a string" }
  3. { "_id" : 3, "comment" : "I can't find how to convert a date to string. cam@mongodb.com", "email" : "cam@mongodb.com" }
  4. { "_id" : 4, "comment" : "It's just me. I'm testing. fred@MongoDB.com", "email" : "fred@MongoDB.com" }

Apply $regexFind to String Elements of an Array

Create a sample collection contacts with the following documents:

  1. db.contacts.insertMany([
  2. { "_id" : 1, name: "Aunt Arc Tikka", details: [ "+672-19-9999", "aunt.arc.tica@example.com" ] },
  3. { "_id" : 2, name: "Belle Gium", details: [ "+32-2-111-11-11", "belle.gium@example.com" ] },
  4. { "_id" : 3, name: "Cam Bo Dia", details: [ "+855-012-000-0000", "cam.bo.dia@example.com" ] },
  5. { "_id" : 4, name: "Fred", details: [ "+1-111-222-3333" ] }
  6. ])

The following aggregation uses the $regexFind to convertthe details array into an embedded document with an email andphone fields:

  1. db.contacts.aggregate( [
  2. { $unwind: "$details" },
  3. { $addFields: {
  4. "regexemail": { $regexFind: { input: "$details", regex: /^[a-z0-9_.+-]+@[a-z0-9_.+-]+\.[a-z0-9_.+-]+$/, options: "i" } },
  5. "regexphone": { $regexFind: { input: "$details", regex: /^[+]{0,1}[0-9]*\-?[0-9_\-]+$/ } }
  6. } },
  7. { $project: { _id: 1, name: 1, details: { email: "$regexemail.match", phone: "$regexphone.match" } } },
  8. { $group: { _id: "$_id", name: { $first: "$name" }, details: { $mergeObjects: "$details"} } },
  9. { $sort: { _id: 1 } }
  10. ])
  • First Stage
  • The stage $unwinds the array into separate documents:
  1. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : "+672-19-9999" }
  2. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : "aunt.arc.tica@example.com" }
  3. { "_id" : 2, "name" : "Belle Gium", "details" : "+32-2-111-11-11" }
  4. { "_id" : 2, "name" : "Belle Gium", "details" : "belle.gium@example.com" }
  5. { "_id" : 3, "name" : "Cam Bo Dia", "details" : "+855-012-000-0000" }
  6. { "_id" : 3, "name" : "Cam Bo Dia", "details" : "cam.bo.dia@example.com" }
  7. { "_id" : 4, "name" : "Fred", "details" : "+1-111-222-3333" }
  • Second Stage
  • The stage uses the $addFields stage to add new fields tothe document that contains the result of the$regexFind for phone number and email:
  1. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : "+672-19-9999", "regexemail" : null, "regexphone" : { "match" : "+672-19-9999", "idx" : 0, "captures" : [ ] } }
  2. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : "aunt.arc.tica@example.com", "regexemail" : { "match" : "aunt.arc.tica@example.com", "idx" : 0, "captures" : [ ] }, "regexphone" : null }
  3. { "_id" : 2, "name" : "Belle Gium", "details" : "+32-2-111-11-11", "regexemail" : null, "regexphone" : { "match" : "+32-2-111-11-11", "idx" : 0, "captures" : [ ] } }
  4. { "_id" : 2, "name" : "Belle Gium", "details" : "belle.gium@example.com", "regexemail" : { "match" : "belle.gium@example.com", "idx" : 0, "captures" : [ ] }, "regexphone" : null }
  5. { "_id" : 3, "name" : "Cam Bo Dia", "details" : "+855-012-000-0000", "regexemail" : null, "regexphone" : { "match" : "+855-012-000-0000", "idx" : 0, "captures" : [ ] } }
  6. { "_id" : 3, "name" : "Cam Bo Dia", "details" : "cam.bo.dia@example.com", "regexemail" : { "match" : "cam.bo.dia@example.com", "idx" : 0, "captures" : [ ] }, "regexphone" : null }
  7. { "_id" : 4, "name" : "Fred", "details" : "+1-111-222-3333", "regexemail" : null, "regexphone" : { "match" : "+1-111-222-3333", "idx" : 0, "captures" : [ ] } }
  • Third Stage
  • The stage use the $project stage to output documents with the _id field, the name field andthe details field. The details field is set to adocument with email and phone fields, whose values are determined from theregexemail and regexphone fields, respectively.
  1. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : { "phone" : "+672-19-9999" } }
  2. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : { "email" : "aunt.arc.tica@example.com" } }
  3. { "_id" : 2, "name" : "Belle Gium", "details" : { "phone" : "+32-2-111-11-11" } }
  4. { "_id" : 2, "name" : "Belle Gium", "details" : { "email" : "belle.gium@example.com" } }
  5. { "_id" : 3, "name" : "Cam Bo Dia", "details" : { "phone" : "+855-012-000-0000" } }
  6. { "_id" : 3, "name" : "Cam Bo Dia", "details" : { "email" : "cam.bo.dia@example.com" } }
  7. { "_id" : 4, "name" : "Fred", "details" : { "phone" : "+1-111-222-3333" } }
  • Fourth Stage
  • The stage uses the $group stage to groups the input documents bytheir _id value. The stage uses the $mergeObjectsexpression to merge the details documents.
  1. { "_id" : 3, "name" : "Cam Bo Dia", "details" : { "phone" : "+855-012-000-0000", "email" : "cam.bo.dia@example.com" } }
  2. { "_id" : 4, "name" : "Fred", "details" : { "phone" : "+1-111-222-3333" } }
  3. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : { "phone" : "+672-19-9999", "email" : "aunt.arc.tica@example.com" } }
  4. { "_id" : 2, "name" : "Belle Gium", "details" : { "phone" : "+32-2-111-11-11", "email" : "belle.gium@example.com" } }
  • Fifth Stage
  • The stage uses the $sort stage to sort the documents by the _id field.
  1. { "_id" : 1, "name" : "Aunt Arc Tikka", "details" : { "phone" : "+672-19-9999", "email" : "aunt.arc.tica@example.com" } }
  2. { "_id" : 2, "name" : "Belle Gium", "details" : { "phone" : "+32-2-111-11-11", "email" : "belle.gium@example.com" } }
  3. { "_id" : 3, "name" : "Cam Bo Dia", "details" : { "phone" : "+855-012-000-0000", "email" : "cam.bo.dia@example.com" } }
  4. { "_id" : 4, "name" : "Fred", "details" : { "phone" : "+1-111-222-3333" } }

Use Captured Groupings to Parse User Name

Create a sample collection employees with the following documents:

  1. db.employees.insertMany([
  2. { "_id" : 1, name: "Aunt Arc Tikka", "email" : "aunt.tica@example.com" },
  3. { "_id" : 2, name: "Belle Gium", "email" : "belle.gium@example.com" },
  4. { "_id" : 3, name: "Cam Bo Dia", "email" : "cam.dia@example.com" },
  5. { "_id" : 4, name: "Fred" }
  6. ])

The employee email has the format<firstname>.<lastname>@example.com. Using the captured fieldreturned in the $regexFind results, you can parse outuser names for employees.

  1. db.employees.aggregate( [
  2. { $addFields: {
  3. "username": { $regexFind: { input: "$email", regex: /^([a-z0-9_.+-]+)@[a-z0-9_.+-]+\.[a-z0-9_.+-]+$/, options: "i" } },
  4. } },
  5. { $set: { username: { $arrayElemAt: [ "$username.captures", 0 ] } } }
  6. ] )
  • First Stage
  • The stage uses the $addFields stage to add a new fieldusername to the document. The new field contains the result ofperforming the $regexFind on the email field:
  1. { "_id" : 1, "name" : "Aunt Arc Tikka", "email" : "aunt.tica@example.com", "username" : { "match" : "aunt.tica@example.com", "idx" : 0, "captures" : [ "aunt.tica" ] } }
  2. { "_id" : 2, "name" : "Belle Gium", "email" : "belle.gium@example.com", "username" : { "match" : "belle.gium@example.com", "idx" : 0, "captures" : [ "belle.gium" ] } }
  3. { "_id" : 3, "name" : "Cam Bo Dia", "email" : "cam.dia@example.com", "username" : { "match" : "cam.dia@example.com", "idx" : 0, "captures" : [ "cam.dia" ] } }
  4. { "_id" : 4, "name" : "Fred", "username" : null }
  • Second Stage
  • The stage use the $set stage to reset the username tothe zero-th element of the "$username.captures" array. If the current value of usernameis null, the new value of username is set to null.
  1. { "_id" : 1, "name" : "Aunt Arc Tikka", "email" : "aunt.tica@example.com", "username" : "aunt.tica" }
  2. { "_id" : 2, "name" : "Belle Gium", "email" : "belle.gium@example.com", "username" : "belle.gium" }
  3. { "_id" : 3, "name" : "Cam Bo Dia", "email" : "cam.dia@example.com", "username" : "cam.dia" }
  4. { "_id" : 4, "name" : "Fred", "username" : null }