Wie wäre es mit einer Volltextsuche? Also habe ich versucht, Groonga zu benutzen. 　→ Groonga

Volltextsuche

"Volltextsuche" ist auf sehr einfache Weise wie "Google-Suche". Geben Sie Schlüsselwörter ein, um aus vielen Dokumenten das gewünschte zu finden.

Es scheint verschiedene zu geben

Wenn Sie also zunächst Google nach dem "Volltextsuchsystem" fragen, werden Sie verschiedene Dinge finden.

Fess
Elasticsearch
Apache Solr
Namazu
Groonga

etc Ich dachte, ich hätte Namazu vermisst, aber als ich es mir ansah, schien Groonga gut zu sein, also entschied ich mich, es zu benutzen.

Installation

Da es sich um eine lokale Umgebung handelte, habe ich beschlossen, sie mit Docker-Compose zu installieren. # Es ist auch im offiziellen Dokument geschrieben. .. ..

Ich habe es so versucht, wie es offiziell geschrieben ist

→ Groonga#with-docker-compose

Oh, es ist auf jeden Fall leicht aufgestanden. Starten Sie zur Bestätigung den Browser und geben Sie "http: // localhost: 10041" ein. Eine Seite wird angezeigt.

Ich habe versucht, es hochzuladen, um ein Bild einzufügen, aber egal wie oft ich es ausprobiert habe, ich wurde wie folgt wütend. Bitte ergänzen Sie es in Ihrem Gehirn (stellen Sie es sich vor). .. ..

Something went wrong

Aber. .. ..

% docker-compose run groonga Wenn ja, wird es fallen, es sei denn, das Terminal bleibt offen. Wenn ich dann versuche, es erneut zu starten und "% docker-compose restart" sage, ist die Datendatei dieses Mal bereits vorhanden. Fehler. .. ..

Der Grund dafür ist, dass der Befehl `-n` in`: [" -n "," /mnt/db/data.db "]` eine Option zum Erstellen einer neuen Datendatei ist. Jedes Mal, wenn ich versuche, eine neue zu erstellen, werde ich wütend. Ich tat.

Mumumu.

Also habe ich eine Docker-Datei erstellt und versucht, sie zu starten

Bitte beziehen Sie sich auf die Quelle auf Github.

Ich werde es kurz erklären. Erstens unter / groonga.

Konfigurationseinstellungen usw. sind in "docker-compose.yml" beschrieben. Ich versuche es aus ./groonga/Dockerfile mit build :. / Groonga zu generieren. Verwenden Sie "Volumes", um die Datendatei auch auf dem Host-Computer sichtbar zu machen.

Der Rest von xxxx.sh fühlt sich wie ein nützliches Werkzeug an. Bei der Installation führt $. / Install.sh so etwas wie Docker-Compose-Build aus. Wenn Sie den Docker-Prozess aufrufen möchten, geben Sie ihn mit ". / Login.sh" ein. Verwenden Sie in diesem Fall ` exitzum Beenden. Der Stopp ist "$. / Stop.sh" und der Neustart ist "$. / Restart.sh". Wenn Sie den Docker-Prozess nicht mehr benötigen, erstellen Sie einenDocker-RM-Container mit $. / Remove.sh`.

Als nächstes unter / groonga / groonga. Die Docker-Datei enthält spezifische Anweisungen zur Erstellung.

Es scheint etwas Buggy zu geben

Wenn Sie groonga normal installieren und über http darauf zugreifen, wird von Zeit zu Zeit möglicherweise eine Fehlermeldung angezeigt. Als ich es im Internet nachgeschlagen habe, habe ich den folgenden Artikel gefunden. 　→ https://okamuuu.hatenablog.com/entry/2017/11/13/185903

Okamuuu Danke.

Aber dieser Artikel war im Jahr 2017 und hat immer noch den gleichen Fehler im Jahr 2020. .. ..

Stack-fix.c ist also ein Patch. Ich habe die mit dem Dockerfile geschrieben. Um den "Fehler beim Erstellen einer neuen Datei beim Neustart" zu vermeiden, habe ich ein Startskript geschrieben, eine Datendatei erstellt, wenn sie nicht vorhanden war, und sie verwendet, wenn sie vorhanden war. Es ist groonga.sh.

Installieren Sie erneut

Also, $. / Install.sh.

Gehen Sie zu "http: // localhost: 10041" und ja. Es ist fertig.

Beginnen wir mit Ruby.

Es scheint verschiedene Möglichkeiten zu geben, Groonga aus Rubin zu verwenden. Rroonga ist berühmt, aber es sieht aus wie eine Bibliothek, wenn Groonga auf demselben Server ausgeführt wird. Es sieht aus wie ein Groonga-Client, wenn er auf Docker oder einem anderen Server (einschließlich virtuell) ausgeführt wird.

Also installieren.

Installation oder Probe

groonga-client ist $ gem install groonga-client Sie können es mit installieren.

Ich habe das folgende Beispiel ausgeführt.

`test.rb`


# -*- coding: utf-8 -*-
require "groonga/client"

