Cum funcționează interogările find și proiecțiile?

Question

Accepted Answer

Metoda **`find`** recuperează documentele care se potrivesc cu un filtru; **proiecția** controlează care câmpuri sunt returnate. Împreună, permit interogarea pentru documentele potrivite și formatarea ieșirii — fundamental pentru citirea eficientă a datelor.

## find — interogarea documentelor

```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` returnează un **cursor** (un pointer la rezultate) pe care îl puteți encadena cu `sort`, `limit`, `skip`, etc. `findOne` returnează direct un singur document.

## Proiecție — alege care câmpuri să returnezi

```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
```

**Proiecția** (al doilea argument) controlează câmpurile returnate: `1` include, `0` exclude. `_id` este inclus implicit (excludere cu `_id: 0`). În general, nu puteți amesteca include-uri și exclude-uri (cu excepția `_id`).

## De ce proiecția este importantă: eficiență și securitate

```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
```

## Proiectarea câmpurilor imbricate și array

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

## De ce este important

`find` și proiecția sunt fundamentale pentru **citirea datelor** în MongoDB — interogarea pentru documentele potrivite și formatarea ieșirii sunt nevoi constante, deci înțelegerea lor este cunoștințe esențiale zilnice.

Cunoașterea modului în care funcționează `find` (returnând un cursor de documente potrivite, encadenabil cu `sort`/`limit`/`skip` pentru ordonare și paginare) și `findOne` (un singur document) este baza citirii datelor. **Proiecția** este deosebit de importantă din două motive practice: **eficiență** (returnarea doar a câmpurilor de care aveți nevoie reduce datele transferate — semnificativ pentru documente mari sau seturi de rezultate, îmbunătățind performanța) și în special **securitate** (excluderea câmpurilor sensibile, cum ar fi parolele sau datele interne, pentru a nu se scurge în rezultatele interogării — o practică comună și importantă, de exemplu, excludeți întotdeauna câmpurile de parolă la returnarea datelor utilizatorului, similar cu utilizarea modelelor de răspuns în API-uri).

Înțelegerea modului de includere (`1`) sau excludere (`0`) a câmpurilor, că `_id` este inclus implicit și cum se proiectează câmpurile imbricate/array acoperă formatarea practică a rezultatelor interogării.

Deoarece citirea datelor este cea mai comună operație de bază de date, și deoarece `find` cu proiecție este modul în care recuperați eficient și în siguranță documentele corecte cu câmpurile corecte, înțelegerea interogărilor find și proiecțiilor — modelul cursor, encadenarea pentru sort/paginare și în special proiecția pentru eficiență și securitate (excluderea datelor sensibile) — este esențial, cunoștințe MongoDB frecvent aplicate pentru orice cod de citire a datelor, cu aspectul de securitate al proiectării datelor sensibile fiind o considerație practică deosebit de importantă.