Bleve : Comment créer un moteur de recherche ultra-rapide ?

Go/Golang est l'une de mes langues préférées ; J'aime le minimalisme et sa propreté, il est très compact au niveau de la syntaxe et s'efforce de garder les choses simples (je suis un grand fan du principe KISS).

L'un des défis majeurs auxquels j'ai été confronté ces derniers temps est de créer un moteur de recherche rapide. Bien sûr, il existe des options telles que SOLR et ElasticSearch ; les deux fonctionnent très bien et sont hautement évolutifs, cependant, j'avais besoin de simplifier la recherche, en la rendant plus rapide et plus facile à déployer avec peu ou pas de dépendances.

J'avais besoin d'optimiser suffisamment pour pouvoir renvoyer rapidement les résultats afin qu'ils puissent être reclassés. Bien que C/Rust puisse convenir à cela, j'apprécie la vitesse de développement et la productivité. Golang est le meilleur des deux mondes, je suppose.

Dans cet article, je vais vous présenter un exemple simple de la façon dont vous pouvez créer votre propre moteur de recherche à l'aide de Go, vous serez surpris : ce n'est pas aussi compliqué que vous ne le pensez.

Golang : Python sous stéroïdes

Je ne sais pas pourquoi, mais Golang ressemble en quelque sorte à Python. La syntaxe est très facile à comprendre, c'est peut-être le manque de points-virgules et de crochets partout ou le manque d'instructions try-catch laides. C'est peut-être le génial formateur Go, je ne sais pas.

Quoi qu'il en soit, puisque Golang génère un seul binaire autonome, il est très facile à déployer sur n'importe quel serveur de production. Il vous suffit de « construire » et d'échanger l'exécutable.

C'est exactement ce dont j'avais besoin.

Est-ce que vous Blèvez ?

Non, ce n'est pas une faute de frappe ?. Bleve est une bibliothèque de recherche puissante, facile à utiliser et très flexible pour Golang.

En tant que développeur Go, vous évitez généralement les packages tiers comme la peste ; il est parfois judicieux d’utiliser un package tiers. Bleve est rapide, bien conçu et offre une valeur suffisante pour justifier son utilisation.

De plus, voici pourquoi je "Bleve" :

• Autonome, l'un des gros avantages de Golang est le binaire unique, je voulais donc conserver cette sensation et ne pas avoir besoin d'une base de données ou d'un service externe pour stocker et interroger des documents. Bleve s'exécute en mémoire et écrit sur le disque de la même manière que Sqlite.

• Facile à étendre. Puisqu'il ne s'agit que de code Go, je peux facilement modifier la bibliothèque ou l'étendre dans ma base de code selon mes besoins.

• Rapide : les résultats de recherche sur 10 millions de documents ne prennent que 50 à 100 ms, cela inclut le filtrage.

• Faceting : vous ne pouvez pas créer un moteur de recherche moderne sans un certain niveau de prise en charge des facettes. Bleve prend entièrement en charge les types de facettes courants : comme les plages ou le simple nombre de catégories.

• Indexation rapide : Bleve est un peu plus lent que SOLR. SOLR peut indexer 10 millions de documents en 30 minutes, tandis que Bleve prend plus d'une heure, cependant, une heure environ reste assez décente et suffisamment rapide pour mes besoins.

• Résultats de bonne qualité. Bleve fonctionne bien avec les résultats de mots clés, mais certaines recherches de type sémantique fonctionnent également très bien dans Bleve.

• Démarrage rapide : si vous devez redémarrer ou déployer une mise à jour, le redémarrage de Bleve ne prend que quelques millisecondes. Il n'y a pas de blocage des lectures pour reconstruire l'index en mémoire, donc la recherche de l'index est possible sans problème quelques millisecondes seulement après un redémarrage.

Mettre en place un index ?

Dans Bleve, un "Index" peut être considéré comme une table de base de données ou une collection (NoSQL). Contrairement à une table SQL classique, vous n'avez pas besoin de spécifier chaque colonne, vous pouvez essentiellement vous en sortir avec le schéma par défaut pour la plupart des cas d'utilisation.

Pour initialiser un index Bleve, vous pouvez procéder comme suit :

mappings := bleve.NewIndexMapping()
index, err = bleve.NewUsing("/some/path/index.bleve", mappings, "scorch", "scorch", nil)
if err != nil {
    log.Fatal(err)
}

Bleve prend en charge plusieurs types d'index différents, mais j'ai découvert après de nombreuses recherches que le type d'index "scorch" vous offre les meilleures performances. Si vous ne transmettez pas les 3 derniers arguments, Bleve utilisera simplement BoltDB par défaut.

