rroonga 1.3.0-x86-mingw32 → 1.3.1-x86-mingw32

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

@@ -1,4 +1,5 @@
-/* Copyright(C) 2009-2011 Brazil
+/*
+  Copyright(C) 2009-2012 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -29,7 +30,7 @@ extern "C" {
 #endif /* defined(_WIN32) || defined(_WIN64) */
 #endif /* GRN_API */
 
-typedef unsigned grn_id;
+typedef unsigned int grn_id;
 typedef unsigned char grn_bool;
 
 #define GRN_ID_NIL                     (0x00)
@@ -549,7 +550,7 @@ GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
  * ctxが使用するdbからnameに対応するオブジェクトを検索して返す。
  * nameに一致するオブジェクトが存在しなければNULLを返す。
  **/
-GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, unsigned name_size);
+GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, unsigned int name_size);
 
 /**
  * grn_ctx_at:
@@ -602,7 +603,7 @@ GRN_API grn_obj *grn_ctx_at(grn_ctx *ctx, grn_id id);
  * nameに対応する新たなtype(型)をdbに定義する。
  **/
 
-GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned name_size,
+GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
                                  grn_obj_flags flags, unsigned int size);
 
 GRN_API grn_rc grn_plugin_register(grn_ctx *ctx, const char *name);
@@ -624,8 +625,8 @@ GRN_API const char *grn_plugin_get_suffix(void);
  **/
 
 typedef struct {
-  char *name;
-  unsigned name_size;
+  const char *name;
+  unsigned int name_size;
   grn_obj value;
 } grn_expr_var;
 
@@ -639,9 +640,9 @@ typedef enum {
 } grn_proc_type;
 
 GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
-                                 const char *name, unsigned name_size, grn_proc_type type,
+                                 const char *name, unsigned int name_size, grn_proc_type type,
                                  grn_proc_func *init, grn_proc_func *next, grn_proc_func *fin,
-                                 unsigned nvars, grn_expr_var *vars);
+                                 unsigned int nvars, grn_expr_var *vars);
 /**
  * grn_proc_vars:
  * @user_data: grn_proc_funcに渡されたuser_data
@@ -652,7 +653,7 @@ GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
  **/
 
 GRN_API grn_obj *grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
-                                   grn_expr_var **vars, unsigned *nvars, grn_obj **caller);
+                                   grn_expr_var **vars, unsigned int *nvars, grn_obj **caller);
 
 /*-------------------------------------------------------------
  * table操作のための関数
@@ -682,7 +683,7 @@ GRN_API grn_obj *grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
  * nameに対応する新たなtableをctxが使用するdbに定義する。
  **/
 GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
-                                  const char *name, unsigned name_size,
+                                  const char *name, unsigned int name_size,
                                   const char *path, grn_obj_flags flags,
                                   grn_obj *key_type, grn_obj *value_type);
 
