Skip to content

Latest commit

 

History

History
649 lines (490 loc) · 12.1 KB

array_update.md

File metadata and controls

649 lines (490 loc) · 12.1 KB

In MongoDB, updating array elements involves using a variety of update operators depending on what you want to do — such as adding, removing, or modifying elements. Below is a complete guide with example code snippets for different array update operations using MongoDB (with db.collection.updateOne() and updateMany()).

🔧 1. Add an item to an array

➕ $push

db.students.updateOne(
  { _id: 1 },
  { $push: { scores: 95 } }
)

➕ 2. Add multiple items

➕ $push with $each

db.students.updateOne(
  { _id: 1 },
  { $push: { scores: { $each: [88, 76] } } }
)

🚀 3. Add and sort

➕ $push with $each and $sort

db.students.updateOne(
  { _id: 1 },
  { $push: { scores: { $each: [67, 92], $sort: -1 } } }
)

🧹 4. Remove an item from an array

➖ $pull

db.students.updateOne(
  { _id: 1 },
  { $pull: { scores: 76 } }
)

✨ 5. Remove item by condition

➖ $pull with condition

db.students.updateOne(
  { _id: 1 },
  { $pull: { scores: { $lt: 50 } } }
)

✅ 6. Update a specific element in an array

🔍 Positional $ operator

db.students.updateOne(
  { _id: 1, "scores": 88 },
  { $set: { "scores.$": 90 } }
)

🧠 7. Update with arrayFilters

🧪 Use $[] or custom filters

db.students.updateOne(
  { _id: 1 },
  {
    $set: {
      "scores.$[elem]": 100
    }
  },
  {
    arrayFilters: [ { "elem": { $lt: 50 } } ]
  }
)

📌 8. Set entire array

🔄 Replace array

db.students.updateOne(
  { _id: 1 },
  { $set: { scores: [80, 90, 100] } }
)

🧩 9. Add only if not already present

🔁 $addToSet

db.students.updateOne(
  { _id: 1 },
  { $addToSet: { scores: 95 } }
)

🔚 10. Remove first or last element

🔽 $pop

// Remove last
db.students.updateOne(
  { _id: 1 },
  { $pop: { scores: 1 } }
)

// Remove first
db.students.updateOne(
  { _id: 1 },
  { $pop: { scores: -1 } }
)

🧮 11. Increment a value inside array

Requires arrayFilters:

db.students.updateOne(
  { _id: 1 },
  {
    $inc: { "scores.$[elem]": 5 }
  },
  {
    arrayFilters: [ { "elem": { $eq: 90 } } ]
  }
)

Let me know your specific use case (e.g., update nested arrays, arrays of objects, etc.), and I can generate tailored code for that as well.

When working with arrays of documents in MongoDB (i.e., an array containing objects rather than simple values), update operations become more complex and powerful. Here's a comprehensive list of all types of updates you can perform on arrays of documents, with code examples using the MongoDB shell or driver syntax.

🧾 Sample Document

We’ll use this document as our base example:

{
  _id: 1,
  name: "Alice",
  contacts: [
    { type: "email", value: "alice@example.com" },
    { type: "phone", value: "123456789" }
  ]
}

🧩 1. Update a field inside an array document

Positional $ operator (matches first element)

db.users.updateOne(
  { _id: 1, "contacts.type": "email" },
  { $set: { "contacts.$.value": "newalice@example.com" } }
)

🧠 2. Update multiple fields using arrayFilters

db.users.updateOne(
  { _id: 1 },
  {
    $set: {
      "contacts.$[elem].value": "updated-phone",
      "contacts.$[elem].verified": true
    }
  },
  {
    arrayFilters: [ { "elem.type": "phone" } ]
  }
)

➕ 3. Add a new document to the array

db.users.updateOne(
  { _id: 1 },
  {
    $push: {
      contacts: { type: "fax", value: "999888777" }
    }
  }
)

🔁 4. Add multiple documents to array

db.users.updateOne(
  { _id: 1 },
  {
    $push: {
      contacts: {
        $each: [
          { type: "linkedin", value: "alice-linkedin" },
          { type: "twitter", value: "@alice" }
        ]
      }
    }
  }
)

🔁 5. Add if not already present (set-like behavior)

$addToSet

db.users.updateOne(
  { _id: 1 },
  {
    $addToSet: {
      contacts: { type: "email", value: "alice@example.com" }
    }
  }
)

🧹 6. Remove a specific document

$pull by exact match

db.users.updateOne(
  { _id: 1 },
  {
    $pull: {
      contacts: { type: "fax", value: "999888777" }
    }
  }
)

🧼 7. Remove documents matching a condition

$pull with condition

db.users.updateOne(
  { _id: 1 },
  {
    $pull: {
      contacts: { type: { $in: ["linkedin", "twitter"] } }
    }
  }
)

✨ 8. Update nested fields in deeply nested arrays

Example with deeper nesting:

{
  _id: 2,
  name: "Bob",
  projects: [
    {
      name: "Alpha",
      tasks: [
        { title: "Design", status: "open" },
        { title: "Code", status: "in progress" }
      ]
    }
  ]
}
db.users.updateOne(
  { _id: 2 },
  {
    $set: {
      "projects.$[project].tasks.$[task].status": "done"
    }
  },
  {
    arrayFilters: [
      { "project.name": "Alpha" },
      { "task.title": "Design" }
    ]
  }
)

🧲 9. Sort documents inside array

