MongoDB
Índices
Buscar..
Sintaxis
db.collection.createIndex({ <string field> : <1|-1 order> [, <string field> : <1|-1 order>] });
Observaciones
Impacto en el rendimiento : tenga en cuenta que los índices mejoran el rendimiento de lectura, pero pueden tener un impacto negativo en el rendimiento de escritura, ya que la inserción de un documento requiere la actualización de todos los índices.
Campo único
db.people.createIndex({name: 1})
Esto crea un índice de campo único ascendente en el nombre del campo.
En este tipo de índices, el orden de clasificación es irrelevante, porque mongo puede atravesar el índice en ambas direcciones.
Compuesto
db.people.createIndex({name: 1, age: -1})
Esto crea un índice en varios campos, en este caso en age campos de name y age . Será ascendente en name y descendente en age .
En este tipo de índice, el orden de clasificación es relevante, ya que determinará si el índice puede admitir una operación de clasificación o no. La clasificación inversa se admite en cualquier prefijo de un índice compuesto, siempre que la clasificación esté en la dirección de clasificación inversa para todas las claves de la clasificación. De lo contrario, la clasificación de los índices compuestos debe coincidir con el orden del índice.
El orden de los campos también es importante, en este caso el índice se ordenará primero por name y, dentro de cada valor de nombre, se ordenará por los valores del campo de age . Esto permite que el índice sea utilizado por consultas en el campo de name , o en name y age , pero no solo en la age .
Borrar
Para descartar un índice puedes usar el nombre del índice.
db.people.dropIndex("nameIndex")
O el documento de especificación del índice
db.people.dropIndex({name: 1})
Lista
db.people.getIndexes()
Esto devolverá una serie de documentos, cada uno describiendo un índice en la colección de personas
Conceptos básicos de creación de índices
Vea la colección de transacciones a continuación.
> 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() funciones getIndexes() mostrarán todos los índices disponibles para una colección.
db.transactions.getIndexes();
Vamos a ver la salida de la declaración anterior.
[
{
"v" : 1,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "documentation_db.transactions"
}
]
Ya hay un índice para la colección de transacciones. Esto se debe a que MongoDB crea un índice único en el campo _id durante la creación de una colección. El índice _id evita que los clientes inserten dos documentos con el mismo valor para el campo _id . No puede colocar este índice en el campo _id .
Ahora vamos a agregar un índice para el campo cr_dr;
db.transactions.createIndex({ cr_dr : 1 });
El resultado de la ejecución del índice es el siguiente.
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
El createdCollectionAutomatically indica si la operación creó una colección. Si no existe una colección, MongoDB crea la colección como parte de la operación de indexación.
Deje ejecutar db.transactions.getIndexes(); otra vez.
[
{
"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"
}
]
Ahora ves que las transacciones de cobro tienen dos índices. Índice _id predeterminado y cr_dr_1 que creamos. El nombre es asignado por MongoDB. Puede establecer su propio nombre como abajo.
db.transactions.createIndex({ cr_dr : -1 },{name : "index on cr_dr desc"})
Ahora db.transactions.getIndexes(); Te daremos tres índices.
[
{
"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"
}
]
Al crear el índice { cr_dr : -1 } 1 significa que el índice estará en orden ascending y -1 para el orden descending .
Índices hash
Los índices se pueden definir también como hash . Esto es más eficaz en consultas de igualdad , pero no es eficiente para consultas de rango ; sin embargo, puede definir los índices con hash y ascendente / descendente en el mismo campo.
> 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"
}
]
Eliminando / Eliminando un Índice
Si el nombre del índice es conocido,
db.collection.dropIndex('name_of_index');
Si no se conoce el nombre del índice,
db.collection.dropIndex( { 'name_of_field' : -1 } );
Obtener índices de una colección
db.collection.getIndexes();
Salida
[
{
"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"
}
]
Índice único
db.collection.createIndex( { "user_id": 1 }, { unique: true } )
imponer la unicidad en el índice definido (ya sea individual o compuesto). La creación del índice fallará si la colección ya contiene valores duplicados; la indexación fallará también con varias entradas que faltan en el campo (ya que todas se indexarán con el valor null ) a menos que se especifique sparse: true .
Índices dispersos e índices parciales
Índices dispersos:
Estos pueden ser particularmente útiles para los campos que son opcionales pero que también deben ser únicos.
{ "_id" : "[email protected]", "nickname" : "Johnnie" }
{ "_id" : "[email protected]" }
{ "_id" : "[email protected]", "nickname" : "Jules"}
{ "_id" : "[email protected]" }
Dado que dos entradas no tienen un "apodo" especificado y la indexación tratará los campos no especificados como nulos, la creación del índice fallará con 2 documentos que tengan 'nulo', por lo que:
db.scores.createIndex( { nickname: 1 } , { unique: true, sparse: true } )
te dejará tener apodos 'nulos'.
Los índices dispersos son más compactos, ya que omiten / ignoran los documentos que no especifican ese campo. Entonces, si tiene una colección donde solo menos del 10% de los documentos especifican este campo, puede crear índices mucho más pequeños, haciendo un mejor uso de la memoria limitada si desea hacer consultas como:
db.scores.find({'nickname': 'Johnnie'})
Índices parciales:
Los índices parciales representan un superconjunto de la funcionalidad ofrecida por los índices dispersos y deberían preferirse a los índices dispersos. ( Nuevo en la versión 3.2 )
Los índices parciales determinan las entradas de índice según el filtro especificado.
db.restaurants.createIndex(
{ cuisine: 1 },
{ partialFilterExpression: { rating: { $gt: 5 } } }
)
Si la rating es mayor a 5, entonces la cuisine será indexada. Sí, podemos especificar una propiedad para ser indexada en función del valor de otras propiedades también.
Diferencia entre índices dispersos y parciales:
Los índices dispersos seleccionan documentos para indexar únicamente en función de la existencia del campo indexado, o para los índices compuestos, la existencia de los campos indexados.
Los índices parciales determinan las entradas de índice según el filtro especificado. El filtro puede incluir campos que no sean las claves de índice y puede especificar condiciones distintas a solo una verificación de existencia.
Aún así, un índice parcial puede implementar el mismo comportamiento que un índice disperso
P.ej:
db.contacts.createIndex(
{ name: 1 },
{ partialFilterExpression: { name: { $exists: true } } }
)
Nota: La opción partialFilterExpression y la opción sparse no se pueden especificar al mismo tiempo.