droonga-engine 1.0.1

data/lib/droonga/plugins/groonga/select.rb

@@ -0,0 +1,236 @@
+# Copyright (C) 2013-2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/plugin"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module Select
+        DRILLDOWN_RESULT_PREFIX = "drilldown_result_"
+
+        class RequestConverter
+          def convert(select_request)
+            @table = select_request["table"]
+            @result_name = @table + "_result"
+
+            output_columns = select_request["output_columns"] || ""
+            attributes = output_columns.split(/, */)
+            offset = (select_request["offset"] || "0").to_i
+            limit = (select_request["limit"] || "10").to_i
+
+            output_offset = offset
+            output_limit = limit
+
+            sort_by = nil
+            sort_keys = (select_request["sortby"] || "").split(",")
+            unless sort_keys.empty?
+              sort_by = {
+                "keys" => sort_keys,
+                "offset" => offset,
+                "limit" => limit,
+              }
+              output_offset = 0
+            end
+
+            search_request = {
+              "queries" => {
+                @result_name => {
+                  "source" => @table,
+                  "output" => {
+                    "elements"   => [
+                      "startTime",
+                      "elapsedTime",
+                      "count",
+                      "attributes",
+                      "records",
+                    ],
+                    "attributes" => attributes,
+                    "offset" => output_offset,
+                    "limit" => output_limit,
+                  },
+                }
+              }
+            }
+            if sort_by
+              search_request["queries"][@result_name]["sortBy"] = sort_by
+            end
+
+            condition = convert_condition(select_request)
+            if condition
+              search_request["queries"][@result_name]["condition"] = condition
+            end
+
+            drilldown_queries = convert_drilldown(select_request)
+            if drilldown_queries
+              search_request["queries"].merge!(drilldown_queries)
+            end
+
+            search_request
+          end
+
+          def convert_condition(select_request)
+            match_columns = select_request["match_columns"]
+            match_to = match_columns ? match_columns.split(/ *\|\| */) : []
+            query = select_request["query"]
+            filter = select_request["filter"]
+
+            conditions = []
+            if query
+              conditions << {
+                "query"  => query,
+                "matchTo"=> match_to,
+                "defaultOperator"=> "&&",
+                "allowPragma"=> false,
+                "allowColumn"=> true,
+              }
+            end
+
+            if filter
+              conditions << filter
+            end
+
+            condition = nil
+
+            case conditions.size
+            when 1
+              condition = conditions.first
+            when 2
+              condition = ["&&"] + conditions
+            end
+
+            condition
+          end
+
+          def convert_drilldown(select_request)
+            drilldown_keys = select_request["drilldown"]
+            return nil if drilldown_keys.nil? or drilldown_keys.empty?
+
+            drilldown_keys = drilldown_keys.split(",")
+
+            sort_keys = (select_request["drilldown_sortby"] || "").split(",")
+            columns   = (select_request["drilldown_output_columns"] || "").split(",")
+            offset    = (select_request["drilldown_offset"] || "0").to_i
+            limit     = (select_request["drilldown_limit"] || "10").to_i
+
+            queries = {}
+            drilldown_keys.each_with_index do |key, index|
+              query = {
+                "source" => @result_name,
+                "groupBy" => key,
+                "output" => {
+                  "elements"   => [
+                    "count",
+                    "attributes",
+                    "records",
+                  ],
+                  "attributes" => columns,
+                  "limit" => limit,
+                },
+              }
+
+              if sort_keys.empty?
+                query["output"]["offset"] = offset
+              else
+                query["sortBy"] = {
+                  "keys"   => sort_keys,
+                  "offset" => offset,
+                  "limit"  => limit,
+                }
+              end
+
+              queries["#{DRILLDOWN_RESULT_PREFIX}#{key}"] = query
+            end
+            queries
+          end
+        end
+
+        class ResponseConverter
+          def convert(search_response)
+            @drilldown_results = []
+            search_response.each do |key, value|
+              if key.start_with?(DRILLDOWN_RESULT_PREFIX)
+                key = key[DRILLDOWN_RESULT_PREFIX.size..-1]
+                convert_drilldown_result(key, value)
+              else
+                convert_main_result(value)
+              end
+            end
+
+            select_results = [@body] + @drilldown_results
+            [@header, select_results]
+          end
+
+          private
+          def convert_main_result(result)
+            status_code = 0
+            start_time = result["startTime"]
+            start_time_in_unix_time = if start_time
+                                        Time.parse(start_time).to_f
+                                      else
+                                        Time.now.to_f
+                                      end
+            elapsed_time = result["elapsedTime"] || 0
+            @header = [status_code, start_time_in_unix_time, elapsed_time]
+            @body = convert_search_result(result)
+          end
+
+          def convert_drilldown_result(key, result)
+            @drilldown_results << convert_search_result(result)
+          end
+
+          def convert_search_result(result)
+            count      = result["count"]
+            attributes = convert_attributes(result["attributes"])
+            records    = result["records"]
+            if records.nil? or records.empty?
+              [[count], attributes]
+            else
+              [[count], attributes, records]
+            end
+          end
+
+          def convert_attributes(attributes)
+            attributes = attributes || []
+            attributes.collect do |attribute|
+              name = attribute["name"]
+              type = attribute["type"]
+              [name, type]
+            end
+          end
+        end
+
+        class Adapter < Droonga::Adapter
+          input_message.pattern = ["type", :equal, "select"]
+
+          def adapt_input(input_message)
+            converter = RequestConverter.new
+            select_request = input_message.body
+            search_request = converter.convert(select_request)
+            input_message.type = "search"
+            input_message.body = search_request
+          end
+
+          def adapt_output(output_message)
+            converter = ResponseConverter.new
+            search_response = output_message.body
+            select_response = converter.convert(search_response)
+            output_message.body = select_response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/droonga/plugins/groonga/table_create.rb