@@ -703,17 +704,20 @@ GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
  **/
 /* TODO: int *added -> grn_bool *added */
 GRN_API grn_id grn_table_add(grn_ctx *ctx, grn_obj *table,
-                             const void *key, unsigned key_size, int *added);
+                             const void *key, unsigned int key_size, int *added);
 
 /**
  * grn_table_get:
- * @table: 対象table
- * @key: 検索key
+ * @table: The table or database
+ * @key: The record or object key to be found
  *
- * tableからkeyに対応するrecordを検索し、対応するIDを返す。
+ * It finds a record that has @key and returns ID of the
+ * found record. If @table is a database, it finds an object
+ * (table, column and so on) that has @key and returns ID of
+ * the found object.
  **/
 GRN_API grn_id grn_table_get(grn_ctx *ctx, grn_obj *table,
-                             const void *key, unsigned key_size);
+                             const void *key, unsigned int key_size);
 
 
 /**
@@ -737,7 +741,7 @@ GRN_API grn_id grn_table_at(grn_ctx *ctx, grn_obj *table, grn_id id);
  * longest common prefix searchを行い、対応するIDを返す。
  **/
 GRN_API grn_id grn_table_lcp_search(grn_ctx *ctx, grn_obj *table,
-                                    const void *key, unsigned key_size);
+                                    const void *key, unsigned int key_size);
 
 /**
  * grn_table_get_key:
@@ -765,7 +769,7 @@ GRN_API int grn_table_get_key(grn_ctx *ctx, grn_obj *table,
  * 対応するレコードが存在しない場合はGRN_INVALID_ARGUMENTを返す。
  **/
 GRN_API grn_rc grn_table_delete(grn_ctx *ctx, grn_obj *table,
-                                const void *key, unsigned key_size);
+                                const void *key, unsigned int key_size);
 
 /**
  * grn_table_delete_by_id:
@@ -909,8 +913,8 @@ typedef grn_obj grn_table_cursor;
  * tableに登録されているレコードを順番に取り出すためのカーソルを生成して返す。
  **/
 GRN_API grn_table_cursor *grn_table_cursor_open(grn_ctx *ctx, grn_obj *table,
-                                                const void *min, unsigned min_size,
-                                                const void *max, unsigned max_size,
+                                                const void *min, unsigned int min_size,
+                                                const void *max, unsigned int max_size,
                                                 int offset, int limit, int flags);
 
 /**
@@ -956,7 +960,7 @@ GRN_API int grn_table_cursor_get_value(grn_ctx *ctx, grn_table_cursor *tc, void
  * cursorのカレントレコードが存在しない場合はGRN_INVALID_ARGUMENTを返す。
  **/
 GRN_API grn_rc grn_table_cursor_set_value(grn_ctx *ctx, grn_table_cursor *tc,
-                                  void *value, int flags);
+                                          const void *value, int flags);
 
 /**
  * grn_table_cursor_delete:
@@ -1222,7 +1226,7 @@ GRN_API grn_rc grn_table_difference(grn_ctx *ctx, grn_obj *table1, grn_obj *tabl
  * カラムIDの数を返す。
  **/
 GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
-                              const char *name, unsigned name_size,
+                              const char *name, unsigned int name_size,
                               grn_obj *res);
 
 /**
@@ -1238,7 +1242,7 @@ GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
  * 例) 'col1' / 'col2.col3' / 'col2._id'
  **/
 GRN_API grn_obj *grn_obj_column(grn_ctx *ctx, grn_obj *table,
-                                const char *name, unsigned name_size);
+                                const char *name, unsigned int name_size);
 
 
 /**
@@ -1279,7 +1283,7 @@ GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
  * 一つのtableに同一のnameのcolumnを複数定義することはできない。
  **/
 GRN_API grn_obj *grn_column_create(grn_ctx *ctx, grn_obj *table,
-                                   const char *name, unsigned name_size,
+                                   const char *name, unsigned int name_size,
                                    const char *path, grn_obj_flags flags, grn_obj *type);
 
 #define GRN_COLUMN_OPEN_OR_CREATE(ctx,table,name,name_size,path,flags,type,column) \
@@ -1415,6 +1419,32 @@ GRN_API grn_bool grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj);
  **/
 GRN_API grn_obj *grn_obj_get_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value);
 
+/**
+ * grn_obj_get_values:
+ * @obj: 対象object
+ * @offset: 値を取得する範囲の開始位置となるレコードID
+ * @values: 値の配列がセットされる
+ *
+ * objに指定されたカラムについて、offsetに指定されたレコードIDを開始位置として、IDが連続
+ * するレコードに対応するカラム値が昇順に格納された配列へのポインタをvaluesにセットします。
+ * 取得できた件数が戻り値として返される。エラーが発生した場合は -1 が返されます。
+ * 注意: 値が固定長であるカラムのみがobjに指定できます。
+ *       範囲内のIDに対応するレコードが有効であるとは限りません。
+ *       delete操作を実行したことのあるテーブルに対しては、
+ *       grn_table_at()などによって各レコードの存否を別途確認しなければなりません。
+ **/
+GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values);
+
+#define GRN_COLUMN_EACH(ctx,column,id,value,block) do {\
+  int _n;\
+  grn_id id = 1;\
+  while ((_n = grn_obj_get_values(ctx, column, id, (void **)&value)) > 0) {\
+    for (; _n; _n--, id++, value++) {\
+      block\
+    }\
+  }\
+} while (0)
+
 /**
  * grn_obj_set_value:
  * @obj: 対象object
@@ -1467,7 +1497,8 @@ GRN_API grn_rc grn_obj_remove(grn_ctx *ctx, grn_obj *obj);
  * ctxが使用するdbにおいてobjに対応する名前をnameに更新する。
  * objは永続オブジェクトでなければならない。
  **/
-GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj, const char *name, unsigned name_size);
+GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj,
+                              const char *name, unsigned int name_size);
 
 /**
  * grn_table_rename:
@@ -1480,7 +1511,7 @@ GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj, const char *name, unsi
  * tableは永続オブジェクトでなければならない。
  **/
 GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,
-                                const char *name, unsigned name_size);
+                                const char *name, unsigned int name_size);
 
 /**
  * grn_column_rename:
@@ -1492,7 +1523,7 @@ GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,
  * columnは永続オブジェクトでなければならない。
  **/
 GRN_API grn_rc grn_column_rename(grn_ctx *ctx, grn_obj *column,
-                                 const char *name, unsigned name_size);
+                                 const char *name, unsigned int name_size);
 
 /**
  * grn_obj_close:
@@ -1783,6 +1814,28 @@ GRN_API grn_obj *grn_obj_open(grn_ctx *ctx, unsigned char type, grn_obj_flags fl
 GRN_API int grn_column_index(grn_ctx *ctx, grn_obj *column, grn_operator op,
                              grn_obj **indexbuf, int buf_size, int *section);
 
+
+/**
+ * grn_obj_delete_by_id:
+ * @db: The target database.
+ * @id: The object (table, column and so on) ID to be deleted.
+ * @removep: If GRN_TRUE, clear object cache and remove relation
+ *   between ID and key in database. Otherwise, just clear object cache.
+ *
+ * dbからidに対応するテーブルやカラムなどを削除します。mroonga向けに用意した内部APIです。
+ **/
+GRN_API grn_rc grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, grn_bool removep);
+
+/**
+ * grn_obj_path_by_id:
+ * @db: The target database.
+ * @id: The object (table, column and so on) ID to be deleted.
+ * @buffer: path string corresponding to the id will be set in this buffer.
+ *
+ * dbのidに対応するpathを返します。mroonga向けに用意した内部APIです。
+ **/
+GRN_API grn_rc grn_obj_path_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer);
+
 /* geo */
 
 typedef struct {
@@ -1791,31 +1844,6 @@ typedef struct {
 } grn_geo_point;
 
 
-/**
- * grn_geo_select_in_circle:
- * @index: the index column for TokyoGeoPoint or WGS84GeoPpoint type.
- * @center_point: the center point of the target circle. (ShortText, Text,
- * LongText, TokyoGeoPoint or WGS84GeoPoint)
- * @distance: the radius of the target circle (Int32,
- * UInt32, Int64, UInt64 or Float) or the point
- * on the circumference of the target circle. (ShortText, Text, LongText,
- * TokyoGeoPoint or WGS84GeoPoint)
- * @res: the table to store found record IDs. It must be
- * GRN_TABLE_HASH_KEY type table.
- * @op: the operator for matched records.
- *
- * It selects records that are in the circle specified by
- * @center_point and @distance from @center_point. Records
- * are searched by @index. Found records are added to @res
- * table with @op operation.
- **/
-GRN_API grn_rc grn_geo_select_in_circle(grn_ctx *ctx,
-                                        grn_obj *index,
-                                        grn_obj *center_point,
-                                        grn_obj *distance,
-                                        grn_obj *res,
-                                        grn_operator op);
-
 /**
  * grn_geo_select_in_rectangle:
  * @index: the index column for TokyoGeoPoint or WGS84GeoPpoint type.
@@ -2089,8 +2117,8 @@ struct _grn_obj_format {
   grn_obj columns;
   const void *min;
   const void *max;
-  unsigned min_size;
-  unsigned max_size;
+  unsigned int min_size;
+  unsigned int max_size;
   int nhits;
   int offset;
   int limit;
@@ -2385,7 +2413,7 @@ GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
   int _val = (int)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int));\
 } while (0)
 #define GRN_UINT32_PUT(ctx,obj,val) do {\
-  unsigned int _val = (unsigned  int)(val);\
+  unsigned int _val = (unsigned int)(val);\
   grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int));\
 } while (0)
 #define GRN_INT64_PUT(ctx,obj,val) do {\
@@ -2435,12 +2463,12 @@ GRN_API int grn_charlen(grn_ctx *ctx, const char *str, const char *end);
 
 /* expr */
 
-GRN_API grn_obj *grn_expr_create(grn_ctx *ctx, const char *name, unsigned name_size);
+GRN_API grn_obj *grn_expr_create(grn_ctx *ctx, const char *name, unsigned int name_size);
 GRN_API grn_rc grn_expr_close(grn_ctx *ctx, grn_obj *expr);
 GRN_API grn_obj *grn_expr_add_var(grn_ctx *ctx, grn_obj *expr,
-                                  const char *name, unsigned name_size);
+                                  const char *name, unsigned int name_size);
 GRN_API grn_obj *grn_expr_get_var(grn_ctx *ctx, grn_obj *expr,
-                                  const char *name, unsigned name_size);
+                                  const char *name, unsigned int name_size);
 GRN_API grn_obj *grn_expr_get_var_by_offset(grn_ctx *ctx, grn_obj *expr, unsigned int offset);
 
 GRN_API grn_obj *grn_expr_append_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