Ajout de documents

Ajouter des documents à Bleve est un jeu d'enfant. En gros, vous pouvez stocker n'importe quel type de structure dans l'index :

type Book struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Genre string `json:"genre"`
}

b := Book{
    ID:    1234,
    Name:  "Some creative title",
    Genre: "Young Adult",
}
idStr := fmt.Sprintf("%d", b.ID)
// index(string, interface{})
index.index(idStr, b)

Si vous indexez une grande quantité de documents, il est préférable d'utiliser le batching :

// You would also want to check if the batch exists already
// - so that you don't recreate it.
batch := index.NewBatch()
if batch.Size() >= 1000 {
    err := index.Batch(batch)
    if err != nil {
        // failed, try again or log etc...
    }
    batch = index.NewBatch()
} else {
    batch.index(idStr, b)
}

Comme vous le remarquerez, une tâche complexe comme le regroupement d'enregistrements et leur écriture dans l'index est simplifiée à l'aide de "index.NewBatch" qui crée un conteneur pour indexer temporairement les documents.

Par la suite, il vous suffit de vérifier la taille au fur et à mesure de la boucle et de vider l'index une fois que vous avez atteint la limite de taille du lot.

Recherche dans l'index

Bleve expose plusieurs analyseurs de requêtes de recherche différents parmi lesquels vous pouvez choisir en fonction de vos besoins de recherche. Pour que cet article soit court et agréable, je vais simplement utiliser l'analyseur de chaîne de requête standard.

searchParser := bleve.NewQueryStringQuery("chicken reciepe books")
maxPerPage := 50
ofsset := 0
searchRequest := bleve.NewSearchRequestOptions(searchParser, maxPerPage, offset, false)
// By default bleve returns just the ID, here we specify
// - all the other fields we would like to return.
searchRequest.Fields = []string{"id", "name", "genre"}
searchResults, err := index.Search(searchResult)

Avec seulement ces quelques lignes, vous disposez désormais d'un moteur de recherche puissant qui fournit de bons résultats avec une faible empreinte mémoire et ressources.

Voici une représentation JSON des résultats de la recherche, les "hits" contiendront les documents correspondants :

{
    "status": {
        "total": 5,
        "failed": 0,
        "successful": 5
    },
    "request": {},
    "hits": [],
    "total_hits": 19749,
    "max_score": 2.221337297308545,
    "took": 99039137,
    "facets": null
}

Facettage

Comme mentionné précédemment, Bleve fournit une prise en charge complète des facettes sans avoir à les configurer dans votre schéma. Pour Facet sur le livre "Genre" par exemple, vous pouvez faire comme suit :

//... build searchRequest -- see previous section.
// Add facets
genreFacet := bleve.NewFacetRequest("genre", 50)
searchRequest.AddFacet("genre", genreFacet)
searchResults, err := index.Search(searchResult)

Nous étendons notre searchRequest du précédent avec seulement 2 lignes de code. Le "NewFacetRequest" prend en compte 2 arguments :

• Champ : le champ de notre index à facettes sur (string).

• Taille : le nombre d'entrées à compter (entier). Ainsi dans notre exemple, il ne comptera que les 50 premiers genres.

Ce qui précède remplira désormais les « facettes » dans nos résultats de recherche.

Ensuite, nous ajoutons simplement notre facette à la demande de recherche. Ce qui prend en compte un "nom de facette" et la facette réelle. "Nom de la facette" est la "clé" sous laquelle vous trouverez cet ensemble de résultats dans nos résultats de recherche.

Requêtes et filtrage avancés

Bien que l'analyseur "QueryStringQuery" puisse vous rapporter pas mal de kilomètres ; parfois, vous avez besoin de requêtes plus complexes telles que "il faut correspondre" où vous souhaitez faire correspondre un terme de recherche avec plusieurs champs et renvoyer des résultats à condition qu'au moins un champ corresponde.

Vous pouvez utiliser les types de requêtes « Disjonction » et « Conjonction » pour ce faire.

• Requête de conjonction : Fondamentalement, elle vous permet d'enchaîner plusieurs requêtes ensemble pour former une requête géante. Toutes les requêtes enfants doivent correspondre à au moins un document.

• Requête de disjonction : Cela vous permettra d'effectuer la requête "il faut correspondre" mentionnée ci-dessus. Vous pouvez transmettre un nombre x de requêtes et définir le nombre de requêtes enfants qui doivent correspondre à au moins un document.

Exemple de requête de disjonction :

mappings := bleve.NewIndexMapping()
index, err = bleve.NewUsing("/some/path/index.bleve", mappings, "scorch", "scorch", nil)
if err != nil {
    log.Fatal(err)
}