@@ -0,0 +1,111 @@
+# Copyright (C) 2013-2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "groonga/command/table-create"
+
+require "droonga/plugin"
+require "droonga/plugins/groonga/generic_command"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module TableCreate
+        class Command < GenericCommand
+          def process_request(request)
+            command_class = ::Groonga::Command.find("table_create")
+            @command = command_class.new("table_create", request)
+
+            name = @command["name"]
+            unless name
+              message = "Should not create anonymous table"
+              raise CommandError.new(:status => Status::INVALID_ARGUMENT,
+                                     :message => message,
+                                     :result => false)
+            end
+
+            options = parse_command
+            ::Groonga::Schema.define(:context => @context) do |schema|
+              schema.create_table(name, options)
+            end
+            true
+          end
+
+          private
+          def parse_command
+            options = {}
+            parse_flags(options)
+            parse_key_type(options)
+            parse_value_type(options)
+            parse_default_tokenizer(options)
+            parse_normalizer(options)
+            options
+          end
+
+          def parse_flags(options)
+            options[:type] = :hash
+            if @command.table_no_key?
+              options[:type] = :array
+            elsif @command.table_hash_key?
+              options[:type] = :hash
+            elsif @command.table_pat_key?
+              options[:type] = :patricia_trie
+            elsif @command.table_dat_key?
+              options[:type] = :double_array_trie
+            end
+            if @command.key_with_sis? and @command.table_pat_key?
+              options[:key_with_sis] = true
+            end
+          end
+
+          def parse_key_type(options)
+            return unless @command["key_type"]
+            options[:key_type] = @command["key_type"]
+          end
+
+          def parse_value_type(options)
+            return unless @command["value_type"]
+            options[:value_type] = @command["value_type"]
+          end
+
+          def parse_default_tokenizer(options)
+            return unless @command["default_tokenizer"]
+            options[:default_tokenizer] = @command["default_tokenizer"]
+          end
+
+          def parse_normalizer(options)
+            return unless @command["normalizer"]
+            options[:normalizer] = @command["normalizer"]
+          end
+        end
+
+        class Handler < Droonga::Handler
+          action.synchronous = true
+
+          def handle(message)
+            command = Command.new(@context)
+            command.execute(message.request)
+          end
+        end
+
+        Groonga.define_single_step do |step|
+          step.name = "table_create"
+          step.write = true
+          step.handler = Handler
+          step.collector = Collectors::Or
+        end
+      end
+    end
+  end
+end

data/lib/droonga/plugins/groonga/table_list.rb

