find கேரிகள் மற்றும் projections எப்படி வேலை செய்கிறது?

Question

Accepted Answer

**`find`** method ஒரு filter உடன் பொருந்தும் documents களை பெறுகிறது; **projection** எந்த fields திரும்ப வேண்டும் என்பதை கட்டுப்படுத்துகிறது. ஒன்றாக அவை சரியான documents க்கு query செய்ய மற்றும் output வடிவம் கொடுக்க உதவுகிறது — data வாசிப்பதை திறமையாக செய்ய அடிப்படை.

## find — documents குவியலை செய்யுங்கள்

```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 களை Projecting செய்யுங்கள்

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

## ஏன் இது முக்கியம்

`find` மற்றும் projection MongoDB இல் **data வாசிப்பதற்கு** அடிப்படை — சரியான documents க்கு query செய்தல் மற்றும் output வடிவம் கொடுப்பது நிरந்தர தேவைகள், எனவே அவற்றை புரிந்து கொள்ள அத்தியாவசிய அன்றாட அறிவு.

`find` எப்படி வேலை செய்கிறது என்பதை அறிந்து கொள்ளுங்கள் (matching documents களின் cursor திரும்பி கொடுக்கிறது, `sort`/`limit`/`skip` உடன் chainable ordering மற்றும் pagination க்கு) மற்றும் `findOne` (ஒரு single document) data வாசிப்பதின் அடிப்படை. **Projection** இரண்டு practical காரணங்களுக்கு குறிப்பாக முக்கியம்: **efficiency** (நீங்கள் தேவையான fields மட்டும் திரும்பி கொடுப்பது transferred data குறைக்கிறது — பெரிய documents அல்லது result sets க்கு महत्वपूर्ण, performance மேம்படுத்த) மற்றும் குறிப்பாக **security** (passwords அல்லது internal data போன்ற sensitive fields விலக்கி அவை query results இல் leak ஆகாமல் — ஒரு common, महत्वपूर्ण অনুশীলन, எ.கா. user data திரும்பி கொடுக்கும் போது எப்போதும் password fields விலக்கி projecting, APIs இல் response models பயன்படுத்துவது போன்றது).

How to include (`1`) அல்லது exclude (`0`) fields, `_id` பொதுவாக சேர்க்கப்படுகிறது, மற்றும் nested/array fields projecting செய்ய எப்படி என்பதை புரிந்து கொள்ளுங்கள் query results வடிவத்தை மாற்றுகிறது.

Data வாசிப்பது மிக பொதுவான database operation எனவே, மற்றும் `find` projection உடன் எப்படி நீங்கள் efficiently மற்றும் securely சரியான documents சரியான fields உடன் பெறுகிறீர்கள் என்பதால், find queries மற்றும் projections புரிந்து கொள்ளுங்கள் — cursor model, sort/pagination க்கு chaining, மற்றும் குறிப்பாக projection efficiency மற்றும் security க்கு (sensitive data விலக்கி) — essential, frequently-applied MongoDB knowledge எந்த data-reading code க்கும், sensitive fields projecting செய்து விலக்கி என்ற security aspect ஒரு குறிப்பாக महत्वपूर्ण practical consideration.