De la même manière que nous avons utilisé « searchParser » plus tôt, nous pouvons désormais transmettre la « requête de disjonction » au constructeur pour notre « searchRequest ».

Bien que ce ne soit pas exactement la même chose, cela ressemble au SQL suivant :

type Book struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Genre string `json:"genre"`
}

b := Book{
    ID:    1234,
    Name:  "Some creative title",
    Genre: "Young Adult",
}
idStr := fmt.Sprintf("%d", b.ID)
// index(string, interface{})
index.index(idStr, b)

Vous pouvez également ajuster le degré de flou souhaité pour la recherche en définissant "query.Fuzziness=[0 or 1 or 2]"

Exemple de requête de conjonction :

// You would also want to check if the batch exists already
// - so that you don't recreate it.
batch := index.NewBatch()
if batch.Size() >= 1000 {
    err := index.Batch(batch)
    if err != nil {
        // failed, try again or log etc...
    }
    batch = index.NewBatch()
} else {
    batch.index(idStr, b)
}

Vous remarquerez que la syntaxe est très similaire, vous pouvez simplement utiliser les requêtes « Conjonction » et « Disjonction » de manière interchangeable.

Cela ressemblera à ce qui suit en SQL :

searchParser := bleve.NewQueryStringQuery("chicken reciepe books")
maxPerPage := 50
ofsset := 0
searchRequest := bleve.NewSearchRequestOptions(searchParser, maxPerPage, offset, false)
// By default bleve returns just the ID, here we specify
// - all the other fields we would like to return.
searchRequest.Fields = []string{"id", "name", "genre"}
searchResults, err := index.Search(searchResult)

En résumé ; utilisez la « Requête de conjonction » lorsque vous souhaitez que toutes les requêtes enfants correspondent à au moins un document et la « Requête de disjonction » lorsque vous souhaitez faire correspondre au moins une requête enfant mais pas nécessairement toutes les requêtes enfants.

Partage

Si vous rencontrez des problèmes de vitesse, Bleve permet également de distribuer vos données sur plusieurs fragments d'index, puis d'interroger ces fragments en une seule requête, par exemple :

{
    "status": {
        "total": 5,
        "failed": 0,
        "successful": 5
    },
    "request": {},
    "hits": [],
    "total_hits": 19749,
    "max_score": 2.221337297308545,
    "took": 99039137,
    "facets": null
}

Le partage peut devenir assez complexe, mais comme vous le voyez ci-dessus, Bleve simplifie grandement la tâche, car il "fusionne" automatiquement tous les index et les recherches à travers eux, puis renvoie les résultats dans un seul ensemble de résultats, comme si vous recherchiez. un seul index.

J'utilise le sharding pour effectuer une recherche sur 100 fragments. L'ensemble du processus de recherche se termine en seulement 100 à 200 millisecondes en moyenne.

Vous pouvez créer des fragments comme suit :

//... build searchRequest -- see previous section.
// Add facets
genreFacet := bleve.NewFacetRequest("genre", 50)
searchRequest.AddFacet("genre", genreFacet)
searchResults, err := index.Search(searchResult)

Assurez-vous simplement de créer des identifiants uniques pour chaque document ou de disposer d'une sorte de moyen prévisible d'ajouter et de mettre à jour des documents sans gâcher l'index.

Un moyen simple de procéder consiste à stocker un préfixe contenant le nom du fragment dans votre base de données source, ou partout où vous obtenez les documents. Ainsi, chaque fois que vous essayez d'insérer ou de mettre à jour, vous recherchez le "préfixe" qui vous indiquera sur quel fragment appeler ".index".

En parlant de mise à jour, le simple fait d'appeler "index.index(idstr, struct)" mettra à jour un document existant.

Conclusion

En utilisant uniquement cette technique de recherche de base ci-dessus et en la plaçant derrière GIN ou le serveur HTTP Go standard, vous pouvez créer une API de recherche assez puissante et répondre à des millions de requêtes sans avoir à déployer une infrastructure complexe.

Une mise en garde cependant ; Bleve ne prend cependant pas en charge la réplication, car vous pouvez l'intégrer dans une API. Créez simplement une tâche cron qui lit votre source et « diffuse » une mise à jour sur tous vos serveurs Bleve à l'aide de goroutines.

Alternativement, vous pouvez simplement verrouiller l'écriture sur le disque pendant quelques secondes, puis simplement "rsync" les données vers les index esclaves, bien que je ne vous conseille pas de le faire car vous devrez probablement également redémarrer le binaire go à chaque fois. .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!