Consultas que no distinguen entre mayúsculas y minúsculas en MongoDB

1. Consultas que no distinguen entre mayúsculas y minúsculas en MongoDB
2. Mejorar las consultas Regex que no distinguen entre mayúsculas y minúsculas
3. Use Regex en el método find() para la búsqueda que no distingue entre mayúsculas y minúsculas en MongoDB

En este artículo, las consultas que no distinguen entre mayúsculas y minúsculas se analizan en breve detalle. Además, las consultas de búsqueda que no distinguen entre mayúsculas y minúsculas también se explican en detalle.

En este artículo se tratan los siguientes temas.

1. Consultas que no distinguen entre mayúsculas y minúsculas
2. Mejorar las consultas de expresiones regulares que no distinguen entre mayúsculas y minúsculas
3. Use expresiones regulares en el método find() para búsquedas que no distinguen entre mayúsculas y minúsculas

Consultas que no distinguen entre mayúsculas y minúsculas en MongoDB

Los índices que no distinguen entre mayúsculas y minúsculas permiten búsquedas que comparan cadenas sin tener en cuenta las mayúsculas y minúsculas.

Con db.collection.createIndex() puede establecer un índice que no distinga entre mayúsculas y minúsculas al incluir el parámetro collation como parámetro opcional.

db.collection.createIndex( { "key" : 1 },
                           { collation: {
                               locale : <locale>,
                               strength : <strength>
                             }
                           } )

Incluya lo siguiente cuando especifique una intercalación para un índice que distingue entre mayúsculas y minúsculas.

1. locale: especifica las reglas del idioma.
2. fuerza: se utiliza para determinar las reglas de comparación. Un valor 1 o 2 indicará una intercalación que no distingue entre mayúsculas y minúsculas.

Comportamiento:

El uso de un índice que no distingue entre mayúsculas y minúsculas no afecta los resultados de la consulta; sin embargo, puede mejorar la velocidad.

Para utilizar un índice especificado por colación, las operaciones de consulta y clasificación deben usar la misma colación que el índice. Si una colección define una intercalación, todas las consultas e índices que usan esa colección la heredan a menos que especifiquen una intercalación diferente.

Crear un índice que no distinga entre mayúsculas y minúsculas

Cree un índice con una intercalación y especifique la opción de “fortaleza” en 1 o 2 para utilizar un índice que no distinga entre mayúsculas y minúsculas en la colección sin una intercalación predeterminada. Para utilizar la intercalación de nivel de índice, debe proporcionar la misma intercalación en el nivel de consulta.

El siguiente ejemplo genera una colección sin intercalación predeterminada y agrega un índice con una intercalación que no distingue entre mayúsculas y minúsculas a la columna tipo.

db.createCollection("fruit")

db.fruit.createIndex( { type: 1},
                      { collation: { locale: `en`, strength: 2 } } )

Las consultas deben tener la misma intercalación para usar el índice.

db.fruit.insertMany( [
   { type: "bloctak" },
   { type: "Bloctak" },
   { type: "BLOCTAK" }
] )

db.fruit.find( { type: "bloctak" } )
//not use index, finds one result

db.fruit.find( { type: "bloctak" } ).collation( { locale: `en`, strength: 2 } )
// uses index, and will find three results

db.fruit.find( { type: "bloctak" } ).collation( { locale: `en`, strength: 1 } )
//not uses the index, finds three results

Índices que no distinguen entre mayúsculas y minúsculas en colecciones con la intercalación predeterminada

Si establece una colección con una intercalación predeterminada, todos los índices futuros heredarán esa intercalación a menos que proporcione una intercalación diferente. Todas las consultas que no especifican una intercalación heredan la intercalación predeterminada.

El siguiente ejemplo genera una colección de nombres con una intercalación predeterminada y luego indexa en el campo first_name.

db.createCollection("names", { collation: { locale: `en_US`, strength: 2 } } )

db.names.createIndex( { first_name: 1 } ) // inherits the default collation

Inserte una pequeña colección de nombres:

db.names.insertMany( [
   { first_name: "Betsy" },
   { first_name: "BETSY"},
   { first_name: "betsy"}
] )

Las consultas sobre esta colección, de forma predeterminada, utilizan la intercalación proporcionada y, si es posible, el índice.

db.names.find( { first_name: "betsy" } )
// inherits the default collation: { collation: { locale: `en_US`, strength: 2 } }
// finds three results

El procedimiento anterior descubre los tres documentos utilizando la intercalación predeterminada de la colección. Emplea un índice en el campo first_name para mejorar la eficiencia.

Esta colección aún puede realizar búsquedas que distinguen entre mayúsculas y minúsculas al especificar una intercalación diferente en la consulta.

db.names.find( { first_name: "betsy" } ).collation( { locale: `en_US` } )
// not use the collection`s default collation, finds one result

El procedimiento anterior devuelve solo un documento porque utiliza una intercalación sin valor de “fuerza” proporcionado. No utiliza el índice o la intercalación predeterminada de la colección.

