MongoDB
Index

Syntaxe

• db.collection.createIndex({ <string field> : <1|-1 order> [, <string field> : <1|-1 order>] });

Remarques

Champ unique

db.people.createIndex({name: 1})

Cela crée un index de champ unique ascendant sur le nom du champ.

Dans ce type d'index, l'ordre de tri n'est pas pertinent, car mongo peut parcourir l'index dans les deux sens.

Composé

db.people.createIndex({name: 1, age: -1})

Cela crée un index sur plusieurs champs, dans ce cas sur les champs name et age . Ce sera ascendant en name et descendant en age .

Dans ce type d'index, l'ordre de tri est pertinent, car il déterminera si l'index peut prendre en charge une opération de tri ou non. Le tri inverse est pris en charge sur tout préfixe d'un index composé, tant que le tri est dans le sens inverse du tri pour toutes les clés du tri. Sinon, le tri des index composés doit correspondre à l'ordre de l'index.

L'ordre des champs est également important. Dans ce cas, l'index sera trié d'abord par name , et dans chaque valeur de nom, trié en fonction des valeurs du champ d' age . Cela permet à l'index d'être utilisé par les requêtes sur le champ de name , ou sur le name et l' age , mais pas uniquement sur l' age .

Effacer

Pour supprimer un index, vous pouvez utiliser le nom d'index

db.people.dropIndex("nameIndex")

Ou le document de spécification d'index

db.people.dropIndex({name: 1})

liste

db.people.getIndexes()

Cela retournera un tableau de documents décrivant chacun un index sur la collection de personnes

Les bases de la création d'index

Voir la collection de transactions ci-dessous.

> db.transactions.insert({ cr_dr : "D", amount : 100, fee : 2});
> db.transactions.insert({ cr_dr : "C", amount : 100, fee : 2});
> db.transactions.insert({ cr_dr : "C", amount : 10,  fee : 2});
> db.transactions.insert({ cr_dr : "D", amount : 100, fee : 4});
> db.transactions.insert({ cr_dr : "D", amount : 10,  fee : 2});
> db.transactions.insert({ cr_dr : "C", amount : 10,  fee : 4});
> db.transactions.insert({ cr_dr : "D", amount : 100, fee : 2});

getIndexes() fonctions getIndexes() afficheront tous les index disponibles pour une collection.

db.transactions.getIndexes();

Laissez voir le résultat de la déclaration ci-dessus.

[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "documentation_db.transactions"
    }
]

Il existe déjà un index pour la collecte des transactions. C'est parce que MongoDB crée un index unique sur le champ _id lors de la création d'une collection. L'index _id empêche les clients d'insérer deux documents ayant la même valeur pour le champ _id . Vous ne pouvez pas supprimer cet index sur le champ _id .

Ajoutons maintenant un index pour le champ cr_dr;

db.transactions.createIndex({ cr_dr : 1 });

Le résultat de l'exécution de l'index est le suivant.

{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}

Le createdCollectionAutomatic indique si l'opération a créé une collection. Si une collection n'existe pas, MongoDB crée la collection dans le cadre de l'opération d'indexation.

Laissez exécuter db.transactions.getIndexes(); encore.

[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "documentation_db.transactions"
    },
    {
        "v" : 1,
        "key" : {
            "cr_dr" : 1
        },
        "name" : "cr_dr_1",
        "ns" : "documentation_db.transactions"
    }
]

Vous voyez maintenant que la collecte des transactions a deux indices. Par défaut _id index et cr_dr_1 que nous avons créé. Le nom est attribué par MongoDB. Vous pouvez définir votre propre nom comme ci-dessous.

db.transactions.createIndex({ cr_dr : -1 },{name : "index on cr_dr desc"})

Maintenant, db.transactions.getIndexes(); vous donnera trois indices.

[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "documentation_db.transactions"
    },
    {
        "v" : 1,
        "key" : {
            "cr_dr" : 1
        },
        "name" : "cr_dr_1",
        "ns" : "documentation_db.transactions"
    },
    {
        "v" : 1,
        "key" : {
            "cr_dr" : -1
        },
        "name" : "index on cr_dr desc",
        "ns" : "documentation_db.transactions"
    }
]

