Implémenter la fonctionnalité d'auto-complétion à l'aide de MongoDB recherche

tl;dr

Il n'y a pas de solution facile pour ce que vous voulez, étant donné que les requêtes ne peuvent pas modifier les champs de leur retour. Il y a une solution (à l'aide de la ci-dessous mapReduce inline au lieu de faire une sortie d'une collection), mais, sauf pour les très petites bases de données, il n'est pas possible de le faire en temps réel.

Le problème

Comme l'écrit, une normale de requête ne peut pas vraiment modifier les champs, il renvoie. Mais il y a d'autres problèmes. Si vous voulez faire une regex de recherche dans les à mi-chemin décent de temps, vous aurez à index tous champs, qui aurait besoin d'un montant disproportionné de RAM pour de la fonctionnalité. Si vous n'avez pas d'index tous des champs, un regex de recherche serait la cause d'une collection de numérisation, ce qui signifie que chaque document devra être chargé à partir du disque, ce qui prendrait trop de temps pour l'auto-complétion pour être pratique. En outre, plusieurs utilisateurs simultanés demandant d'auto-complétion reviendrait à créer une grande charge sur le backend.

La solution

Le problème est assez similaire à j'ai déjà répondu: Nous avons besoin d'extraire tous les mots de plusieurs champs, supprimer la stop paroles et enregistrez le reste des mots avec un lien vers le document en question(s), le mot a été trouvé dans une collection. Maintenant, pour obtenir une liste d'auto-complétion, nous avons tout simplement requête de l'indexation de la liste de mots.

Étape 1: Utiliser une carte, à en réduire l'emploi d'extraire les mots

db.yourCollection.mapReduce(
//Map function
function() {
//We need to save this in a local var as per scoping problems
var document = this;
//You need to expand this according to your needs
var stopwords = ["the","this","and","or"];
for(var prop in document) {
//We are only interested in strings and explicitly not in _id
if(prop === "_id" || typeof document[prop] !== 'string') {
continue
}
(document[prop]).split(" ").forEach(
function(word){
//You might want to adjust this to your needs
var cleaned = word.replace(/[;,.]/g,"")
if(
//We neither want stopwords...
stopwords.indexOf(cleaned) > -1 ||
//...nor string which would evaluate to numbers
!(isNaN(parseInt(cleaned))) ||
!(isNaN(parseFloat(cleaned)))
) {
return
}
emit(cleaned,document._id)
}
) 
}
},
//Reduce function
function(k,v){
//Kind of ugly, but works.
//Improvements more than welcome!
var values = { 'documents': []};
v.forEach(
function(vs){
if(values.documents.indexOf(vs)>-1){
return
}
values.documents.push(vs)
}
)
return values
},
{
//We need this for two reasons...
finalize:
function(key,reducedValue){
//First, we ensure that each resulting document
//has the documents field in order to unify access
var finalValue = {documents:[]}
//Second, we ensure that each document is unique in said field
if(reducedValue.documents) {
//We filter the existing documents array
finalValue.documents = reducedValue.documents.filter(
function(item,pos,self){
//The default return value
var loc = -1;
for(var i=0;i<self.length;i++){
//We have to do it this way since indexOf only works with primitives
if(self[i].valueOf() === item.valueOf()){
//We have found the value of the current item...
loc = i;
//... so we are done for now
break
}
}
//If the location we found equals the position of item, they are equal
//If it isn't equal, we have a duplicate
return loc === pos;
}
);
} else {
finalValue.documents.push(reducedValue)
}
//We have sanitized our data, now we can return it        
return finalValue
},
//Our result are written to a collection called "words"
out: "words"
}
)

L'exécution de cette mapReduce contre votre exemple entraînerait db.words ressembler à ceci:

    { "_id" : "can", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "canada", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "candid", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "candle", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "candy", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "cannister", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "canteen", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }
{ "_id" : "canvas", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }

Noter que les paroles individuelles sont les _id des documents. Le _id champ est indexé automatiquement par MongoDB. Depuis indices sont essayé d'être conservé dans la mémoire vive, on peut faire quelques trucs à la fois d'accélérer l'auto-complétion et de réduire la charge sur le serveur.

Étape 2: Requête pour l'autocomplétion

Pour l'autocomplétion, nous avons seulement besoin de mots, sans les liens vers les documents.
Puisque les mots sont indexés, nous utilisons un requête couverte – une requête répondu seulement à partir de l'index, qui réside habituellement dans la mémoire RAM.

À s en tenir à votre exemple, nous pourrions utiliser la requête suivante pour obtenir les candidats à l'auto-complétion:

db.words.find({_id:/^can/},{_id:1})

qui nous donne le résultat

    { "_id" : "can" }
{ "_id" : "canada" }
{ "_id" : "candid" }
{ "_id" : "candle" }
{ "_id" : "candy" }
{ "_id" : "cannister" }
{ "_id" : "canteen" }
{ "_id" : "canvas" }

À l'aide de la .explain() méthode, on peut vérifier que cette requête utilise uniquement l'index.

        {
"cursor" : "BtreeCursor _id_",
"isMultiKey" : false,
"n" : 8,
"nscannedObjects" : 0,
"nscanned" : 8,
"nscannedObjectsAllPlans" : 0,
"nscannedAllPlans" : 8,
"scanAndOrder" : false,
"indexOnly" : true,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"indexBounds" : {
"_id" : [
[
"can",
"cao"
],
[
/^can/,
/^can/
]
]
},
"server" : "32a63f87666f:27017",
"filterSet" : false
}

Note le indexOnly:true champ.

Étape 3: la Requête du document,

Quoique nous n'en aurez à faire deux requêtes pour obtenir le document en lui-même, depuis que nous avons d'accélérer l'ensemble du processus, l'expérience utilisateur doit être assez bien.

Étape 3.1: Obtenir le document de la words collection

Lorsque l'utilisateur sélectionne un choix de l'auto-complétion, nous devons nous interroger le document complet de mots dans l'ordre pour trouver les documents où le mot choisi pour l'auto-complétion est originaire de.

db.words.find({_id:"canteen"})

qui devrait aboutir à un document comme ceci:

{ "_id" : "canteen", "value" : { "documents" : [ ObjectId("553e435f20e6afc4b8aa0efb") ] } }

Étape 3.2: Obtenir le document réel

Avec ce document, nous pouvons maintenant afficher une page avec les résultats de la recherche ou, comme dans ce cas, la redirection vers le document que vous pouvez obtenir par:

db.yourCollection.find({_id:ObjectId("553e435f20e6afc4b8aa0efb")})

Notes

Bien que cette approche peut paraître compliqué au premier abord (le bien, le mapReduce est un peu), il est vrai assez facile sur le plan conceptuel. Fondamentalement, vous faites du commerce des résultats en temps réel (que vous n'aurez pas de toute façon à moins de dépenser une beaucoup de RAM) pour la vitesse. À mon humble avis, c'est une bonne affaire. Afin de rendre le coût assez élevé mapReduce la phase la plus efficace, la mise en œuvre de Différentiels mapReduce pourrait être une approche – l'amélioration de mon il est vrai piraté mapReduce pourrait bien être un autre.

Dernier mais non le moindre, de cette façon est plutôt moche hack tout à fait. Vous pourriez voulez plonger dans elasticsearch ou lucene. Ces produits à mon humble avis sont beaucoup, beaucoup plus adapté pour ce que vous voulez.

OriginalL'auteur Markus W Mahlberg