find queries ਅਤੇ projections ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**`find`** method ਫਿਲਟਰ ਨਾਲ ਮੇਲ ਖਾਣ ਵਾਲੇ ਡੌਕੂਮੈਂਟ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ; **projection** ਨਿਯੰਤ੍ਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਫੀਲਡ ਵਾਪਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇਕੱਠੇ ਉਹ ਤੁਹਾਨੂੰ ਸਹੀ ਡੌਕੂਮੈਂਟਾਂ ਲਈ ਖੋਜ ਕਰਨ ਅਤੇ ਆਊਟਪੁੱਟ ਨੂੰ ਆਕਾਰ ਦੇਣ ਦਿੰਦੇ ਹਨ — ਡੇਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪੜ੍ਹਨ ਲਈ ਬੁਨਿਆਦੀ।

## find — ਡੌਕੂਮੈਂਟ ਖੋਜੋ

```js
db.users.find();                          // all documents
db.users.find({ age: { $gt: 25 } });      // filter: matching documents (a CURSOR)
db.users.findOne({ email: "ann@x.com" }); // the FIRST matching document (or null)

// find returns a CURSOR you can chain methods on
db.users.find({ active: true })
  .sort({ name: 1 })                      // sort
  .limit(10)                              // limit
  .skip(20);                              // skip (pagination)
```

`find` ਇੱਕ **cursor** (ਨਤੀਜਿਆਂ ਲਈ ਪੁਆਇੰਟਰ) ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ `sort`, `limit`, `skip`, ਆਦਿ ਨਾਲ ਜੋੜ ਸਕਦੇ ਹੋ। `findOne` ਸਿੱਧਾ ਇੱਕ ਡੌਕੂਮੈਂਟ ਵਾਪਸ ਕਰਦਾ ਹੈ।

## Projection — ਚੁਣੋ ਕਿ ਕਿਹੜੇ ਫੀਲਡ ਵਾਪਸ ਕਰਨੇ ਹਨ

```js
// projection: 1 = include, 0 = exclude
db.users.find({ active: true }, { name: 1, email: 1 });        // only name and email (+ _id)
db.users.find({}, { password: 0 });                           // everything EXCEPT password
db.users.find({}, { name: 1, _id: 0 });                       // name only, exclude _id
```

**Projection** (ਦੂਜਾ ਆਰਗੂਮੈਂਟ) ਵਾਪਸ ਕੀਤੇ ਫੀਲਡ ਨਿਯੰਤ੍ਰਿਤ ਕਰਦਾ ਹੈ: `1` ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ, `0` ਬਾਹਰ ਕਰਦਾ ਹੈ। `_id` ਡਿਫ਼ਾਲਟ ਨਾਲ ਸ਼ਾਮਲ ਹਿੰਦਾ ਹੈ (`_id: 0` ਨਾਲ ਬਾਹਰ ਕਰੋ)। ਆਮ ਤੌਰ 'ਤੇ ਤੁਸੀਂ ਸ਼ਾਮਲ ਅਤੇ ਬਾਹਰ ਕਰਨ ਦੀ ਮਿਲਾ-ਜੁਲਾ ਨਹੀਂ ਕਰ ਸਕਦੇ (`_id` ਨੂੰ ਛੱਡ ਕੇ)।

## ਪ੍ਰੋਜੈਕਸ਼ਨ ਮਾਇਨੇ ਕਯੋਂ ਰੱਖਦਾ ਹੈ: ਕੁਸ਼ਲਤਾ ਅਤੇ ਸੁਰੱਖਿਆ

```text
✓ EFFICIENCY — return only needed fields → less data transferred (especially for large
  documents or large result sets) → faster
✓ SECURITY — EXCLUDE sensitive fields (passwords, internal data) so they don't leak
  → e.g. always project out password fields when returning user data
```

## Nested ਅਤੇ array ਫੀਲਡ ਪ੍ਰੋਜੈਕਟ ਕਰਨਾ

```js
db.users.find({}, { "address.city": 1 });        // nested field (dot notation)
db.posts.find({}, { comments: { $slice: 5 } });   // first 5 array elements
```

## ਇਹ ਮਾਇਨੇ ਕਯੋਂ ਰੱਖਦਾ ਹੈ

