groonga-client 0.5.8 → 0.6.3

data/lib/groonga/client/protocol/file.rb

@@ -0,0 +1,76 @@
+# Copyright (C) 2017  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/version"
+require "groonga/client/protocol/error"
+
+module Groonga
+  class Client
+    module Protocol
+      class File
+        def initialize(url, options)
+          @url = url
+          @options = options
+        end
+
+        def send(command, &block)
+          open_pipes do |input, output, error|
+            options = {
+              :in => input[0],
+              :out => output[1],
+              :err => error[1],
+            }
+            pid = spawn("groonga", @url.path, options)
+            input[0].close
+            output[1].close
+            error[1].close
+
+            input[1].puts(command.to_command_format)
+            input[1].close
+            response = output[0].read
+            Process.waitpid(pid)
+            yield(response)
+            EmptyRequest.new
+          end
+        end
+
+        def connected?
+          false
+        end
+
+        def close(&block)
+          if block_given?
+            yield
+            EmptyRequest.new
+          else
+            false
+          end
+        end
+
+        private
+        def open_pipes
+          IO.pipe do |input|
+            IO.pipe do |output|
+              IO.pipe do |error|
+                yield(input, output, error)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groonga/client/protocol/http/path-resolvable.rb

@@ -21,7 +21,12 @@ module Groonga
         module PathResolvable
           private
           def resolve_path(uri, path)
-            uri.path.chomp("/") + path
+            path_prefix = uri.path.chomp("/")
+            if path_prefix.empty?
+              path
+            else
+              path.sub(/\A\/d/) {path_prefix}
+            end
           end
         end
       end

data/lib/groonga/client/protocol/http/synchronous.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013  Haruka Yoshihara <yoshihara@clear-code.com>
-# Copyright (C) 2013-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2020  Sutou Kouhei <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
@@ -55,9 +55,15 @@ module Groonga
             @options = options
           end
 
+          DEBUG = (ENV["GROONGA_CLIENT_HTTP_DEBUG"] == "yes")
           def send(command)
             begin
-              HTTPClient.start(@url.host, @url.port, start_options) do |http|
+              http = HTTPClient.new(@url.host, @url.port)
+              http.set_debug_output($stderr) if DEBUG
+              start_options.each do |key, value|
+                http.__send__("#{key}=", value)
+              end
+              http.start do
                 http.read_timeout = read_timeout
                 response = send_request(http, command)
                 case response
@@ -141,18 +147,7 @@ module Groonga
 
           def send_request(http, command)
             if command.is_a?(Groonga::Command::Load)
-              raw_values = command[:values]
-              command[:values] = nil
-              path = resolve_path(@url, command.to_uri_format)
-              command[:values] = raw_values
-              request = Net::HTTP::Post.new(path, headers)
-              request.content_type = "application/json"
-              if @options[:chunk]
-                request["Transfer-Encoding"] = "chunked"
-              else
-                request.content_length = raw_values.bytesize
-              end
-              request.body_stream = StringIO.new(raw_values)
+              request = prepare_load_request(command)
             else
               path = resolve_path(@url, command.to_uri_format)
               request = Net::HTTP::Get.new(path, headers)
@@ -167,6 +162,42 @@ module Groonga
             }
           end
 
+          def prepare_load_request(command)
+            path_prefix = command.path_prefix
+            command = command.class.new(command.command_name,
+                                        command.arguments,
+                                        [])
+            command.path_prefix = path_prefix
+            case @options[:load_input_type]
+            when "apache-arrow"
+              command[:input_type] = "apache-arrow"
+              content_type = "application/x-apache-arrow-streaming"
+              arrow_table = command.build_arrow_table
+              if arrow_table
+                buffer = Arrow::ResizableBuffer.new(1024)
+                arrow_table.save(buffer, format: :stream)
+                body = buffer.data.to_s
+              else
+                body = ""
+              end
+              command.arguments.delete(:values)
+            else
+              content_type = "application/json"
+              body = command.arguments.delete(:values)
+            end
+            command[:lock_table] = "yes" if @options[:load_lock_table]
+            path = resolve_path(@url, command.to_uri_format)
+            request = Net::HTTP::Post.new(path, headers)
+            if @options[:chunk]
+              request["Transfer-Encoding"] = "chunked"
+            else
+              request.content_length = body.bytesize
+            end
+            request.content_type = content_type
+            request.body_stream = StringIO.new(body)
+            request
+          end
+
           def setup_authentication(request)
             userinfo = @url.userinfo
             return if userinfo.nil?