Mejorar las consultas Regex que no distinguen entre mayúsculas y minúsculas

Si a menudo realiza consultas de expresiones regulares que no distinguen entre mayúsculas y minúsculas (con la opción I), debe establecer un índice que no distinga entre mayúsculas y minúsculas para adaptarse a sus búsquedas.

Se puede usar una intercalación en un índice para proporcionar reglas de comparación de cadenas específicas del idioma, como las reglas de mayúsculas y minúsculas y acentos. Un índice que no distingue entre mayúsculas y minúsculas mejora significativamente el rendimiento de las consultas que no distinguen entre mayúsculas y minúsculas.

Considere los siguientes documentos en una colección de empleados. Aparte del índice _id habitual, esta colección no contiene otros índices.

db={
  "employees": [
    {
      "_id": 1,
      "first_name": "Hannah",
      "last_name": "Simmons",
      "dept": "Engineering"
    },
    {
      "_id": 2,
      "first_name": "Michael",
      "last_name": "Hughes",
      "dept": "Security"
    },
    {
      "_id": 3,
      "first_name": "Wendy",
      "last_name": "Crawford",
      "dept": "Human Resources"
    },
    {
      "_id": 4,
      "first_name": "MICHAEL",
      "last_name": "FLORES",
      "dept": "Sales"
    }
  ]
}

Si su aplicación busca a menudo en la columna first_name, es posible que desee utilizar consultas de expresiones regulares que no distinguen entre mayúsculas y minúsculas para descubrir nombres coincidentes.

La expresión regular que no distingue entre mayúsculas y minúsculas también ayuda a comparar formatos de datos que difieren, como en el ejemplo anterior, donde tiene el first_name tanto de Michael como de MICHAEL.

Si un usuario busca michael, el programa puede ejecutar la siguiente consulta.

db.employees.find({
  first_name: {
    $regex: "michael",
    $options: "i"
  }
})

Debido a que esta consulta contiene el $regex:

{ "_id" : 2, "first_name" : "Michael", "last_name" : "Hughes", "dept" : "Security" }
{ "_id" : 4, "first_name" : "MICHAEL", "last_name" : "FLORES", "dept" : "Sales" }

Aunque esta consulta devuelve los documentos deseados, las consultas de expresiones regulares que no distinguen entre mayúsculas y minúsculas sin compatibilidad con índices son lentas. Puede aumentar la eficiencia creando un índice que no distinga entre mayúsculas y minúsculas en el campo first_name.

db.employees.createIndex(
  { first_name: 1 },
  { collation: { locale: 'en', strength: 2 } }
)

Cuando el campo fuerza de un documento de intercalación de un índice se establece en 1 o 2, el índice no distingue entre mayúsculas y minúsculas para una explicación más extensa del documento de intercalación y los diversos valores de fuerza.

Para que la aplicación utilice este índice, también debe mencionar el documento de recopilación del índice en la consulta. Elimine el operador $regex de la función anterior db.collection.find() y use el índice recién construido en su lugar.

db.employees.find( { first_name: "michael" } ).collation( { locale: 'en', strength: 2 } )

No utilice el operador $regex cuando utilice un índice que no distingue entre mayúsculas y minúsculas para su consulta. La implementación de $regex no admite la intercalación y no puede usar índices que no distingan entre mayúsculas y minúsculas.

Use Regex en el método find() para la búsqueda que no distingue entre mayúsculas y minúsculas en MongoDB

Use expresiones regulares en el método find() para búsquedas que no distinguen entre mayúsculas y minúsculas.

Sintaxis:

db.demo572.find({"yourFieldName" : { `$regex`:/^yourValue$/i}});

Para comprender la sintaxis anterior, creemos una colección de documentos.

> db.demo572.insertOne({"CountryName":"US"});{
   "acknowledged" : true, "insertedId" : ObjectId("5e915f0e581e9acd78b427f1")
}
> db.demo572.insertOne({"CountryName":"UK"});{
   "acknowledged" : true, "insertedId" : ObjectId("5e915f17581e9acd78b427f2")
}
> db.demo572.insertOne({"CountryName":"Us"});{
   "acknowledged" : true, "insertedId" : ObjectId("5e915f1b581e9acd78b427f3")
}
> db.demo572.insertOne({"CountryName":"AUS"});{
   "acknowledged" : true, "insertedId" : ObjectId("5e915f20581e9acd78b427f4")
}
> db.demo572.insertOne({"CountryName":"us"});{
   "acknowledged" : true, "insertedId" : ObjectId("5e915f25581e9acd78b427f5")
}

La función buscar() muestra todos los documentos de una colección.

db.demo572.find();

Esto producirá la siguiente salida.

La siguiente es la consulta para la búsqueda que no distingue entre mayúsculas y minúsculas.

> db.demo572.find({"CountryName" : { `$regex`:/^US$/i}});

Esto producirá la siguiente salida.