`find` ਅਤੇ projection MongoDB ਵਿੱਚ **ਡੇਟਾ ਪੜ੍ਹਨ** ਲਈ ਬੁਨਿਆਦੀ ਹਨ — ਸਹੀ ਡੌਕੂਮੈਂਟਾਂ ਲਈ ਖੋਜ ਕਰਨਾ ਅਤੇ ਆਊਟਪੁੱਟ ਨੂੰ ਆਕਾਰ ਦੇਣਾ ਨਿਰੰਤਰ ਲੋੜ ਹਨ, ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਰੋਜ਼ਾਨਾ ਗਿਆਨ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ `find` ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ (ਮੇਲ ਖਾਣ ਵਾਲੇ ਡੌਕੂਮੈਂਟਾਂ ਦਾ cursor ਵਾਪਸ ਕਰਦਾ ਹੈ, `sort`/`limit`/`skip` ਨਾਲ ਜੋੜਨ ਯੋਗ) ਅਤੇ `findOne` (ਇੱਕ ਡੌਕੂਮੈਂਟ) ਹੈ ਡੇਟਾ ਪੜ੍ਹਨ ਦੀ ਬੁਨਿਆਦ। **Projection** ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਦੋ ਵਿਹਾਰਕ ਕਾਰਨਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ: **ਕੁਸ਼ਲਤਾ** (ਸਿਰਫ ਲੋੜੀਂਦੇ ਫੀਲਡ ਵਾਪਸ ਕਰਨਾ ਸਥਾਨਾਂਤਰਿਤ ਡੇਟਾ ਘਟਾਉਂਦਾ ਹੈ — ਵੱਡੇ ਡੌਕੂਮੈਂਟਾਂ ਜਾਂ ਨਤੀਜਿਆਂ ਦੇ ਸੈੱਟ ਲਈ ਮਹੱਤਵਪੂਰਨ, ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ) ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ **ਸੁਰੱਖਿਆ** (ਪਾਸਵਰਡ ਜਾਂ ਅੰਦਰੂਨੀ ਡੇਟਾ ਵਰਗੇ ਸੰਵੇਦਨਸ਼ੀਲ ਫੀਲਡ ਨੂੰ ਬਾਹਰ ਕਰਨਾ ਤਾਂ ਕਿ ਉਹ ਖੋਜ ਨਤੀਜਿਆਂ ਵਿੱਚ ਲੀਕ ਨਾ ਹੋਣ — ਇੱਕ ਆਮ, ਮਹੱਤਵਪੂਰਨ ਅਭਿਆਸ, ਮਸਲਨ ਹਮੇਸ਼ਾ ਯੂਜ਼ਰ ਡੇਟਾ ਵਾਪਸ ਕਰਦੇ ਸਮੇਂ ਪਾਸਵਰਡ ਫੀਲਡ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਆਊਟ ਕਰਨਾ, APIs ਵਿੱਚ ਜਵਾਬ ਮਾਡਲ ਵਰਤਣ ਵਰਗਾ)।

ਇਹ ਜਾਣਨਾ ਕਿ ਫੀਲਡ ਨੂੰ ਕਿਵੇਂ ਸ਼ਾਮਲ (`1`) ਜਾਂ ਬਾਹਰ (`0`) ਕਰਨਾ ਹੈ, ਕਿ `_id` ਡਿਫ਼ਾਲਟ ਨਾਲ ਸ਼ਾਮਲ ਹੈ, ਅਤੇ nested/array ਫੀਲਡਾਂ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਕਰਨਾ ਖੋਜ ਨਤੀਜਿਆਂ ਦੀ ਵਿਹਾਰਕ ਸ਼ਕਲਿੰਗ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ।

ਕਿਉਂਕਿ ਡੇਟਾ ਪੜ੍ਹਨਾ ਸਭ ਤੋਂ ਆਮ ਡੇਟਾਬੇਸ ਓਪਰੇਸ਼ਨ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ projection ਦੇ ਨਾਲ `find` ਉਹ ਕੁਸ਼ਲਤਾ ਤੋਂ ਅਤੇ ਸੁਰੱਖਿਆ ਨਾਲ ਸਹੀ ਫੀਲਡਾਂ ਵਾਲੇ ਸਹੀ ਡੌਕੂਮੈਂਟ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹੈ, find queries ਅਤੇ projections ਨੂੰ ਸਮਝਨਾ — cursor ਮਾਡਲ, sort/pagination ਲਈ ਜੋੜਨਾ, ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ ਕੁਸ਼ਲਤਾ ਅਤੇ ਸੁਰੱਖਿਆ ਲਈ projection (ਸੰਵੇਦਨਸ਼ੀਲ ਡੇਟਾ ਬਾਹਰ ਕਰਨਾ) — ਕਿਸੇ ਵੀ ਡੇਟਾ-ਪੜ੍ਹਨ ਕੋਡ ਲਈ ਮਹੱਤਵਪੂਰਨ, ਅਕਸਰ-ਲਾਗੂ MongoDB ਗਿਆਨ ਹੈ, ਸੰਵੇਦਨਸ਼ੀਲ ਫੀਲਡਾਂ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਆਊਟ ਕਰਨ ਦਾ ਸੁਰੱਖਿਆ ਪਹਿਲੂ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਾਇਨੇ ਰੱਖਣ ਵਾਲਾ ਵਿਹਾਰਕ ਵਿਚਾਰ ਹਨ।