Jak fungují find dotazy a projekce?

Question

Accepted Answer

Metoda **`find`** získává dokumenty odpovídající filtru; **projekce** kontroluje, která pole jsou vrácena. Dohromady vám umožňují dotazovat se na správné dokumenty a formovat výstup — to je zásadní pro efektivní čtení dat.

## find — dotazování na dokumenty

```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` vrací **kurzor** (ukazatel na výsledky), který můžete řetězit s `sort`, `limit`, `skip` atd. `findOne` vrací jeden dokument přímo.

## Projekce — výběr polí, která se mají vrátit

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

**Projekce** (druhý argument) kontroluje vrácená pole: `1` zahrnuje, `0` vylučuje. `_id` je zahrnuto ve výchozím nastavení (vyloučit pomocí `_id: 0`). Obecně nemůžete kombinovat zahrnutí a vyloučení (kromě `_id`).

## Proč je projekce důležitá: efektivita a bezpečnost

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

## Projektování vnořených a polí pole

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

## Proč to má význam

`find` a projekce jsou zásadní pro **čtení dat** v MongoDB — dotazování se na správné dokumenty a formování výstupu jsou neustálé potřeby, takže jejich pochopení je zásadní každodenní znalostí.

Pochopení toho, jak `find` funguje (vrací kurzor odpovídajících dokumentů, zřetězitelný s `sort`/`limit`/`skip` pro řazení a stránkování) a `findOne` (jeden dokument), je základem čtení dat. **Projekce** je obzvláště důležitá ze dvou praktických důvodů: **efektivita** (vrácení pouze polí, která potřebujete, snižuje přenesená data — významné pro velké dokumenty nebo sady výsledků, zlepšuje výkon) a zejména **bezpečnost** (vyloučení citlivých polí, jako jsou hesla nebo interní data, aby se v oblasti dotazů neunikla — běžná a důležitá praxe, např. vždy projektování polí hesel při vracení dat uživatele, podobně jako používání modelů odpovědí v API).

Pochopení toho, jak zahrnout (`1`) nebo vyloučit (`0`) pole, že `_id` je zahrnuto ve výchozím nastavení a jak projektovat vnořená/polí pole, pokrývá praktické formování výsledků dotazu.

Protože čtení dat je nejčastější operací databáze a protože `find` s projekcí je způsob, jak efektivně a bezpečně získat správné dokumenty se správnými poli, pochopení find dotazů a projekcí — model kurzoru, řetězení pro řazení/stránkování a zejména projekce pro efektivitu a bezpečnost (vyloučení citlivých dat) — je zásadní, často používaná znalost MongoDB pro libovolný kód čtení dat, přičemž aspekt bezpečnosti projektování citlivých polí je obzvláště důležitou praktickou úvahou.