host = "127.0.0.1"
port = 10041
Groonga::Client.open(host: host, port: port, protocol: :http) do |client|
  tables = client.table_list
  unless tables.map{|m| m.name}.include?("docs")
    # ---- create normal table ----
    client.table_create(name: "docs",
                        flags: "TABLE_HASH_KEY",
                        key_type: "ShortText")
    client.column_create(table: "docs",
                         name: "body",
                         flags: "COLUMN_SCALAR",
                         type: "Text")

    # ---- data insert to table ----
    values = [
      { "_key" => "/path/to/document/1",
        "body" => "Meros war wütend." },
      { "_key" => "/path/to/document/2",
        "body" => "Meros versteht Politik nicht." },
      { "_key" => "/path/to/document/3",
        "body" => "Meros hatte einen Freund von Takema." },      
    ]   
    client.load(table: "docs",
                values: values.to_json)
  end

  # ---- data search ----
  query = "verliere das Temperament"
  response = client.select(table: "docs",
                           query: query,
                           match_columns: "body")
  puts "hits: #{response.n_hits} (query: #{query} -> body)"
  response.records.each do |record|
    p record
  end

  query = "Politik"
  response = client.select(table: "docs",
                           query: "body:@#{query}")
  puts "hits: #{response.n_hits} (query: #{query} -> body)"
  response.records.each do |record|
    p record
  end

  filter = "/path/to/document/3"
  response = client.select(table: "docs",
                           filter: "_key == '#{filter}'")
  puts "hits: #{response.n_hits} (filter: #{filter} -> _key)"
  response.records.each do |record|
    p record
  end
  query = "/document"
  response = client.select(table: "docs",
                           query: "_key:@#{query}")
  puts "hits: #{response.n_hits} (query: #{query} -> _key)"
  response.records.each do |record|
    p record
  end

end

Dann ausführen.

$ ruby ./test.rb
hits: 1 (query:verliere das Temperament-> body)
{"_id"=>1, "_key"=>"/path/to/document/1", "body"=>"Meros war wütend."}
hits: 1 (query:Politik-> body)
{"_id"=>2, "_key"=>"/path/to/document/2", "body"=>"Meros versteht Politik nicht."}
hits: 1 (filter: /path/to/document/3 -> _key)
{"_id"=>3, "_key"=>"/path/to/document/3", "body"=>"Meros hatte einen Freund von Takema."}
hits: 3 (query: /document -> _key)
{"_id"=>1, "_key"=>"/path/to/document/1", "body"=>"Meros war wütend."}
{"_id"=>2, "_key"=>"/path/to/document/2", "body"=>"Meros versteht Politik nicht."}
{"_id"=>3, "_key"=>"/path/to/document/3", "body"=>"Meros hatte einen Freund von Takema."}

Es sieht gut aus.

Ich habe versucht, eine Abfrage auf zwei Arten zu schreiben, indem ich nach "Wut" und "Politik" gesucht habe. Verwenden Sie match_columns und schreiben Sie like column: @ query. Welches ist vorerst in Ordnung?

.. .. .. Ich meine, als ich die Tabelle erstellt habe, habe ich keinen Tokenizer oder ähnliches festgelegt und keine Indextabelle erstellt, aber ich kann die Körperspalte als "% rage%" durchsuchen. .. .. Ist das eine Abfrage? .. ..

Ich meine, es sieht so aus. Ja.

Ich habe versucht, eine Indextabelle zu erstellen

Also habe ich eine Indextabelle erstellt. Es scheint, dass die Suchzeit sehr schnell sein wird, wenn Sie dies machen.

`test2.rb`


# -*- coding: utf-8 -*-
require "groonga/client"

host = "127.0.0.1"
port = 10041
Groonga::Client.open(host: host, port: port, protocol: :http) do |client|
  tables = client.table_list
  unless tables.map{|m| m.name}.include?("doc_indexes")
    # ---- create indexes ----
    client.table_create(name: "doc_indexes",
                        flags: "TABLE_PAT_KEY",
                        key_type: "ShortText",
                        default_tokenizer: "TokenBigram",
                        normalizer: "NormalizerAuto")
    client.column_create(table: "doc_indexes",
                         name: "body_index",
                         flags: "COLUMN_INDEX|WITH_POSITION",
                         type: "docs",
                         source: "body")
  end

  query = "Ich weiß es nicht"
  response = client.select(table: "docs",
                           query: query,
                           match_columns: "doc_indexes.body_index")
  puts "hits: #{response.n_hits} (query: #{query} -> doc_indexes.body_index)"
  response.records.each do |record|
    p record
  end  
end

Bei Ausführung mit

$ ruby ./test2.rb
hits: 1 (query:Ich weiß es nicht-> doc_indexes.body_index)
{"_id"=>2, "_key"=>"/path/to/document/2", "body"=>"Meros versteht Politik nicht."}

Ich hab es geschafft. Vielleicht ist dies der richtige Weg. .. ..

Umm.

Über Groonga

Oh ja, ich habe das Wichtige vergessen. groonga ist ein Datenbanksystem, das für die Volltextsuche optimiert ist. Es unterscheidet sich also ein wenig von den RDB und KVS, die ich ständig benutze, daher ist es schwierig, sich daran zu gewöhnen.

Mit RDB können Sie Spalten erstellen, die beim Erstellen einer Tabelle als Schlüssel verwendet werden, Spalten, in denen Daten gespeichert werden usw. Groonga verfügt jedoch über eine Schlüsselstruktur und eine Funktion für die Volltextsuche, wenn Sie zum ersten Mal eine Tabelle erstellen. Wird angegeben und Spalten werden später zur Tabelle hinzugefügt. Auch das Erstellen eines Index und das Suchen ist ein einzigartiger Eindruck. Ich denke, es wird praktisch sein, wenn Sie es meistern können.

das ist alles.

[RUBY] Es ist neu, aber ich habe versucht, Groonga zu verwenden