db.users.updateOne(
  { _id: 1 },
  {
    $push: {
      contacts: {
        $each: [],
        $sort: { type: 1 }
      }
    }
  }
)

🧺 10. Slice array to limit length

Useful when adding multiple items and keeping array size fixed.

db.users.updateOne(
  { _id: 1 },
  {
    $push: {
      contacts: {
        $each: [
          { type: "extra", value: "extra-value" }
        ],
        $slice: -3
      }
    }
  }
)

⚡ 11. Increment a field inside array of objects

db.users.updateOne(
  { _id: 1 },
  {
    $inc: {
      "contacts.$[elem].priority": 1
    }
  },
  {
    arrayFilters: [ { "elem.type": "phone" } ]
  }
)

📌 Summary of Key Operators for Arrays of Documents

Operator Purpose
$set Update a specific field
$push Add to array
$each Push multiple items
$sort Sort pushed items
$slice Limit array size
$addToSet Add only if not present
$pull Remove by condition
$pop Remove first/last item
$inc Increment a field
arrayFilters Target specific documents in array
$ Positional operator for first match

Would you like to see a real-world case (like a todo app or student-course structure) with all these in action?

Great question! Let's break down how $ne and $not are used in array updates in MongoDB, and how to combine them with update operators like $set, $push, $pull, etc.

✅ $ne – "Not Equal"

Used in the query filter to find documents where a field or an array element does not equal a value.

🔹 Example 1: $ne with an array of documents

Sample document:

{
  _id: 1,
  name: "Alice",
  contacts: [
    { type: "email", value: "alice@example.com" },
    { type: "phone", value: "123456789" }
  ]
}

➕ Add a new contact only if it doesn't already exist:

db.users.updateOne(
  {
    _id: 1,
    "contacts": { $not: { $elemMatch: { type: "fax" } } }
  },
  {
    $push: {
      contacts: { type: "fax", value: "999-888-777" }
    }
  }
)

Here, $not + $elemMatch ensures the array does not already contain a document with type: "fax".

🔹 Example 2: $ne on subfield inside array

Update the email only if it's not already the desired value:

db.users.updateOne(
  {
    _id: 1,
    "contacts.type": "email",
    "contacts.value": { $ne: "updated@example.com" }
  },
  {
    $set: {
      "contacts.$.value": "updated@example.com"
    }
  }
)

🔸 $not – Logical NOT

Used to invert the result of another operator, like $regex, $gt, etc.

🔹 Example 3: Use $not with $regex inside array filter

db.users.updateOne(
  { _id: 1 },
  {
    $set: {
      "contacts.$[elem].value": "unknown@example.com"
    }
  },
  {
    arrayFilters: [
      { "elem.type": "email", "elem.value": { $not: /@example\.com$/ } }
    ]
  }
)

This updates the email value only if it does not end with "@example.com".

🧪 Summary of Use Cases:

Operator Purpose Example
$ne Match values not equal to something { "contacts.value": { $ne: "x" } }
$not Negate a condition (like regex, gt, etc.) { "contacts.value": { $not: /regex/ } }
$not + $elemMatch Avoid pushing duplicate object to array { contacts: { $not: { $elemMatch: { type: "x" } } } }

✅ Common Pattern: Conditional $push with $not and $elemMatch

db.users.updateOne(
  {
    _id: 1,
    contacts: {
      $not: {
        $elemMatch: {
          type: "linkedin",
          value: "linkedin.com/alice"
        }
      }
    }
  },
  {
    $push: {
      contacts: { type: "linkedin", value: "linkedin.com/alice" }
    }
  }
)

This prevents duplicate documents inside the contacts array.

Let me know if you’d like examples using $addToSet, $pull, or $inc with $ne or $not!

Great follow-up! Here's a clear breakdown:

🔍 Do $ne or $not update all array elements or just the first?

✳️ Short answer:

  • On their own, $ne and $not in the query filter only help find documents.

  • The actual update behavior (first element vs all elements) depends on:

    1. Whether you're using the positional $ operator – updates only the first matching element.
    2. Or $[<identifier>] with arrayFilters – lets you target multiple/matching elements in the array.

✅ Update first matching array element → $ (Positional operator)

Example:

db.users.updateOne(
  {
    _id: 1,
    "contacts.value": { $ne: "updated@example.com" }
  },
  {
    $set: {
      "contacts.$.value": "updated@example.com"
    }
  }
)

🔸 This will update only the first element in contacts where value != "updated@example.com".

✅ Update all matching elements → $[<identifier>] + arrayFilters

Example:

db.users.updateOne(
  { _id: 1 },
  {
    $set: {
      "contacts.$[elem].value": "updated@example.com"
    }
  },
  {
    arrayFilters: [
      { "elem.type": "email", "elem.value": { $ne: "updated@example.com" } }
    ]
  }
)

🔸 This will update all email contacts in the array that do not already have the desired value.

✅ Use $not or $ne in filter to control when update happens — not where

For example:

{
  contacts: { $not: { $elemMatch: { type: "fax" } } }
}

→ This controls whether the document should be updated at all, based on the contents of the array.

It does not decide which array elements get updated — that's controlled by the update expression, not the filter.

✅ Summary:

Feature Behavior
$ (positional operator) Updates first matching array element
$[<identifier>] + arrayFilters Updates all matching elements based on filter
$ne or $not in query Just filter which documents get updated, not which array elements
$not in arrayFilters Lets you negate array field conditions for multi-element updates

Would you like to try a real-time before-and-after example to see how these updates affect array contents?