data/lib/groonga/client/response.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2014-2019  Sutou Kouhei <kou@clear-code.com>
 # Copyright (C) 2013  Haruka Yoshihara <yoshihara@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -30,6 +30,8 @@ require "groonga/client/response/lock-clear"
 require "groonga/client/response/log-level"
 require "groonga/client/response/log-put"
 require "groonga/client/response/log-reopen"
+require "groonga/client/response/logical-range-filter"
+require "groonga/client/response/logical-select"
 require "groonga/client/response/quit"
 require "groonga/client/response/register"
 require "groonga/client/response/schema"

data/lib/groonga/client/response/base.rb

@@ -1,7 +1,5 @@
-# -*- coding: utf-8 -*-
-#
 # Copyright (C) 2013  Haruka Yoshihara <yoshihara@clear-code.com>
-# Copyright (C) 2013-2014  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2018  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
@@ -17,9 +15,14 @@
 # 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 "csv"
 require "rexml/document"
 require "json"
 
+begin
+  require "arrow"
+rescue LoadError
+end
 require "hashie"
 
 module Groonga
@@ -66,7 +69,13 @@ module Groonga
             return_code = nil
             case command.output_type
             when :json
-              response = JSON.parse(raw_response)
+              callback = command["callback"]
+              if callback and
+                  /\A#{Regexp.escape(callback)}\((.+)\);\z/ =~ raw_response
+                response = JSON.parse($1)
+              else
+                response = JSON.parse(raw_response)
+              end
               if response.is_a?(::Array)
                 header, body = response
                 return_code = header[0] if header
@@ -78,6 +87,12 @@ module Groonga
             when :xml
               header, body = parse_xml(raw_response)
               return_code = header[0] if header
+            when :tsv
+              header, body = parse_tsv(raw_response)
+              return_code = header["return_code"] if header
+            when :arrow, :"apache-arrow"
+              header, body = parse_apache_arrow(raw_response)
+              return_code = header["return_code"] if header
             else
               header = nil
               body = raw_response
@@ -129,6 +144,80 @@ module Groonga
               end
             end
           end
+
+          def parse_tsv(response)
+            tsv = CSV.new(response, col_sep: "\t")
+            raw_header = tsv.shift
+            return nil, nil if raw_header.nil?
+
+            header = parse_tsv_header(raw_header)
+            return header, nil unless header["return_code"].zero?
+
+            body = parse_tsv_body(tsv)
+            [header, body]
+          end
+
+          def parse_tsv_header(raw_header)
+            header = {
+              "return_code" => Integer(raw_header[0], 10),
+              "start_time" => Float(raw_header[1]),
+              "elapsed_time" => Float(raw_header[2]),
+            }
+            if raw_header.size >= 4
+              header["error"] = {
+                "message" => raw_header[3],
+              }
+              if raw_header.size >= 5
+                header["error"]["function"] = raw_header[4]
+                header["error"]["file"] = raw_header[5]
+                header["error"]["line"] = Integer(raw_header[6])
+              end
+            end
+            header
+          end
+
+          def parse_tsv_body(tsv)
+            body = []
+            tsv.each do |row|
+              break if row.size == 1 and row[0] == "END"
+              body << row
+            end
+            body
+          end
+
+          def parse_apache_arrow(response)
+            header = nil
+            body = nil
+            buffer = Arrow::Buffer.new(response)
+            Arrow::BufferInputStream.open(buffer) do |input|
+              while input.tell < response.bytesize
+                reader = Arrow::RecordBatchStreamReader.new(input)
+                schema = reader.schema
+                record_batches = reader.to_a
+                if apache_arrow_metadata?(schema)
+                  table = Arrow::Table.new(schema, record_batches)
+                  header = table.each_record.first.to_h
+                else
+                  body = {}
+                  body["columns"] = schema.fields.collect do |field|
+                    [field.name, field.data_type.to_s]
+                  end
+                  if record_batches.empty?
+                    records = []
+                  else
+                    table = Arrow::Table.new(schema, record_batches)
+                    records = table.raw_records
+                  end
+                  body["records"] = records
+                end
+              end
+            end
+            return header, body
+          end
+
+          def apache_arrow_metadata?(schema)
+            (schema.metadata || {})["GROONGA:data_type"] == "metadata"
+          end
         end
 
         # @return [Groonga::Command] The command for the request.