Lors de la création de l'index { cr_dr : -1 } 1 signifie que l'index sera dans l'ordre ascending et -1 dans descending ordre descending .

> db.transactions.createIndex({ cr_dr : "hashed" });    

> db.transactions.getIndexes(
[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "documentation_db.transactions"
    },
    {
        "v" : 1,
        "key" : {
            "cr_dr" : "hashed"
        },
        "name" : "cr_dr_hashed",
        "ns" : "documentation_db.transactions"
    }
]

Suppression / Suppression d'un index

Si le nom de l'index est connu,

db.collection.dropIndex('name_of_index');

Si le nom de l'index n'est pas connu,

db.collection.dropIndex( { 'name_of_field' : -1 } );

Obtenir les indices d'une collection

 db.collection.getIndexes();

Sortie

[
    {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "documentation_db.transactions"
    },
    {
        "v" : 1,
        "key" : {
            "cr_dr" : 1
        },
        "name" : "cr_dr_1",
        "ns" : "documentation_db.transactions"
    },
    {
        "v" : 1,
        "key" : {
            "cr_dr" : -1
        },
        "name" : "index on cr_dr desc",
        "ns" : "documentation_db.transactions"
    }
]

Index unique

db.collection.createIndex( { "user_id": 1 }, { unique: true } )

appliquer l'unicité à l'index défini (unique ou composé). La construction de l'index échouera si la collection contient déjà des valeurs en double; l'indexation échouera également avec plusieurs entrées manquant le champ (puisqu'elles seront toutes indexées avec la valeur null ) sauf si sparse: true est spécifié.

Index clairsemés et index partiels

Index clairsemés:

Celles-ci peuvent être particulièrement utiles pour les champs facultatifs mais qui doivent également être uniques.

{ "_id" : "[email protected]", "nickname" : "Johnnie" }
{ "_id" : "[email protected]" }
{ "_id" : "[email protected]", "nickname" : "Jules"}
{ "_id" : "[email protected]" }

Comme deux entrées n'ont pas de "pseudonyme" spécifié et que l'indexation traitera les champs non spécifiés comme null, la création de l'index échouerait avec 2 documents ayant la valeur "null", donc:

db.scores.createIndex( { nickname: 1 } , { unique: true, sparse: true } )

vous laissera encore des surnoms "null".

Les index fragmentés sont plus compacts car ils ignorent / ignorent les documents qui ne spécifient pas ce champ. Donc, si vous avez une collection dans laquelle seulement moins de 10% des documents spécifient ce champ, vous pouvez créer des index beaucoup plus petits - en utilisant mieux la mémoire limitée si vous souhaitez effectuer des requêtes telles que:

db.scores.find({'nickname': 'Johnnie'})

Index partiels:

Les index partiels représentent un sur-ensemble des fonctionnalités offertes par les index clairsemés et doivent être préférés aux index clairsemés. ( Nouveau dans la version 3.2 )

Les index partiels déterminent les entrées d'index en fonction du filtre spécifié.

db.restaurants.createIndex(
  { cuisine: 1 },
  { partialFilterExpression: { rating: { $gt: 5 } } }
)

Si la rating est supérieure à 5, la cuisine sera indexée. Oui, nous pouvons spécifier une propriété à indexer en fonction de la valeur des autres propriétés également.

Différence entre les indices clairsemés et partiels:

Les index fragmentés sélectionnent les documents à indexer uniquement en fonction de l'existence du champ indexé ou, pour les index composés, de l'existence des champs indexés.

Les index partiels déterminent les entrées d'index en fonction du filtre spécifié. Le filtre peut inclure des champs autres que les clés d'index et peut spécifier des conditions autres qu'un contrôle d'existence.

Cependant, un index partiel peut implémenter le même comportement qu'un index fragmenté

Par exemple:

db.contacts.createIndex(
   { name: 1 },
   { partialFilterExpression: { name: { $exists: true } } }
)

Remarque: Les deux l'option partialFilterExpression et l'option clairsemés ne peuvent pas être spécifiées en même temps.