Kako funkcioniraju find upiti i projekcije?

Question

Accepted Answer

Metoda **`find`** dohvaća dokumente koji odgovaraju filtru; **projekcija** kontrolira koja polja se vraćaju. Zajedno omogućavaju vam da upitате ispravne dokumente i oblikujete rezultat — temeljne za efikasno čitanje podataka.

## find — upit dokumenata

```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` vraća **cursor** (pokazivač na rezultate) koji možete lanac sa `sort`, `limit`, `skip`, itd. `findOne` vraća jedan dokument direktno.

## Projekcija — odaberite koja polja vratiti

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

**Projekcija** (drugi argument) kontrolira vraćena polja: `1` uključuje, `0` isključuje. `_id` se uključuje zadano (isključite sa `_id: 0`). Generalno ne možete miješati uključivanja i isključivanja (osim za `_id`).

## Zašto projekcija važna: efikasnost i sigurnost

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

## Projekcija ugniježđenih i array polja

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

## Zašto je važno

`find` i projekcija su temeljne za **čitanje podataka** u MongoDB-u — upitivanje ispravnih dokumenata i oblikovanje rezultata su stalne potrebe, pa razumijevanje toga je osnovna svakodnevna znanja.

Znati kako `find` radi (vraćajući cursor podudarnih dokumenata, lanac sa `sort`/`limit`/`skip` za sortiranje i paginaciju) i `findOne` (jedan dokument) je temelj čitanja podataka. **Projekcija** je posebno važna iz dvaju praktičnih razloga: **efikasnost** (vraćanje samo polja koja trebate smanjuje prenesene podatke — značajno za velike dokumente ili skupove rezultata, poboljšavajući performanse) i posebno **sigurnost** (isključivanje osjetljivih polja kao što su lozinke ili interni podaci kako se ne bi procurili u rezultatima upita — česta, važna praksa, npr. uvijek isključivanje polja lozinke pri vraćanju korisničkih podataka, slično kao korištenje modela odgovora u API-jima).

Razumijevanje kako uključiti (`1`) ili isključiti (`0`) polja, da je `_id` uključen zadano, i kako projektirati ugniježđena/array polja pokriva praktično oblikovanje rezultata upita.

Budući da je čitanje podataka najčešća operacija baze podataka, i budući da je `find` s projekcijom način na koji efikasno i sigurno dohvaćate ispravne dokumente s ispravnim poljima, razumijevanje find upita i projekcija — model cursora, lanac za sortiranje/paginaciju, i posebno projekcija za efikasnost i sigurnost (isključivanje osjetljivih podataka) — je osnovna, često primijenjena MongoDB znanja za bilo koji kod čitanja podataka, sa sigurnosnim aspektom isključivanja osjetljivih polja biti posebno važna praktična razmatranja.