@@ -2448,7 +2476,7 @@ GRN_API grn_obj *grn_expr_append_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
 GRN_API grn_obj *grn_expr_append_const(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
                                        grn_operator op, int nargs);
 GRN_API grn_obj *grn_expr_append_const_str(grn_ctx *ctx, grn_obj *expr,
-                                           const char *str, unsigned str_size,
+                                           const char *str, unsigned int str_size,
                                            grn_operator op, int nargs);
 GRN_API grn_obj *grn_expr_append_const_int(grn_ctx *ctx, grn_obj *expr, int i,
                                            grn_operator op, int nargs);
@@ -2466,7 +2494,7 @@ GRN_API grn_obj *grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
                                   grn_obj *res, grn_operator op);
 
 GRN_API int grn_obj_columns(grn_ctx *ctx, grn_obj *table,
-                            const char *str, unsigned str_size, grn_obj *res);
+                            const char *str, unsigned int str_size, grn_obj *res);
 
 #define GRN_EXPR_CREATE_FOR_QUERY(ctx,table,expr,var) \
   if (((expr) = grn_expr_create((ctx), NULL, 0)) &&\
@@ -2485,7 +2513,7 @@ typedef unsigned int grn_expr_flags;
 #define GRN_EXPR_ALLOW_UPDATE          (0x08)
 
 GRN_API grn_rc grn_expr_parse(grn_ctx *ctx, grn_obj *expr,
-                              const char *str, unsigned str_size,
+                              const char *str, unsigned int str_size,
                               grn_obj *default_column, grn_operator default_mode,
                               grn_operator default_op, grn_expr_flags flags);
 
@@ -2497,17 +2525,17 @@ GRN_API grn_snip *grn_expr_snip(grn_ctx *ctx, grn_obj *expr, int flags,
                                 grn_snip_mapping *mapping);
 
 GRN_API grn_table_sort_key *grn_table_sort_key_from_str(grn_ctx *ctx,
-                                                        const char *str, unsigned str_size,
-                                                        grn_obj *table, unsigned *nkeys);
+                                                        const char *str, unsigned int str_size,
+                                                        grn_obj *table, unsigned int *nkeys);
 GRN_API grn_rc grn_table_sort_key_close(grn_ctx *ctx,
-                                        grn_table_sort_key *keys, unsigned nkeys);
+                                        grn_table_sort_key *keys, unsigned int nkeys);
 
 GRN_API grn_rc grn_load(grn_ctx *ctx, grn_content_type input_type,
-                        const char *table, unsigned table_len,
-                        const char *columns, unsigned columns_len,
-                        const char *values, unsigned values_len,
-                        const char *ifexists, unsigned ifexists_len,
-                        const char *each, unsigned each_len);
+                        const char *table, unsigned int table_len,
+                        const char *columns, unsigned int columns_len,
+                        const char *values, unsigned int values_len,
+                        const char *ifexists, unsigned int ifexists_len,
+                        const char *each, unsigned int each_len);
 
 #define GRN_CTX_MORE                    (0x01<<0)
 #define GRN_CTX_TAIL                    (0x01<<1)