@@ -0,0 +1,120 @@
+# Copyright (C) 2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/plugin"
+require "droonga/plugins/groonga/generic_command"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module TableList
+        HEADER = [
+          ["id",                "UInt32"],
+          ["name",              "ShortText"],
+          ["path",              "ShortText"],
+          ["flags",             "ShortText"],
+          ["domain",            "ShortText"],
+          ["range",             "ShortText"],
+          ["default_tokenizer", "ShortText"],
+          ["normalizer",        "ShortText"],
+        ].freeze
+
+        class Command < GenericCommand
+          def process_request(request)
+            [HEADER, *list_tables]
+          end
+
+          private
+          def list_tables
+            @context.database.tables.collect do |table|
+              format_table(table)
+            end
+          end
+
+          def format_table(table)
+            [
+              table.id,
+              table.name,
+              table.path,
+              table_flags(table),
+              domain_name(table),
+              range_name(table),
+              default_tokenizer_name(table),
+              normalizer_name(table),
+            ]
+          end
+
+          def table_flags(table)
+            flags = []
+            case table
+            when ::Groonga::Array
+              flags << "TABLE_NO_KEY"
+            when ::Groonga::Hash
+              flags << "TABLE_HASH_KEY"
+            when ::Groonga::PatriciaTrie
+              flags << "TABLE_PAT_KEY"
+            when ::Groonga::DoubleArrayTrie
+              flags << "TABLE_DAT_KEY"
+            end
+            if table.domain
+              if table.is_a?(::Groonga::PatriciaTrie) and
+                   table.register_key_with_sis?
+                flags << "KEY_WITH_SIS"
+              end
+            end
+            flags << "PERSISTENT"
+            flags.join("|")
+          end
+
+          def domain_name(table)
+            return nil unless table.domain
+            table.domain.name
+          end
+
+          def range_name(table)
+            return nil unless table.range
+            table.range.name
+          end
+
+          def default_tokenizer_name(table)
+            return nil if table.is_a?(::Groonga::Array)
+            return nil unless table.default_tokenizer
+            table.default_tokenizer.name
+          end
+
+          def normalizer_name(table)
+            return nil if table.is_a?(::Groonga::Array)
+            return nil unless table.domain
+            return nil unless table.normalizer
+            table.normalizer.name
+          end
+        end
+
+        class Handler < Droonga::Handler
+          def handle(message)
+            command = Command.new(@context)
+            command.execute(message.request)
+          end
+        end
+
+        Groonga.define_single_step do |step|
+          step.name = "table_list"
+          step.handler = Handler
+          step.collector = Collectors::Or
+        end
+      end
+    end
+  end
+end

data/lib/droonga/plugins/groonga/table_remove.rb

@@ -0,0 +1,57 @@
+# Copyright (C) 2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "groonga/command/table-remove"
+
+require "droonga/plugin"
+require "droonga/plugins/groonga/generic_command"
+
+module Droonga
+  module Plugins
+    module Groonga
+      module TableRemove
+        class Command < GenericCommand
+          def process_request(request)
+            command_class = ::Groonga::Command.find("table_remove")
+            @command = command_class.new("table_remove", request)
+
+            name = valid_table_name("name")
+
+            ::Groonga::Schema.define(:context => @context) do |schema|
+              schema.remove_table(name)
+            end
+            true
+          end
+        end
+
+        class Handler < Droonga::Handler
+          action.synchronous = true
+
+          def handle(message)
+            command = Command.new(@context)
+            command.execute(message.request)
+          end
+        end
+
+        Groonga.define_single_step do |step|
+          step.name = "table_remove"
+          step.write = true
+          step.handler = Handler
+          step.collector = Collectors::Or
+        end
+      end
+    end
+  end
+end

data/lib/droonga/plugins/groonga.rb

@@ -0,0 +1,37 @@
+# Copyright (C) 2013-2014 Droonga Project
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require "droonga/plugin"
+
+module Droonga
+  module Plugins
+    module Groonga
+      extend Plugin
+      register("groonga")
+    end
+  end
+end
+
+require "droonga/plugins/groonga/generic_response"
+require "droonga/plugins/groonga/select"
+require "droonga/plugins/groonga/table_create"
+require "droonga/plugins/groonga/table_remove"
+require "droonga/plugins/groonga/table_list"
+require "droonga/plugins/groonga/column_create"
+require "droonga/plugins/groonga/column_remove"
+require "droonga/plugins/groonga/column_rename"
+require "droonga/plugins/groonga/column_list"
+require "droonga/plugins/groonga/delete"
+