find queries और projections कैसे काम करते हैं?

Question

Accepted Answer

**`find`** method एक filter से match करने वाले documents को retrieve करता है; **projection** नियंत्रित करता है कि कौन से fields वापस किए जाएँ। साथ में वे आपको सही documents के लिए query करने और output को आकार देने देते हैं — डेटा को कुशलता से पढ़ने के लिए मौलिक।

## find — documents query करना

```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** (results की ओर एक pointer) लौटाता है जिसे आप `sort`, `limit`, `skip`, आदि के साथ chain कर सकते हैं। `findOne` सीधे एक single document लौटाता है।

## Projection — चुनें कि कौन से fields वापस करने हैं

```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** (दूसरा argument) वापस किए गए fields को नियंत्रित करता है: `1` शामिल करता है, `0` बाहर करता है। `_id` डिफ़ॉल्ट रूप से शामिल होता है (`_id: 0` के साथ बाहर करें)। आप सामान्यतः includes और excludes को मिश्रित नहीं कर सकते (`_id` को छोड़कर)।

## Projection क्यों मायने रखता है: efficiency और security

```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 fields को project करना

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

## यह क्यों महत्वपूर्ण है

MongoDB में **डेटा पढ़ने** के लिए `find` और projection मौलिक हैं — सही documents के लिए query करना और output को आकार देना निरंतर आवश्यकताएँ हैं, इसलिए उन्हें समझना आवश्यक रोज़मर्रा का ज्ञान है।

यह जानना कि `find` कैसे काम करता है (matching documents का एक cursor लौटाना, ordering और pagination के लिए `sort`/`limit`/`skip` के साथ chainable) और `findOne` (एक single document) डेटा पढ़ने की नींव है। **Projection** दो व्यावहारिक कारणों से विशेष रूप से महत्वपूर्ण है: **efficiency** (केवल आपके आवश्यक fields लौटाना transferred डेटा को कम करता है — बड़े documents या result sets के लिए महत्वपूर्ण, performance में सुधार) और विशेष रूप से **security** (passwords या internal data जैसे sensitive fields को बाहर करना ताकि वे query results में leak न हों — एक सामान्य, महत्वपूर्ण अभ्यास, उदा. user data लौटाते समय हमेशा password fields को project out करना, APIs में response models का उपयोग करने के समान)।

यह समझना कि fields को कैसे शामिल करें (`1`) या बाहर करें (`0`), कि `_id` डिफ़ॉल्ट रूप से शामिल होता है, और nested/array fields को कैसे project करें, query results के व्यावहारिक आकार-निर्धारण को कवर करता है।

चूँकि डेटा पढ़ना सबसे सामान्य database operation है, और चूँकि projection के साथ `find` वह तरीका है जिससे आप सही fields के साथ सही documents को कुशलता से और सुरक्षित रूप से retrieve करते हैं, find queries और projections को समझना — cursor model, sort/pagination के लिए chaining, और विशेष रूप से efficiency और security के लिए projection (sensitive data को बाहर करना) — किसी भी data-reading code के लिए आवश्यक, बार-बार लागू किया जाने वाला MongoDB ज्ञान है, जिसमें sensitive fields को project out करने का security पहलू एक विशेष रूप से महत्वपूर्ण व्यावहारिक विचार है।