groonga-client-rails 0.9.0

data/lib/groonga/client/searcher.rb

@@ -0,0 +1,165 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga/client"
+
+require "groonga/client/searcher/error"
+require "groonga/client/searcher/select"
+require "groonga/client/searcher/schema"
+require "groonga/client/searcher/schema_synchronizer"
+require "groonga/client/searcher/source"
+
+module Groonga
+  class Client
+    class Searcher
+      class << self
+        def schema
+          @schema ||= Schema.new(default_table_name)
+        end
+
+        def source(model_class)
+          sources[model_class] ||= create_source(model_class)
+        end
+
+        def sync
+          sync_schema
+          sync_records
+        end
+
+        def sync_schema
+          current_schema = Client.open do |client|
+            client.schema
+          end
+          syncher = SchemaSynchronizer.new(schema, current_schema)
+          syncher.sync
+        end
+
+        def sync_records
+          ensure_model_classes_loaded
+          sources.each do |model_class, definition|
+            all_records = model_class.all
+            if all_records.respond_to?(:find_each)
+              enumerator = all_records.find_each
+            else
+              enumerator = all_records.each
+            end
+            searcher = new
+            enumerator.each do |model|
+              searcher.upsert(model)
+            end
+          end
+        end
+
+        private
+        def sources
+          @sources ||= {}
+        end
+
+        def create_source(model_class)
+          source = Source.new(schema, model_class)
+
+          searcher_class = self
+          model_class.after_create do |model|
+            searcher = searcher_class.new
+            searcher.create(model)
+          end
+
+          model_class.after_update do |model|
+            searcher = searcher_class.new
+            searcher.update(model)
+          end
+
+          model_class.after_destroy do |model|
+            searcher = searcher_class.new
+            searcher.destroy(model)
+          end
+
+          source
+        end
+
+        def default_table_name
+          name.gsub(/Searcher\z/, "").tableize
+        end
+
+        def ensure_model_classes_loaded
+          ::Rails.application.eager_load!
+        end
+      end
+
+      def inititalize
+      end
+
+      def upsert(model)
+        source = self.class.source(model.class)
+        record = {}
+        source.columns.each do |name, reader|
+          case reader
+          when Symbol
+            value = model.__send__(reader)
+          when TrueClass
+            value = model.__send__(name)
+          when NilClass
+            next
+          else
+            value = reader.call(model)
+          end
+          record[name] = value
+        end
+        record["_key"] = model_key(model)
+        Client.open do |client|
+          client.load(:table => self.class.schema.table,
+                      :values => [record])
+        end
+      end
+
+      def create(model)
+        upsert(model)
+      end
+
+      def update(model)
+        upsert(model)
+      end
+
+      def destroy(model)
+        Client.open do |client|
+          client.delete(table: self.class.schema.table,
+                        key: model_key(model))
+        end
+      end
+
+      def search
+        select
+      end
+
+      def select
+        schema = self.class.schema
+        full_text_searchable_column_names = []
+        schema.columns.each do |name, column|
+          if column.have_full_text_search_index?
+            full_text_searchable_column_names << name
+          end
+        end
+        Select::Request.new(schema.table).
+          match_columns(full_text_searchable_column_names)
+      end
+
+      private
+      def model_key(model)
+        "#{model.class.name}-#{model.id}"
+      end
+    end
+  end
+end

data/lib/groonga/client/searcher/error.rb

@@ -0,0 +1,37 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    class Searcher
+      class Error < Client::Error
+      end
+
+      class ErrorResponse < Error
+        attr_reader :response
+        def initialize(response)
+          @response = response
+          command = @response.command
+          status_code = @response.status_code
+          error_message = @response.error_message
+          message = "failed to execute: #{command.name}: #{status_code}: "
+          message << "<#{error_message}>"
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/searcher/raw_request.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    class Searcher
+      class RawRequest
+        def initialize(command_name, parameters=nil)
+          @command_name = command_name
+          @parameters = parameters
+        end
+
+        def response
+          @reponse ||= Client.open do |client|
+            response = client.execute(@command_name, to_parameters)
+            raise ErrorResponse.new(response) unless response.success?
+            response
+          end
+        end
+
+        def parameter(name, value)
+          add_parameter(OverwriteMerger,
+                        RequestParameter.new(name, value))
+        end
+
+        def to_parameters
+          if @parameters.nil?
+            {}
+          else
+            @parameters.to_parameters
+          end
+        end
+
+        private
+        def add_parameter(merger_class, parameter)
+          merger = merger_class.new(@parameters, parameter)
+          create_request(merger)
+        end
+
+        def create_request(parameters)
+          self.class.new(@command_name, parameters)
+        end
+      end
+
+      class RequestParameter
+        def initialize(name, value)
+          @name = name
+          @value = value
+        end
+
+        def to_parameters
+          {
+            @name => @value,
+          }
+        end
+      end
+
+      class ParameterMerger
+        def initialize(parameters1, parameters2)
+          @parameters1 = parameters1
+          @parameters2 = parameters2
+        end
+      end
+
+      class OverwriteMerger < ParameterMerger
+        def to_parameters
+          @parameters1.to_parameters.merge(@parameters2.to_parameters)
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/searcher/schema.rb