data/lib/groonga/client/response/drilldownable.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2019  Sutou Kouhei <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
+    module Response
+      module Drilldownable
+        # @return [::Array<Groonga::Client::Response::Select::Drilldown>,
+        #          ::Hash<String, Groonga::Client::Response::Select::Drilldown>]
+        #   If labeled drilldowns are used or command version 3 or
+        #   later is used, `{"label1" => drilldown1, "label2" => drilldown2}`
+        #   is returned since 0.3.1.
+        #
+        #   Otherwise, `[drilldown1, drilldown2]` is returned.
+        attr_accessor :drilldowns
+
+        private
+        def parse_drilldown(label, keys, raw_drilldown)
+          if raw_drilldown.is_a?(::Array)
+            n_hits = raw_drilldown[0][0]
+            raw_columns = raw_drilldown[1]
+            raw_records = raw_drilldown[2..-1]
+          else
+            n_hits = raw_drilldown["n_hits"]
+            raw_columns = raw_drilldown["columns"]
+            raw_records = raw_drilldown["records"]
+          end
+          records = parse_records(raw_columns, raw_records)
+          Drilldown.new(label,
+                        keys,
+                        n_hits,
+                        records,
+                        raw_columns,
+                        raw_records)
+        end
+
+        def parse_drilldowns(keys, raw_drilldowns)
+          (raw_drilldowns || []).collect.with_index do |raw_drilldown, i|
+            key = keys[i]
+            parse_drilldown(key, [key], raw_drilldown)
+          end
+        end
+
+        def parse_labeled_drilldowns(labeled_drilldown_requests,
+                                     raw_drilldowns)
+          drilldowns = {}
+          (raw_drilldowns || {}).each do |label, raw_drilldown|
+            labeled_drilldown_request = labeled_drilldown_requests[label]
+            drilldowns[label] = parse_drilldown(label,
+                                                labeled_drilldown_request.keys,
+                                                raw_drilldown)
+          end
+          drilldowns
+        end
+
+        class Drilldown < Struct.new(:label,
+                                     :keys,
+                                     :n_hits,
+                                     :records,
+                                     :raw_columns,
+                                     :raw_records)
+          # @deprecated since 0.2.6. Use {#records} instead.
+          alias_method :items, :records
+
+          def key
+            keys.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,10 +20,50 @@ module Groonga
   class Client
     module Response
       class Error < Base
-        # @return [String] The error message of the error response.
+        # @return [String, nil] The error message of the error response.
+        #
         # @since 0.1.0
         def message
-          (header || [0, 0, 0.0, ""])[3]
+          error_message
+        end
+
+        # @return [String, nil] The function name where the error is occurred.
+        #
+        # @since 0.5.9
+        def function
+          if header.nil?
+            nil
+          elsif header_v1?
+            header[4]
+          else
+            (header["error"] || {})["function"]
+          end
+        end
+
+        # @return [String, nil] The file name where the error is occurred.
+        #
+        # @since 0.5.9
+        def file
+          if header.nil?
+            nil
+          elsif header_v1?
+            header[5]
+          else
+            (header["error"] || {})["file"]
+          end
+        end
+
+        # @return [String, nil] The line where the error is occurred.
+        #
+        # @since 0.5.9
+        def line
+          if header.nil?
+            nil
+          elsif header_v1?
+            header[5]
+          else
+            (header["error"] || {})["line"]
+          end
         end
       end
     end