rroonga 4.0.8-x64-mingw32 → 5.0.0-x64-mingw32

data/test/test-table.rb

@@ -630,188 +630,6 @@ class TableTest < Test::Unit::TestCase
     assert_not_predicate(bookmarks, :builtin?)
   end
 
-  class GroupTest < self
-    class MaxNSubRecordsTest < self
-      setup
-      def setup_schema
-        Groonga::Schema.define do |schema|
-          schema.create_table("Bookmarks", :type => :hash) do |table|
-            table.text("title")
-          end
-
-          schema.create_table("Comments", :type => :array) do |table|
-            table.reference("bookmark")
-            table.text("content")
-            table.int32("rank")
-          end
-        end
-      end
-
-      setup
-      def setup_data
-        setup_bookmarks
-        setup_comments
-      end
-
-      def setup_bookmarks
-        @bookmarks = Groonga["Bookmarks"]
-        @groonga = @bookmarks.add("http://groonga.org/", :title => "groonga")
-        @ruby = @bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
-      end
-
-      def setup_comments
-        @comments = Groonga["Comments"]
-        @comments.add(:bookmark => @groonga,
-                      :content => "garbage comment1",
-                      :rank => 0)
-        @comments.add(:bookmark => @groonga,
-                      :content => "garbage comment2",
-                      :rank => 0)
-        @comments.add(:bookmark => @groonga,
-                      :content => "full-text search",
-                      :rank => 1)
-        @comments.add(:bookmark => @groonga,
-                      :content => "column store",
-                      :rank => 5)
-        @comments.add(:bookmark => @ruby,
-                      :content => "object oriented script language",
-                      :rank => 100)
-        @comments.add(:bookmark => @ruby,
-                      :content => "multi paradigm programming language",
-                      :rank => 80)
-      end
-
-      setup
-      def setup_searched
-        @records = @comments.select do |record|
-          record.rank > 0
-        end
-      end
-
-      def test_upper_limit
-        grouped_records = @records.group("bookmark", :max_n_sub_records => 2)
-        groups = grouped_records.collect do |record|
-          sub_record_contents = record.sub_records.collect do |sub_record|
-            sub_record.content
-          end
-          [record.title, sub_record_contents]
-        end
-        assert_equal([
-                       [
-                         "groonga",
-                         [
-                           "full-text search",
-                           "column store",
-                         ],
-                       ],
-                       [
-                         "Ruby",
-                         [
-                           "object oriented script language",
-                           "multi paradigm programming language",
-                         ],
-                       ],
-                     ],
-                     groups)
-      end
-
-      def test_less_than_limit
-        sorted = @records.sort([{:key => "rank", :order => :descending}],
-                               :limit => 3, :offset => 0)
-        grouped_records = sorted.group("bookmark", :max_n_sub_records => 2)
-        groups = grouped_records.collect do |record|
-          sub_record_ranks = record.sub_records.collect do |sub_record|
-            sub_record.rank
-          end
-          [record.title, sub_record_ranks]
-        end
-        assert_equal([
-                       ["Ruby", [100, 80]],
-                       ["groonga", [5]]
-                     ],
-                     groups)
-      end
-    end
-
-    class KeyTest < self
-      setup
-      def setup_schema
-        Groonga::Schema.define do |schema|
-          schema.create_table("Bookmarks", :type => :hash) do |table|
-            table.text("title")
-          end
-
-          schema.create_table("Comments", :type => :array) do |table|
-            table.reference("bookmark")
-            table.text("content")
-            table.int32("rank")
-          end
-        end
-      end
-
-      setup
-      def setup_data
-        setup_bookmarks
-        setup_comments
-      end
-
-      def setup_bookmarks
-        @bookmarks = Groonga["Bookmarks"]
-        @groonga = @bookmarks.add("http://groonga.org/", :title => "groonga")
-        @ruby = @bookmarks.add("http://ruby-lang.org/", :title => "Ruby")
-      end
-
-      def setup_comments
-        @comments = Groonga["Comments"]
-        @comments.add(:bookmark => @groonga,
-                      :content => "full-text search")
-        @comments.add(:bookmark => @groonga,
-                      :content => "column store")
-        @comments.add(:bookmark => @ruby,
-                      :content => "object oriented script language")
-      end
-
-      def test_string
-        grouped_records = @comments.group("bookmark").collect do |record|
-          bookmark = record.key
-          [
-            record.n_sub_records,
-            bookmark["title"],
-            bookmark.key,
-          ]
-        end
-        assert_equal([
-                       [2, "groonga", "http://groonga.org/"],
-                       [1, "Ruby", "http://ruby-lang.org/"],
-                     ],
-                     grouped_records)
-      end
-
-      def test_array
-        grouped_records = @comments.group(["bookmark"]).collect do |record|
-          bookmark = record.key
-          [
-            record.n_sub_records,
-            bookmark["title"],
-            bookmark.key,
-          ]
-        end
-        assert_equal([
-                       [2, "groonga", "http://groonga.org/"],
-                       [1, "Ruby", "http://ruby-lang.org/"],
-                     ],
-                     grouped_records)
-      end
-
-      def test_nonexistent
-        message = "unknown group key: <\"nonexistent\">: <#{@comments.inspect}>"
-        assert_raise(ArgumentError.new(message)) do
-          @comments.group("nonexistent")
-        end
-      end
-    end
-  end
-
   class OtherProcessTest < self
     def test_create
       by_other_process do