@@ -2516,8 +2544,8 @@ GRN_API grn_rc grn_load(grn_ctx *ctx, grn_content_type input_type,
 #define GRN_CTX_QUIT                    (0x01<<4)
 
 GRN_API grn_rc grn_ctx_connect(grn_ctx *ctx, const char *host, int port, int flags);
-GRN_API unsigned grn_ctx_send(grn_ctx *ctx, const char *str, unsigned int str_len, int flags);
-GRN_API unsigned grn_ctx_recv(grn_ctx *ctx, char **str, unsigned int *str_len, int *flags);
+GRN_API unsigned int grn_ctx_send(grn_ctx *ctx, const char *str, unsigned int str_len, int flags);
+GRN_API unsigned int grn_ctx_recv(grn_ctx *ctx, char **str, unsigned int *str_len, int *flags);
 
 typedef struct _grn_ctx_info grn_ctx_info;
 
@@ -2554,8 +2582,8 @@ GRN_API grn_id grn_hash_get(grn_ctx *ctx, grn_hash *hash, const void *key,
 GRN_API int grn_hash_get_key(grn_ctx *ctx, grn_hash *hash, grn_id id, void *keybuf, int bufsize);
 GRN_API int grn_hash_get_key2(grn_ctx *ctx, grn_hash *hash, grn_id id, grn_obj *bulk);
 GRN_API int grn_hash_get_value(grn_ctx *ctx, grn_hash *hash, grn_id id, void *valuebuf);
-GRN_API grn_rc grn_hash_set_value(grn_ctx *ctx, grn_hash *hash, grn_id id, void *value,
-                                  int flags);
+GRN_API grn_rc grn_hash_set_value(grn_ctx *ctx, grn_hash *hash, grn_id id,
+                                  const void *value, int flags);
 
 typedef struct _grn_table_delete_optarg grn_table_delete_optarg;
 
@@ -2581,7 +2609,7 @@ GRN_API void grn_hash_cursor_close(grn_ctx *ctx, grn_hash_cursor *c);
 GRN_API int grn_hash_cursor_get_key(grn_ctx *ctx, grn_hash_cursor *c, void **key);
 GRN_API int grn_hash_cursor_get_value(grn_ctx *ctx, grn_hash_cursor *c, void **value);
 GRN_API grn_rc grn_hash_cursor_set_value(grn_ctx *ctx, grn_hash_cursor *c,
-                                         void *value, int flags);
+                                         const void *value, int flags);
 
 GRN_API int grn_hash_cursor_get_key_value(grn_ctx *ctx, grn_hash_cursor *c,
                                           void **key, unsigned int *key_size, void **value);
@@ -2608,20 +2636,20 @@ typedef struct _grn_array grn_array;
 typedef struct _grn_array_cursor grn_array_cursor;
 
 GRN_API grn_array *grn_array_create(grn_ctx *ctx, const char *path,
-                                    unsigned value_size, unsigned flags);
+                                    unsigned int value_size, unsigned int flags);
 GRN_API grn_array *grn_array_open(grn_ctx *ctx, const char *path);
 GRN_API grn_rc grn_array_close(grn_ctx *ctx, grn_array *array);
 GRN_API grn_id grn_array_add(grn_ctx *ctx, grn_array *array, void **value);
 GRN_API int grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id, void *valuebuf);
 GRN_API grn_rc grn_array_set_value(grn_ctx *ctx, grn_array *array, grn_id id,
-                                   void *value, int flags);
+                                   const void *value, int flags);
 GRN_API grn_array_cursor *grn_array_cursor_open(grn_ctx *ctx, grn_array *array,
                                                 grn_id min, grn_id max,
                                                 int offset, int limit, int flags);
 GRN_API grn_id grn_array_cursor_next(grn_ctx *ctx, grn_array_cursor *c);
 GRN_API int grn_array_cursor_get_value(grn_ctx *ctx, grn_array_cursor *c, void **value);
 GRN_API grn_rc grn_array_cursor_set_value(grn_ctx *ctx, grn_array_cursor *c,
-                                          void *value, int flags);
+                                          const void *value, int flags);
 GRN_API grn_rc grn_array_cursor_delete(grn_ctx *ctx, grn_array_cursor *c,
                                        grn_table_delete_optarg *optarg);
 GRN_API void grn_array_cursor_close(grn_ctx *ctx, grn_array_cursor *c);
