Per citare i documenti :

Quando si crea un indice, il numero associato a una chiave specifica la direzione dell'indice, quindi dovrebbe essere sempre 1 (crescente) o -1 (decrescente). La direzione non è importante per gli indici a chiave singola o per il recupero ad accesso casuale, ma è importante se si eseguono query di ordinamento o intervallo su indici composti.

Tuttavia, non vedo alcun motivo per cui la direzione dell'indice dovrebbe avere importanza negli indici composti. Qualcuno può fornire un'ulteriore spiegazione (o un esempio)?

MongoDB concatena in qualche modo la chiave composta e la utilizza come chiave in un BTree.

Quando si trovano elementi singoli : l'ordine dei nodi nell'albero è irrilevante.

Se stai restituendo un intervallo di nodi : gli elementi vicini tra loro si troveranno lungo gli stessi rami dell'albero. Più i nodi sono vicini all'intervallo, più velocemente possono essere recuperati.

Con un singolo indice di campo : l'ordine non avrà importanza. Se sono ravvicinati in ordine crescente, saranno anche vicini in ordine decrescente.

Quando hai una chiave composta - L'ordine inizia a essere importante.

Ad esempio, se la chiave è A crescente B crescente, l'indice potrebbe essere simile a questo:

Riga AB
1 1 1
2 2 6
3 2 7 
4 3 4
5 3 5
6 3 6
7 5 1

Una query per A crescente B decrescente dovrà saltare intorno all'indice fuori ordine per restituire le righe e sarà più lenta. Ad esempio restituirà Row1, 3, 2, 6, 5, 4, 7

Una query con intervallo nello stesso ordine dell'indice restituirà semplicemente le righe in sequenza nell'ordine corretto.

Trovare un record in un BTree richiede tempo O (Log (n)). Trovare un intervallo di record in ordine è solo OLog (n) + k dove k è il numero di record da restituire.

Se i record sono fuori servizio, il costo potrebbe essere pari a OLog (n) * k

La semplice risposta che stai cercando è che la direzione è importante solo quando esegui l'ordinamento su due o più campi .

Se stai ordinando su {a : 1, b : -1}:

L'indice {a : 1, b : 1}sarà più lento dell'indice{a : 1, b : -1}

Perché gli indici

Comprendi due punti chiave.

1. Sebbene un indice sia migliore di nessun indice, l'indice corretto è molto migliore di entrambi.
2. MongoDB utilizzerà solo un indice per query, creando indici composti con il corretto ordinamento dei campi che probabilmente si desidera utilizzare.

Gli indici non sono gratuiti. Prendono memoria e impongono una riduzione delle prestazioni durante gli inserimenti, gli aggiornamenti e le eliminazioni. Normalmente il calo delle prestazioni è trascurabile (soprattutto se paragonato all'aumento delle prestazioni di lettura), ma ciò non significa che non possiamo essere intelligenti nel creare i nostri indici.

Come indici

Identificare il gruppo di campi da indicizzare insieme significa comprendere le query che stai eseguendo. L'ordine dei campi utilizzati per creare il tuo indice è fondamentale. La buona notizia è che, se sbagli l'ordine, l'indice non verrà utilizzato affatto, quindi sarà facile individuarlo spiegando.

Perché ordinare

Le tue query potrebbero richiedere l'ordinamento. Ma l'ordinamento può essere un'operazione costosa, quindi è importante trattare i campi su cui stai ordinando proprio come un campo su cui stai interrogando. Quindi sarà più veloce se ha index. Tuttavia, c'è una differenza importante, il campo che stai ordinando deve essere l'ultimo campo del tuo indice. L'unica eccezione a questa regola è che se anche il campo fa parte della query, la regola deve essere l'ultima non si applica.

Come ordinare

È possibile specificare un ordinamento su tutte le chiavi dell'indice o su un sottoinsieme; tuttavia, le chiavi di ordinamento devono essere elencate nello stesso ordine in cui appaiono nell'indice. Ad esempio, un modello di chiave di indice {a: 1, b: 1} può supportare un ordinamento su {a: 1, b: 1} ma non su {b: 1, a: 1}.

L'ordinamento deve specificare la stessa direzione di ordinamento (cioè ascendente / discendente) per tutte le sue chiavi come modello di chiave di indice o specificare la direzione di ordinamento inversa per tutte le sue chiavi come modello di chiave di indice. Ad esempio, un pattern di chiave di indice {a: 1, b: 1} può supportare un ordinamento su {a: 1, b: 1} e {a: -1, b: -1} ma non su {a: -1 , b: 1}.

Supponiamo che ci siano questi indici:

{ a: 1 }
{ a: 1, b: 1 }
{ a: 1, b: 1, c: 1 }

Example                                                    Index Used
db.data.find().sort( { a: 1 } )                            { a: 1 }
db.data.find().sort( { a: -1 } )                           { a: 1 }
db.data.find().sort( { a: 1, b: 1 } )                      { a: 1, b: 1 }
db.data.find().sort( { a: -1, b: -1 } )                    { a: 1, b: 1 }
db.data.find().sort( { a: 1, b: 1, c: 1 } )                { a: 1, b: 1, c: 1 }
db.data.find( { a: { $gt: 4 } } ).sort( { a: 1, b: 1 } )   { a: 1, b: 1 }