groonga-client-rails 0.9.0

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

@@ -0,0 +1,18 @@
+# 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/searcher/select/request"
+require "groonga/client/searcher/select/result_set"

data/lib/groonga/client/searcher/select/request.rb

@@ -0,0 +1,266 @@
+# 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 "active_support/core_ext/object/blank"
+
+require "groonga/client/searcher/raw_request"
+
+module Groonga
+  class Client
+    class Searcher
+      module Select
+        class Request < RawRequest
+          def initialize(table_or_parameters)
+            if table_or_parameters.respond_to?(:to_parameters)
+              parameters = table_or_parameters
+            else
+              table_name = table_or_parameters
+              parameters = RequestParameter.new(:table, table_name)
+            end
+            super("select", parameters)
+          end
+
+          def result_set
+            @result_set ||= ResultSet.new(response)
+          end
+
+          def match_columns(value)
+            add_parameter(OverwriteMerger,
+                          MatchColumnsParameter.new(value))
+          end
+
+          def query(value)
+            add_parameter(QueryMerger,
+                          RequestParameter.new(:query, value))
+          end
+
+          def filter(expression, values=nil)
+            add_parameter(FilterMerger,
+                          FilterParameter.new(expression, values))
+          end
+
+          def output_columns(value)
+            add_parameter(OverwriteMerger,
+                          OutputColumnsParameter.new(value))
+          end
+
+          def sortby(value)
+            add_parameter(OverwriteMerger,
+                          SortbyParameter.new(value))
+          end
+          alias_method :sort, :sortby
+
+          def offset(value)
+            parameter(:offset, value)
+          end
+
+          def limit(value)
+            parameter(:limit, value)
+          end
+
+          def paginate(page, per_page: 10)
+            page ||= 1
+            page = page.to_i
+            return self if page < 0
+
+            offset(per_page * page).limit(per_page)
+          end
+
+          private
+          def create_request(parameters)
+            self.class.new(parameters)
+          end
+        end
+
+        # @private
+        class QueryMerger < ParameterMerger
+          def to_parameters
+            params1 = @parameters1.to_parameters
+            params2 = @parameters2.to_parameters
+            params = params1.merge(params2)
+            query1 = params1[:query]
+            query2 = params2[:query]
+            if query1.present? and query2.present?
+              params[:query] = "(#{query1}) (#{query2})"
+            else
+              params[:query] = (query1 || query2)
+            end
+            params
+          end
+        end
+
+        # @private
+        class FilterMerger < ParameterMerger
+          def to_parameters
+            params1 = @parameters1.to_parameters
+            params2 = @parameters2.to_parameters
+            params = params1.merge(params2)
+            filter1 = params1[:filter]
+            filter2 = params2[:filter]
+            if filter1.present? and filter2.present?
+              params[:filter] = "(#{filter1}) && (#{filter2})"
+            else
+              params[:filter] = (filter1 || filter2)
+            end
+            params
+          end
+        end
+
+        # @private
+        class MatchColumnsParameter
+          def initialize(match_columns)
+            @match_columns = match_columns
+          end
+
+          def to_parameters
+            if @match_columns.blank?
+              {}
+            else
+              case @match_columns
+              when ::Array
+                match_columns = @match_columns.join(", ")
+              when Symbol
+                match_columns = @match_columns.to_s
+              else
+                match_columns = @match_columns
+              end
+              {
+                match_columns: match_columns,
+              }
+            end
+          end
+        end
+
+        # @private
+        class FilterParameter
+          def initialize(expression, values)
+            @expression = expression
+            @values = values
+          end
+
+          def to_parameters
+            if @expression.blank?
+              {}
+            else
+              if @values.blank?
+                expression = @expression
+              else
+                escaped_values = {}
+                @values.each do |key, value|
+                  escaped_values[key] = escape_filter_value(value)
+                end
+                expression = @expression % escaped_values
+              end
+              {
+                filter: expression,
+              }
+            end
+          end
+
+          private
+          def escape_filter_value(value)
+            case value
+            when Numeric
+              value
+            when TrueClass, FalseClass
+              value
+            when NilClass
+              "null"
+            when String
+              ScriptSyntax.format_string(value)
+            when Symbol
+              ScriptSyntax.format_string(value.to_s)
+            when ::Array
+              escaped_value = "["
+              value.each_with_index do |element, i|
+                escaped_value << ", " if i > 0
+                escaped_value << escape_filter_value(element)
+              end
+              escaped_value << "]"
+              escaped_value
+            when ::Hash
+              escaped_value = "{"
+              value.each_with_index do |(k, v), i|
+                escaped_value << ", " if i > 0
+                escaped_value << escape_filter_value(k.to_s)
+                escaped_value << ": "
+                escaped_value << escape_filter_value(v)
+              end
+              escaped_value << "}"
+              escaped_value
+            else
+              value
+            end
+          end
+        end
+
+        # @private
+        class OutputColumnsParameter
+          def initialize(output_columns)
+            @output_columns = output_columns
+          end
+
+          def to_parameters
+            if @output_columns.blank?
+              {}
+            else
+              case @output_columns
+              when ::Array
+                output_columns = @output_columns.join(", ")
+              when Symbol
+                output_columns = @output_columns.to_s
+              else
+                output_columns = @output_columns
+              end
+              parameters = {
+                output_columns: output_columns,
+              }
+              if output_columns.include?("(")
+                parameters[:command_version] = "2"
+              end
+              parameters
+            end
+          end
+        end
+
+        # @private
+        class SortbyParameter
+          def initialize(sortby)
+            @sortby = sortby
+          end
+
+          def to_parameters
+            if @sortby.blank?
+              {}
+            else
+              case @sortby
+              when ::Array
+                sortby = @sortby.collect(&:to_s).join(", ")
+              when Symbol
+                sortby = @sortby.to_s
+              else
+                sortby = @sortby
+              end
+              {
+                sortby: sortby,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/searcher/select/result_set.rb

@@ -0,0 +1,117 @@
+# 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
+      module Select
+        class ResultSet
+          def initialize(response)
+            @response = response
+          end
+
+          def n_hits
+            @response.n_hits
+          end
+          # For Kaminari
+          alias_method :total_count, :n_hits
+
+          # For Kaminari
+          def limit_value
+            (@response.command[:limit] || 10).to_i
+          end
+
+          # For Kaminari
+          def offset_value
+            (@response.command[:offset] || 0).to_i
+          end
+
+          def records
+            @records ||= build_records
+          end
+
+          def sources
+            @sources ||= fetch_sources
+          end
+
+          def drilldowns
+            @response.drilldowns
+          end
+
+          private
+          def build_records
+            @response.records.collect.with_index do |record, i|
+              Record.new(self, i, record)
+            end
+          end
+
+          def fetch_sources
+            source_ids = {}
+            records.collect do |record|
+              model_name, id = record["_key"].split(/-/, 2)
+              source_ids[model_name] ||= []
+              source_ids[model_name] << id
+            end
+            sources = {}
+            source_ids.each do |model_name, ids|
+              model_name.constantize.find(ids).each_with_index do |model, i|
+                sources["#{model_name}-#{ids[i]}"] = model
+              end
+            end
+            records.collect do |record|
+              sources[record["_key"]]
+            end
+          end
+
+          class Record
+            def initialize(result_set, nth, raw_record)
+              @result_set = result_set
+              @nth = nth
+              @raw_record = raw_record
+            end
+
+            def source
+              @result_set.sources[@nth]
+            end
+
+            def [](name)
+              @raw_record[normalize_name(name)]
+            end
+
+            def method_missing(name, *args, &block)
+              return super unless args.empty?
+              return super unless @raw_record.key?(name.to_s)
+
+              self[name]
+            end
+
+            def respond_to_missing?(name, *args, &block)
+              return super unless args.empty?
+              return super unless @raw_record.key?(name.to_s)
+
+              @raw_record.key?(normalize_name(name))
+            end
+
+            private
+            def normalize_name(name)
+              name.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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 Source
+        attr_reader :model_class
+        attr_reader :columns
+        def initialize(schema, model_class)
+          @schema = schema
+          @model_class = model_class
+          @columns = {}
+        end
+
+        def []=(name, reader)
+          unless @schema.have_column?(name)
+            message = "unknown column name: #{name.inspect}"
+            available_columns = @schema.columns.keys.join(", ")
+            message << "available columns: [#{available_columns}]"
+            raise ArgumentError, message
+          end
+          @columns[name.to_s] = reader
+        end
+
+        def method_missing(name, *args, &block)
+          return super unless name.to_s.end_with?("=")
+
+          base_name = name.to_s[0..-2]
+          if @schema.have_column?(base_name)
+            __send__(:[]=, base_name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, include_private)
+          return super unless name.to_s.end_with?("=")
+
+          base_name = name.to_s[0..-2]
+          @schema.have_column?(base_name)
+        end
+      end
+    end
+  end
+end