@@ -2667,7 +2695,7 @@ GRN_API int grn_pat_get_key(grn_ctx *ctx, grn_pat *pat, grn_id id, void *keybuf,
 GRN_API int grn_pat_get_key2(grn_ctx *ctx, grn_pat *pat, grn_id id, grn_obj *bulk);
 GRN_API int grn_pat_get_value(grn_ctx *ctx, grn_pat *pat, grn_id id, void *valuebuf);
 GRN_API grn_rc grn_pat_set_value(grn_ctx *ctx, grn_pat *pat, grn_id id,
-                                 void *value, int flags);
+                                 const void *value, int flags);
 
 GRN_API grn_rc grn_pat_delete_by_id(grn_ctx *ctx, grn_pat *pat, grn_id id,
                                     grn_table_delete_optarg *optarg);
@@ -2709,7 +2737,7 @@ GRN_API int grn_pat_cursor_get_value(grn_ctx *ctx, grn_pat_cursor *c, void **val
 GRN_API int grn_pat_cursor_get_key_value(grn_ctx *ctx, grn_pat_cursor *c,
                                          void **key, unsigned int *key_size, void **value);
 GRN_API grn_rc grn_pat_cursor_set_value(grn_ctx *ctx, grn_pat_cursor *c,
-                                        void *value, int flags);
+                                        const void *value, int flags);
 GRN_API grn_rc grn_pat_cursor_delete(grn_ctx *ctx, grn_pat_cursor *c,
                                      grn_table_delete_optarg *optarg);
 

data/vendor/local/lib/pkgconfig/groonga.pc

@@ -3,12 +3,15 @@ exec_prefix=${prefix}
 bindir=${exec_prefix}/bin
 libdir=${exec_prefix}/lib
 includedir=${prefix}/include
+datarootdir=${prefix}/share
+datadir=${datarootdir}
+document_root=${datadir}/groonga/html/admin
 groonga=${bindir}/groonga.exe
 groonga_suggest_create_dataset=${bindir}/groonga-suggest-create-dataset.exe
-groonga_version=1.2.8
+groonga_version=1.3.0
 
 Name: Groonga
 Description: An Embeddable Fulltext Search Engine
-Version: 1.2.8
+Version: 1.3.0
 Libs: -L${libdir} -lgroonga
 Cflags: -I${includedir}/groonga

data/vendor/local/share/doc/groonga/en/html/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: fd5b7ec27c959d53caabd9fc92f292cd
+config: 2328c05e37425554abd0b8a6ebbec308
 tags: fbb0d17656682115ca4d033fb2f83ba1

data/vendor/local/share/doc/groonga/en/html/_sources/characteristic.txt

@@ -2,58 +2,68 @@
 
 .. highlightlang:: none
 
-The characteristics of groonga
-==============================
+Characteristics of groonga
+==========================
 
-The successor to the Senna that is an embeddable full text search engine
-------------------------------------------------------------------------
+Groonga overview
+----------------
 
-Groonga is developed as the successor project to Senna. Senna is an embeddable full text search engine and it is used widely. Groonga takes over from Senna's characteristics that are fast, high precision and high flexibility. We started to develop groonga to improve those Senna' characteristics.
+Groonga is a fast and accurate full text search engine based on inverted index. One of the characteristics of groonga is that a newly registered document instantly appears in search results. Also, groonga allows updates without read locks. These characteristics result in superior performance on real-time applications.
 
-Groonga server supports multi-protocols such as HTTP
-----------------------------------------------------
+Groonga is also a column-oriented database management system (DBMS). Compared with well-known row-oriented systems, such as MySQL and PostgreSQL, column-oriented systems are more suited for aggregate queries. Due to this advantage, groonga can cover weakness of row-oriented systems.
 