@@ -0,0 +1,74 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    class Searcher
+      class Schema
+        attr_reader :table
+        attr_reader :columns
+        def initialize(table)
+          @table = table
+          @columns = {}
+        end
+
+        def table=(name)
+          name = name.to_s if name.is_a?(Symbol)
+          @table = name
+        end
+
+        def column(name, options)
+          name = normalize_name(name)
+          @columns[name] = Column.new(name, options)
+        end
+
+        def have_column?(name)
+          name = normalize_name(name)
+          @columns.key?(name)
+        end
+
+        private
+        def normalize_name(name)
+          if name.is_a?(Symbol)
+            name.to_s
+          else
+            name
+          end
+        end
+
+        class Column
+          attr_reader :name
+          def initialize(name, options)
+            @name = name
+            @options = options
+          end
+
+          def type
+            @options[:type] || "Text"
+          end
+
+          def have_index?
+            @options[:index]
+          end
+
+          def have_full_text_search_index?
+            have_index? and @options[:index_type] == :full_text_search
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/searcher/schema_synchronizer.rb

@@ -0,0 +1,137 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Groonga
+  class Client
+    class Searcher
+      class SchemaSynchronizer
+        def initialize(schema, current_schema)
+          @schema = schema
+          @current_schema = current_schema
+        end
+
+        def sync
+          sync_table
+          sync_columns
+        end
+
+        private
+        def sync_table
+          current_table = find_current_table
+          return if current_table # TODO: validation
+
+          Client.open do |client|
+            client.table_create(:name => @schema.table,
+                                :flags => "TABLE_PAT_KEY",
+                                :key_type => "ShortText")
+          end
+        end
+
+        def sync_columns
+          current_columns = find_current_columns
+          @schema.columns.each do |_, column|
+            sync_column(column, current_columns[column.name])
+          end
+        end
+
+        def sync_column(column, current_column)
+          if current_column.nil?
+            Client.open do |client|
+              client.column_create(:table => @schema.table,
+                                   :name => column.name,
+                                   :type => column.type)
+            end
+          end
+
+          sync_column_index(column, current_column)
+        end
+
+        def sync_column_index(column, current_column)
+          if column.have_index?
+            lexicon_name = "lexicon_#{@schema.table}_#{column.name}"
+            index_column_name = "index"
+            if current_column
+              indexes = current_column.indexes
+            else
+              indexes = []
+            end
+            indexes.each do |index|
+              return if index.full_name == "#{lexicon_name}.#{index_column_name}"
+            end
+            sync_lexicon(column, lexicon_name)
+            create_index_column(column, lexicon_name, index_column_name)
+          else
+            remove_indexes(current_column)
+          end
+        end
+
+        def sync_lexicon(column, lexicon_name)
+          return if @current_schema.tables[lexicon_name]
+
+          parameters = {
+            :name => lexicon_name,
+            :flags => "TABLE_PAT_KEY",
+          }
+          if column.have_full_text_search_index?
+            parameters[:key_type] = "ShortText"
+            parameters[:default_tokenizer] = "TokenBigram"
+            parameters[:normalizer] = "NormalizerAuto"
+          else
+            parameters[:key_type] = column.type
+          end
+          Client.open do |client|
+            client.table_create(parameters)
+          end
+        end
+
+        def create_index_column(column, lexicon_name, index_column_name)
+          flags = "COLUMN_INDEX"
+          flags += "|WITH_POSITION" if column.have_full_text_search_index?
+          Client.open do |client|
+            client.column_create(:table => lexicon_name,
+                                 :name => index_column_name,
+                                 :flags => flags,
+                                 :type => @schema.table,
+                                 :source => column.name)
+          end
+        end
+
+        def remove_indexes(current_column)
+          return if current_column.nil?
+          current_column.indexes.each do |index|
+            Client.open do |client|
+              clinet.column_remove(:table => index.table.name,
+                                   :name => index.name)
+            end
+          end
+        end
+
+        def find_current_table
+          @current_schema.tables[@schema.table]
+        end
+
+        def find_current_columns
+          current_table = find_current_table
+          if current_table.nil?
+            {}
+          else
+            current_table.columns
+          end
+        end
+      end
+    end
+  end
+end