Jak działają zapytania find i projekcje?

Question

Accepted Answer

Metoda **`find`** pobiera dokumenty spełniające filtr; **projekcja** kontroluje, które pola są zwracane. Razem pozwalają na wyszukanie właściwych dokumentów i kształtowanie wyników — fundamentalne dla wydajnego odczytu danych.

## find — zapytanie dokumentów

```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` zwraca **kursor** (wskaźnik do wyników), który można łączyć z `sort`, `limit`, `skip` itp. `findOne` zwraca jeden dokument bezpośrednio.

## Projekcja — wybór pól do zwrócenia

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

**Projekcja** (drugi argument) kontroluje zwracane pola: `1` włącza, `0` wyklucza. `_id` jest domyślnie włączany (wyklucz za pomocą `_id: 0`). Generalnie nie można mieszać włączeń i wykluczeń (z wyjątkiem `_id`).

## Dlaczego to ważne: wydajność i bezpieczeństwo

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

## Projekcja zagnieżdżonych i polskich tablicowych

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

## Dlaczego to ważne

`find` i projekcja są fundamentalne dla **odczytu danych** w MongoDB — wyszukiwanie właściwych dokumentów i kształtowanie wyników to ciągłe potrzeby, dlatego zrozumienie ich jest niezbędną, codzienną wiedzą.

Znajomość sposobu działania `find` (zwracającej kursor pasujących dokumentów, łączalnej z `sort`/`limit`/`skip` do sortowania i paginacji) i `findOne` (jeden dokument) jest fundamentem odczytu danych. **Projekcja** jest szczególnie ważna z dwóch praktycznych powodów: **wydajności** (zwracanie tylko potrzebnych pól zmniejsza przesyłane dane — istotne dla dużych dokumentów lub zestawów wyników, poprawiając wydajność) i zwłaszcza **bezpieczeństwa** (wykluczanie wrażliwych pól takich jak hasła lub dane wewnętrzne, aby nie wyciękły w wynikach zapytań — powszechna, ważna praktyka, np. zawsze projekcja pól hasła przy zwracaniu danych użytkownika, podobnie jak użycie modeli odpowiedzi w API).

Zrozumienie sposobu włączenia (`1`) lub wykluczenia (`0`) pól, że `_id` jest domyślnie włączany oraz sposobu projekcji zagnieżdżonych/polskich pól tablicowych obejmuje praktyczne kształtowanie wyników zapytań.

Ponieważ odczyt danych jest najbardziej powszechną operacją bazy danych, a `find` z projekcją to sposób na wydajne i bezpieczne pobranie właściwych dokumentów z właściwymi polami, zrozumienie zapytań find i projekcji — modelu kursora, łączenia do sortowania/paginacji oraz zwłaszcza projekcji dla wydajności i bezpieczeństwa (wykluczanie wrażliwych danych) — jest niezbędną, często stosowaną wiedzą MongoDB dla każdego kodu odczytującego dane, przy czym aspekt bezpieczeństwa projekcji wrażliwych pól jest szczególnie ważnym praktycznym zagadnieniem.