-Senna is an component for an application that supports full text search. Groonga can be a server that provides search service. The groonga server supports HTTP, memcached binary protocol and gqtp (groonga query transfer protocol). Clients can search by those protocols via TCP/IP connection. It makes easy to use on a rental server that can install a library.
+The basic functions of groonga are provided in a C library. Also, libraries for using groonga in other languages, such as Ruby, are provided by related projects. In addition, groonga-based storage engines are provided for MySQL and PostgreSQL. These libraries and storage engines allow any application to use groonga. See `usage examples <http://groonga.org/users/>`_.
 
-Groonga also can be used as a C library like Senna.
+Full text search and Instant update
+-----------------------------------
 
-Fast data update
-----------------
+In widely used DBMSs, updates are immediately processed, for example, a newly registered record appears in the result of the next query. In contrast, some full text search engines do not support instant updates, because it is difficult to dynamically update inverted indexes, the underlying data structure.
+
+Groonga also uses inverted indexes but supports instant updates. In addition, groonga allows you to search documents even when updating the document collection. Due to these superior characteristics, groonga is very flexible as a full text search engine. Also, groonga always shows good performance because it divides a large task, inverted index merging, into smaller tasks.
+
+Column store and aggregate query
+--------------------------------
+
+People can collect more than enough data in the Internet era. However, it is difficult to extract informative knowledge from a large database, and such a task requires a many-sided analysis through trial and error. For example, search refinement by date, time and location may reveal hidden patterns. Aggregate queries are useful to perform this kind of tasks.
+
+An aggregate query groups search results by specified column values and then counts the number of records in each group. For example, an aggregate query in which a location column is specified counts the number of records per location. Making a graph from the result of an aggregate query against a date column is an easy way to visualize changes over time. Also, a combination of refinement by location and an aggregate query against a date column allows visualization of changes over time in specific location. Thus refinement and aggregation are important to perform data mining.
 
-Senna that is predecessor of groonga is a full text search engine without storage. Senna was commonly used with MySQL or PostgreSQL. Tritonn is a custom MyISAM storage engine that uses Senna as full text search engine. Ludia is a extension module for a PostgreSQL to use Senna as full text search engine. But those approaches can't fully utilize the performance characteristics of Senna. Senna can update index without read lock.
+A column-oriented architecture allows groonga to efficiently process aggregate queries because a column-oriented database, which stores records by column, allows an aggregate query to access only a specified column. On the other hand, an aggregate query on a row-oriented database, which stores records by row, has to access neighbor columns, even though those columns are not required.
 
-For example, MyISAM acquires table lock while updating records in many cases. In those cases, data update by MyISAM is a bottleneck however Senna updates an index full text search fast.
+Inverted index and tokenizer
+----------------------------
 
-Groonga implements a storage that doesn't acquires read lock to realize search service that has immediacy.
+An inverted index is a traditional data structure used for large-scale full text search. A search engine based on inverted index extracts index terms from a document when it is added. Then in retrieval, a query is divided into index terms to find documents containing those index terms. In this way, index terms play an important role in full text search and thus the way of extracting index terms is a key to a better search engine.
 
+A tokenizer is a module to extract index terms. A Japanese full text search engine commonly uses a word-based tokenizer (hereafter referred to as a word tokenizer) and/or a character-based n-gram tokenizer (hereafter referred to as an n-gram tokenizer). A word tokenizer-based search engine is superior in time, space and precision, which is the fraction of relevant documents in a search result. On the other hand, an n-gram tokenizer-based search engine is superior in recall, which is the fraction of retrieved documents in the perfect search result. The best choice depends on the application in practice.
 
-Storage that can be shared with multi-processes and multi-threads
------------------------------------------------------------------
+Groonga supports both word and n-gram tokenizers. The simplest built-in tokenizer uses spaces as word delimiters. Built-in n-gram tokenizers (n = 1, 2, 3) are also available by default. In addition, a yet another built-in word tokenizer is available if MeCab, a part-of-speech and morphological analyzer, is embedded. Note that a tokenizer is pluggable and you can develop your own tokenizer, such as a tokenizer based on another part-of-speech tagger or a named-entity recognizer.
 
-Groonga's storage file can be shared with multi-processes and multi-threads. It doesn't require explicit lock.
+Sharable storage and read lock-free
+-----------------------------------
 