data/vendor/local/bin/mecab-config

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-prefix=/home/kou/work/c/groonga.clean/packages/windows/dist-x64
+prefix=/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x64
 exec_prefix=${prefix}
 exec_prefix_set=no
 
@@ -107,7 +107,7 @@ while test $# -gt 0; do
 	;;
 
     --libexecdir)
-       	echo /home/kou/work/c/groonga.clean/packages/windows/dist-x64/libexec/mecab
+       	echo /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x64/libexec/mecab
        	;;
 	
     --sysconfdir)

data/vendor/local/bin/onig-config

@@ -27,7 +27,7 @@ if test $# -eq 0; then
   show_usage
 fi
 
-prefix=/home/kou/work/c/groonga.clean/packages/windows/dist-x64
+prefix=/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x64
 exec_prefix=${prefix}
 is_set_exec_prefix=no
 

data/vendor/local/etc/groonga/httpd/groonga-httpd.conf

@@ -15,7 +15,7 @@ http {
   keepalive_timeout 65;
 
   # The default groonga database path.
-  groonga_database /home/kou/work/c/groonga.clean/packages/windows/dist-x64/var/lib/groonga/db/db;
+  groonga_database /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x64/var/lib/groonga/db/db;
 
   # Create a groonga database automatically if the groonga database doesn't
   # exist.
@@ -45,7 +45,7 @@ http {
     }
 
     location / {
-      root /home/kou/work/c/groonga.clean/packages/windows/dist-x64/share/groonga/html/admin;
+      root /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x64/share/groonga/html/admin;
       index index.html;
     }
 

data/vendor/local/include/groonga/groonga.h

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2014 Brazil
+  Copyright(C) 2014-2015 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -21,6 +21,7 @@
 #include "groonga/groonga.h"
 #include "groonga/ii.h"
 #include "groonga/expr.h"
+#include "groonga/output.h"
 #include "groonga/util.h"
 #include "groonga/request_canceler.h"
 

data/vendor/local/include/groonga/groonga/command.h

@@ -0,0 +1,79 @@
+/* -*- c-basic-offset: 2 -*- */
+/*
+  Copyright(C) 2015 Brazil
+
+  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef GROONGA_COMMAND_H
+#define GROONGA_COMMAND_H
+
+#include <groonga/plugin.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+typedef struct _grn_command_input grn_command_input;
+
+GRN_PLUGIN_EXPORT grn_command_input *grn_command_input_open(grn_ctx *ctx,
+                                                            grn_obj *command);
+GRN_PLUGIN_EXPORT grn_rc grn_command_input_close(grn_ctx *ctx,
+                                                 grn_command_input *input);
+
+GRN_PLUGIN_EXPORT grn_obj *grn_command_input_add(grn_ctx *ctx,
+                                                 grn_command_input *input,
+                                                 const char *name,
+                                                 int name_size,
+                                                 grn_bool *added);
+GRN_PLUGIN_EXPORT grn_obj *grn_command_input_get(grn_ctx *ctx,
+                                                 grn_command_input *input,
+                                                 const char *name,
+                                                 int name_size);
+GRN_PLUGIN_EXPORT grn_obj *grn_command_input_at(grn_ctx *ctx,
+                                                grn_command_input *input,
+                                                unsigned int offset);
+
+typedef void grn_command_run_func(grn_ctx *ctx,
+                                  grn_obj *command,
+                                  grn_command_input *input,
+                                  void *user_data);
+
+/*
+  grn_command_register() registers a command to the database which is
+  associated with `ctx'. `command_name' and `command_name_size'
+  specify the command name. Alphabetic letters ('A'-'Z' and 'a'-'z'),
+  digits ('0'-'9') and an underscore ('_') are capable characters.
+
+  `run' is called for running the command.
+
+  grn_command_register() returns GRN_SUCCESS on success, an error
+  code on failure.
+ */
+GRN_PLUGIN_EXPORT grn_rc grn_command_register(grn_ctx *ctx,
+                                              const char *command_name,
+                                              int command_name_size,
+                                              grn_command_run_func *run,
+                                              grn_expr_var *vars,
+                                              unsigned int n_vars,
+                                              void *user_data);
+
+GRN_PLUGIN_EXPORT grn_rc grn_command_run(grn_ctx *ctx,
+                                         grn_obj *command,
+                                         grn_command_input *input);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */
+
+#endif  /* GROONGA_COMMAND_H */

data/vendor/local/include/groonga/groonga/groonga.h

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2009-2014 Brazil
+  Copyright(C) 2009-2015 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -119,6 +119,8 @@ typedef enum {
   GRN_UNSUPPORTED_COMMAND_VERSION = -71,
   GRN_NORMALIZER_ERROR = -72,
   GRN_TOKEN_FILTER_ERROR = -73,
+  GRN_COMMAND_ERROR = -74,
+  GRN_PLUGIN_ERROR = -75,
 } grn_rc;
 
 GRN_API grn_rc grn_init(void);
@@ -709,6 +711,15 @@ typedef enum {
 } grn_operator;
 
 GRN_API const char *grn_operator_to_string(grn_operator op);
+GRN_API grn_bool grn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_not_equal(grn_ctx *ctx,
+                                             grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_greater(grn_ctx *ctx, grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_less_equal(grn_ctx *ctx,
+                                              grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx,
+                                                 grn_obj *x, grn_obj *y);
 
 struct _grn_table_group_result {
   grn_obj *table;
@@ -717,6 +728,8 @@ struct _grn_table_group_result {
   int limit;
   grn_table_group_flags flags;
   grn_operator op;
+  unsigned int max_n_subrecs;
+  grn_obj *calc_target;
 };
 
 GRN_API grn_rc grn_table_group(grn_ctx *ctx, grn_obj *table,
@@ -749,6 +762,14 @@ GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
 #define GRN_COLUMN_NAME_SCORE_LEN     (sizeof(GRN_COLUMN_NAME_SCORE) - 1)
 #define GRN_COLUMN_NAME_NSUBRECS      "_nsubrecs"
 #define GRN_COLUMN_NAME_NSUBRECS_LEN  (sizeof(GRN_COLUMN_NAME_NSUBRECS) - 1)
+#define GRN_COLUMN_NAME_MAX           "_max"
+#define GRN_COLUMN_NAME_MAX_LEN       (sizeof(GRN_COLUMN_NAME_MAX) - 1)
+#define GRN_COLUMN_NAME_MIN           "_min"
+#define GRN_COLUMN_NAME_MIN_LEN       (sizeof(GRN_COLUMN_NAME_MIN) - 1)
+#define GRN_COLUMN_NAME_SUM           "_sum"
+#define GRN_COLUMN_NAME_SUM_LEN       (sizeof(GRN_COLUMN_NAME_SUM) - 1)
+#define GRN_COLUMN_NAME_AVG           "_avg"
+#define GRN_COLUMN_NAME_AVG_LEN       (sizeof(GRN_COLUMN_NAME_AVG) - 1)
 
 GRN_API grn_obj *grn_column_create(grn_ctx *ctx, grn_obj *table,
                                    const char *name, unsigned int name_size,
@@ -1253,81 +1274,10 @@ GRN_API grn_rc grn_text_printf(grn_ctx *ctx, grn_obj *bulk,
 GRN_API grn_rc grn_text_vprintf(grn_ctx *ctx, grn_obj *bulk,
                                 const char *format, va_list args);
 
-typedef struct _grn_obj_format grn_obj_format;
-
-#define GRN_OBJ_FORMAT_WITH_COLUMN_NAMES   (0x01<<0)
-#define GRN_OBJ_FORMAT_AS_ARRAY            (0x01<<3)
-/* Deprecated since 4.0.1. It will be removed at 5.0.0.
-   Use GRN_OBJ_FORMAT_AS_ARRAY instead.*/
-#define GRN_OBJ_FORMAT_ASARRAY             GRN_OBJ_FORMAT_AS_ARRAY
-#define GRN_OBJ_FORMAT_WITH_WEIGHT         (0x01<<4)
-
-struct _grn_obj_format {
-  grn_obj columns;
-  const void *min;
-  const void *max;
-  unsigned int min_size;
-  unsigned int max_size;
-  int nhits;
-  int offset;
-  int limit;
-  int hits_offset;
-  int flags;
-  grn_obj *expression;
-};
-
-#define GRN_OBJ_FORMAT_INIT(format,format_nhits,format_offset,format_limit,format_hits_offset) do { \
-  GRN_PTR_INIT(&(format)->columns, GRN_OBJ_VECTOR, GRN_ID_NIL);\
-  (format)->nhits = (format_nhits);\
-  (format)->offset = (format_offset);\
-  (format)->limit = (format_limit);\
-  (format)->hits_offset = (format_hits_offset);\
-  (format)->flags = 0;\
-  (format)->expression = NULL;\
-} while (0)
-
-#define GRN_OBJ_FORMAT_FIN(ctx,format) do {\
-  int ncolumns = GRN_BULK_VSIZE(&(format)->columns) / sizeof(grn_obj *);\
-  grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&(format)->columns);\
-  while (ncolumns--) { grn_obj_unlink((ctx), *columns++); }\
-  GRN_OBJ_FIN((ctx), &(format)->columns);\
-  if ((format)->expression) { GRN_OBJ_FIN((ctx), (format)->expression); } \
-} while (0)
-
-GRN_API void grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
-                            grn_obj *obj, grn_obj_format *format);
-GRN_API void grn_output_envelope(grn_ctx *ctx, grn_rc rc,
-                                 grn_obj *head, grn_obj *body, grn_obj *foot,
-                                 const char *file, int line);
-
-GRN_API void grn_ctx_output_array_open(grn_ctx *ctx,
-                                       const char *name, int nelements);
-GRN_API void grn_ctx_output_array_close(grn_ctx *ctx);
-GRN_API void grn_ctx_output_map_open(grn_ctx *ctx,
-                                     const char *name, int nelements);
-GRN_API void grn_ctx_output_map_close(grn_ctx *ctx);
-GRN_API void grn_ctx_output_int32(grn_ctx *ctx, int value);
-GRN_API void grn_ctx_output_int64(grn_ctx *ctx, long long int value);
-GRN_API void grn_ctx_output_float(grn_ctx *ctx, double value);
-GRN_API void grn_ctx_output_cstr(grn_ctx *ctx, const char *value);
-GRN_API void grn_ctx_output_str(grn_ctx *ctx,
-                                const char *value, unsigned int value_len);
-GRN_API void grn_ctx_output_bool(grn_ctx *ctx, grn_bool value);
-GRN_API void grn_ctx_output_obj(grn_ctx *ctx,
-                                grn_obj *value, grn_obj_format *format);
-
-
-GRN_API grn_content_type grn_ctx_get_output_type(grn_ctx *ctx);
-GRN_API grn_rc grn_ctx_set_output_type(grn_ctx *ctx, grn_content_type type);
-GRN_API const char *grn_ctx_get_mime_type(grn_ctx *ctx);
 GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
                                       void (*func)(grn_ctx *, int, void *),
                                       void *func_arg);
 
-/* obsolete */
-GRN_API grn_rc grn_text_otoj(grn_ctx *ctx, grn_obj *bulk, grn_obj *obj,
-                             grn_obj_format *format);
-
 /* various values exchanged via grn_obj */
 
 #define GRN_OBJ_DO_SHALLOW_COPY        (GRN_OBJ_REFER|GRN_OBJ_OUTPLACE)
@@ -1910,9 +1860,10 @@ GRN_API grn_rc grn_pat_delete(grn_ctx *ctx, grn_pat *pat, const void *key, unsig
 GRN_API int grn_pat_delete_with_sis(grn_ctx *ctx, grn_pat *pat, grn_id id,
                                     grn_table_delete_optarg *optarg);
 
-typedef struct _grn_pat_scan_hit grn_pat_scan_hit;
+typedef struct _grn_table_scan_hit grn_pat_scan_hit;
+typedef struct _grn_table_scan_hit grn_dat_scan_hit;
 
-struct _grn_pat_scan_hit {
+struct _grn_table_scan_hit {
   grn_id id;
   unsigned int offset;
   unsigned int length;
@@ -1965,6 +1916,13 @@ GRN_API grn_rc grn_pat_cursor_delete(grn_ctx *ctx, grn_pat_cursor *c,
 typedef struct _grn_dat grn_dat;
 typedef struct _grn_dat_cursor grn_dat_cursor;
 
+GRN_API int grn_dat_scan(grn_ctx *ctx, grn_dat *dat, const char *str,
+                         unsigned int str_size, grn_dat_scan_hit *scan_hits,
+                         unsigned int max_num_scan_hits, const char **str_rest);
+
+GRN_API grn_id grn_dat_lcp_search(grn_ctx *ctx, grn_dat *dat,
+                          const void *key, unsigned int key_size);
+
 GRN_API grn_dat *grn_dat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
                                 unsigned int value_size, unsigned int flags);