-`Mroonga <http://mroonga.github.com/>`_ that is the successor to the Tritonn is implemented as a MySQL pruggable storage engine. Groonga's storage files that are opened by mroonga can also be shared with groonga server. For example, you can update your data via SQL and search your data via HTTP.
+Multi-core processors are mainstream today and the number of cores per processor is increasing. In order to exploit multiple cores, executing multiple queries in parallel or dividing a query into sub-queries for parallel processing is becoming more important.
 
-Fast aggregate query processing such as drilldown
--------------------------------------------------
+A database of groonga can be shared with multiple threads/processes. Also, multiple threads/processes can execute read queries in parallel even when another thread/process is executing an update query because groonga uses read lock-free data structures. This feature is suited to a real-time application that needs to update a database while executing read queries. In addition, groonga allows you to build flexible systems. For example, a database can receive read queries through the built-in HTTP server of groonga while accepting update queries through MySQL.
 
-Groonga's storage uses column oriented database model that stores data for each column. Column oriented database is suitable for fast aggregate query processing such as OLAP.
+Geo-location (latitude and longitude) search
+--------------------------------------------
 
-"Drilldown" is a processing that groups full text search result by each specified column values and counts number of records in each group. Groonga does the processing fast because groonga uses column oriented database.
+Location services are getting more convenient because of mobile devices with GPS. For example, if you are going to have lunch or dinner at a nearby restaurant, a local search service for restaurants may be very useful, and for such services, fast geo-location search is becoming more important.
 
-Improved Senna's inverted index implementation
-----------------------------------------------
+Groonga provides inverted index-based fast geo-location search, which supports a query to find points in a rectangle or circle. Groonga gives high priority to points near the center of an area. Also, groonga supports distance measurement and you can sort points by distance from any point.
 
-Groonga's inverted index is the improved Senna's inverted index. It is more faster and more versatile.
+Groonga library
+---------------
 
-Groonga can also process some complex queries fast by utilizing inverted index. Those queries are difficult to process with SQL and RDB. For example, tag search and drilldown can be processed fast by utilizing inverted index.
+The basic functions of groonga are provided in a C library and any application can use groonga as a full text search engine or a column-oriented database. Also, libraries for languages other than C/C++, such as Ruby, are provided in related projects. See `related projects <http://groonga.org/related-projects.html>`_ for details.
 
-Geolocation (latitude and longitude) search
--------------------------------------------
+Groonga server
+--------------
 
-Groonga supports geolocation search. Supported geodetic systems are Japan geodetic system and world geodetic system (WGS 84). Supported geolocation refinement region types are circle and rectangle. Groonga also supports distance between two coordinates.
+Groonga provides a built-in server command which supports HTTP, the memcached binary protocol and the groonga query transfer protocol (gqtp). Also, a groonga server supports query caching, which significantly reduces response time for repeated read queries. Using this command, groonga is available even on a server that does not allow you to install new libraries.
 
-Auto query cache mechanism
---------------------------
+Groonga storage engine
+----------------------
 
-Groonga caches reference queries automatically.
+Groonga works not only as an independent column-oriented DBMS but also as storage engines of well-known DBMSs. For example, `mroonga <http://mroonga.github.com/>`_ is a MySQL pluggable storage engine using groonga. By using mroonga, you can use groonga for column-oriented storage and full text search. A combination of a built-in storage engine, MyISAM or InnoDB, and a groonga-based full text search engine is also available. All the combinations have good and bad points and the best one depends on the application. See `related projects <http://groonga.org/related-projects.html>`_ for details.

data/vendor/local/share/doc/groonga/en/html/_sources/commands/delete.txt

@@ -14,7 +14,7 @@ delete - 一件のレコードの削除
 ----
 ::
 
- delete table [key [id]]
+ delete table [key [id [filter]]]
 
 説明
 ----
@@ -38,6 +38,10 @@ deleteは、使用しているデータベースのテーブルに1件のレコ
 
   レコードIDによってレコードを指定します。idパラメータを指定する場合は、keyパラメータを指定してはいけません。
 
+``filter``
+
+  script形式のgrn_expr文字列によってレコードを指定します。filterパラメータを指定する場合は、id及びkeyパラメータを指定してはいけません。
+
 返値
 ---