[Groonga-commit] groonga/groonga at cb240e7 [master] io_flush: add dependent option

Back to archive index
Kouhei Sutou null+****@clear*****
Fri Apr 12 17:49:44 JST 2019


Kouhei Sutou	2019-04-12 17:49:44 +0900 (Fri, 12 Apr 2019)

  Revision: cb240e71aa6e83c60550a5e6388e9d07a5cd945a
  https://github.com/groonga/groonga/commit/cb240e71aa6e83c60550a5e6388e9d07a5cd945a

  Message:
    io_flush: add dependent option
    
    TODO: test

  Modified files:
    include/groonga/groonga.h
    lib/db.c
    lib/proc.c
    test/command/suite/io_flush/default.expected
    test/command/suite/io_flush/default.test
    test/command/suite/io_flush/many_data.expected
    test/command/suite/io_flush/many_data.test
    test/command/suite/io_flush/only_opened/yes.expected
    test/command/suite/io_flush/only_opened/yes.test
    test/command/suite/io_flush/recursive/no.expected
    test/command/suite/io_flush/recursive/no.test
    test/command/suite/io_flush/target_name/column.expected
    test/command/suite/io_flush/target_name/column.test
    test/command/suite/io_flush/target_name/nonexistent.test
    test/command/suite/io_flush/target_name/table.expected
    test/command/suite/io_flush/target_name/table.test

  Modified: include/groonga/groonga.h (+1 -0)
===================================================================
--- include/groonga/groonga.h    2019-04-12 17:27:42 +0900 (20d0a354a)
+++ include/groonga/groonga.h    2019-04-12 17:49:44 +0900 (7ed36b718)
@@ -779,6 +779,7 @@ GRN_API grn_rc grn_obj_clear_lock(grn_ctx *ctx, grn_obj *obj);
 GRN_API unsigned int grn_obj_is_locked(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_rc grn_obj_flush(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_rc grn_obj_flush_recursive(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_rc grn_obj_flush_dependent(grn_ctx *ctx, grn_obj *obj);
 GRN_API int grn_obj_defrag(grn_ctx *ctx, grn_obj *obj, int threshold);
 
 GRN_API grn_obj *grn_obj_db(grn_ctx *ctx, grn_obj *obj);

  Modified: lib/db.c (+392 -0)
===================================================================
--- lib/db.c    2019-04-12 17:27:42 +0900 (3fb46d580)
+++ lib/db.c    2019-04-12 17:49:44 +0900 (a17d13994)
@@ -12302,6 +12302,9 @@ grn_obj_flush(grn_ctx *ctx, grn_obj *obj)
 
   GRN_API_ENTER;
 
+  char name[GRN_TABLE_MAX_KEY_SIZE];
+  int name_size = 0;
+  bool flushed = false;
   switch (obj->header.type) {
   case GRN_DB :
     {
@@ -12317,12 +12320,17 @@ grn_obj_flush(grn_ctx *ctx, grn_obj *obj)
         rc = grn_options_flush(ctx, db->options);
       }
     }
+    grn_strcpy(name, GRN_TABLE_MAX_KEY_SIZE, "(DB)");
+    name_size = strlen(name);
+    flushed = true;
     break;
   case GRN_TABLE_DAT_KEY :
     rc = grn_dat_flush(ctx, (grn_dat *)obj);
+    flushed = true;
     break;
   case GRN_COLUMN_INDEX :
     rc = grn_ii_flush(ctx, (grn_ii *)obj);
+    flushed = true;
     break;
   default :
     {
@@ -12330,11 +12338,30 @@ grn_obj_flush(grn_ctx *ctx, grn_obj *obj)
       io = grn_obj_get_io(ctx, obj);
       if (io) {
         rc = grn_io_flush(ctx, io);
+        flushed = true;
       }
     }
     break;
   }
 
+  if (flushed && name_size == 0) {
+    name_size = grn_obj_name(ctx, obj, name, GRN_TABLE_MAX_KEY_SIZE);
+    if (name_size == 0) {
+      grn_strcpy(name, GRN_TABLE_MAX_KEY_SIZE, "(anonymous:");
+      grn_strcat(name, GRN_TABLE_MAX_KEY_SIZE,
+                 grn_obj_type_to_string(obj->header.type));
+      grn_strcat(name, GRN_TABLE_MAX_KEY_SIZE, ")");
+      name_size = strlen(name);
+    }
+  }
+
+  if (name_size > 0) {
+    GRN_QUERY_LOG(ctx, GRN_QUERY_LOG_SIZE,
+                  ":",
+                  "flush[%.*s]",
+                  name_size, name);
+  }
+
   if (rc == GRN_SUCCESS &&
       GRN_DB_OBJP(obj) &&
       DB_OBJ(obj)->id != GRN_ID_NIL &&
@@ -12443,6 +12470,371 @@ grn_obj_flush_recursive(grn_ctx *ctx, grn_obj *obj)
   GRN_API_RETURN(rc);
 }
 
+typedef struct {
+  grn_hash *flushed;
+  bool is_close_opened_object_mode;
+} flush_dependent_data;
+
+static bool
+grn_obj_flush_dependent_need_flush(grn_ctx *ctx,
+                                   flush_dependent_data *data,
+                                   grn_id id)
+{
+  int added = 0;
+  grn_id flushed_id = grn_hash_add(ctx,
+                                   data->flushed,
+                                   &id, sizeof(grn_id),
+                                   NULL,
+                                   &added);
+  if (flushed_id == GRN_ID_NIL) {
+    grn_rc rc = ctx->rc;
+    if (rc == GRN_SUCCESS) {
+      rc = GRN_NO_MEMORY_AVAILABLE;
+    }
+    char message[GRN_CTX_MSGSIZE];
+    grn_strcpy(message, GRN_CTX_MSGSIZE, ctx->errbuf);
+    ERR(rc,
+        "[io_flush] failed to register flushed ID: <%u>: %s",
+        id,
+        message);
+    return false;
+  }
+  return added != 0;
+}
+
+static void
+grn_obj_flush_dependent_internal(grn_ctx *ctx,
+                                 grn_obj *obj,
+                                 flush_dependent_data *data);
+
+static void
+grn_obj_flush_dependent_internal_db(grn_ctx *ctx,
+                                    grn_obj *db,
+                                    flush_dependent_data *data)
+{
+  GRN_TABLE_EACH_BEGIN(ctx, db, cursor, id) {
+    if (!grn_obj_flush_dependent_need_flush(ctx, data, id)) {
+      if (ctx->rc == GRN_SUCCESS) {
+        continue;
+      } else {
+        break;
+      }
+    }
+
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_push_temporary_open_space(ctx);
+    }
+
+    grn_obj *object = grn_ctx_at(ctx, id);
+    if (grn_obj_is_table(ctx, object)) {
+      grn_obj_flush_dependent_internal(ctx, object, data);
+    } else {
+      if (ctx->rc != GRN_SUCCESS) {
+        ERRCLR(ctx);
+      }
+    }
+
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_pop_temporary_open_space(ctx);
+    }
+
+    if (ctx->rc != GRN_SUCCESS) {
+      break;
+    }
+  } GRN_TABLE_EACH_END(ctx, cursor);
+  if (ctx->rc != GRN_SUCCESS) {
+    return;
+  }
+
+  grn_obj_flush(ctx, db);
+}
+
+static void
+grn_obj_flush_dependent_internal_table(grn_ctx *ctx,
+                                       grn_obj *table,
+                                       flush_dependent_data *data)
+{
+  if (grn_obj_is_lexicon(ctx, table)) {
+    grn_id domain_id = table->header.domain;
+    if (grn_obj_flush_dependent_need_flush(ctx, data, domain_id)) {
+      if (data->is_close_opened_object_mode) {
+        grn_ctx_push_temporary_open_space(ctx);
+      }
+      grn_obj *domain = grn_ctx_at(ctx, domain_id);
+      if (grn_obj_is_table(ctx, domain)) {
+        grn_obj_flush_dependent_internal(ctx, domain, data);
+      }
+      if (data->is_close_opened_object_mode) {
+        grn_ctx_pop_temporary_open_space(ctx);
+      }
+    }
+    if (ctx->rc != GRN_SUCCESS) {
+      return;
+    }
+  }
+
+  grn_hash *columns = grn_hash_create(ctx,
+                                      NULL,
+                                      sizeof(grn_id),
+                                      0,
+                                      GRN_OBJ_TABLE_HASH_KEY | GRN_HASH_TINY);
+  if (!columns) {
+    grn_rc rc = ctx->rc;
+    if (rc == GRN_SUCCESS) {
+      rc = GRN_NO_MEMORY_AVAILABLE;
+    }
+    char message[GRN_CTX_MSGSIZE];
+    grn_strcpy(message, GRN_CTX_MSGSIZE, ctx->errbuf);
+    char table_name[GRN_TABLE_MAX_KEY_SIZE];
+    int table_name_size;
+    table_name_size = grn_obj_name(ctx,
+                                   table,
+                                   table_name,
+                                   GRN_TABLE_MAX_KEY_SIZE);
+    ERR(rc,
+        "[io_flush] failed to create internal hash table "
+        "to store columns: <%.*s>: %s",
+        table_name_size, table_name,
+        message);
+    return;
+  }
+
+  if (grn_table_columns(ctx, table, "", 0, (grn_obj *)columns) > 0) {
+    GRN_HASH_EACH_BEGIN(ctx, columns, cursor, id) {
+      void *key;
+      if (grn_hash_cursor_get_key(ctx, cursor, &key) == 0) {
+        continue;
+      }
+
+      grn_id *column_id = key;
+      if (!grn_obj_flush_dependent_need_flush(ctx, data, *column_id)) {
+        if (ctx->rc == GRN_SUCCESS) {
+          continue;
+        } else {
+          break;
+        }
+      }
+
+      if (data->is_close_opened_object_mode) {
+        grn_ctx_push_temporary_open_space(ctx);
+      }
+      grn_obj *column = grn_ctx_at(ctx, *column_id);
+      if (column) {
+        grn_obj_flush_dependent_internal(ctx, column, data);
+      }
+      if (data->is_close_opened_object_mode) {
+        grn_ctx_pop_temporary_open_space(ctx);
+      }
+
+      if (ctx->rc != GRN_SUCCESS) {
+        break;
+      }
+    } GRN_HASH_EACH_END(ctx, cursor);
+  }
+  grn_hash_close(ctx, columns);
+  if (ctx->rc != GRN_SUCCESS) {
+    return;
+  }
+
+  grn_obj_flush(ctx, table);
+}
+
+static void
+grn_obj_flush_dependent_internal_column_data(grn_ctx *ctx,
+                                             grn_obj *column,
+                                             flush_dependent_data *data)
+{
+  grn_id table_id = column->header.domain;
+  if (grn_obj_flush_dependent_need_flush(ctx, data, table_id)) {
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_push_temporary_open_space(ctx);
+    }
+    grn_obj *table = grn_ctx_at(ctx, table_id);
+    if (table) {
+      grn_obj_flush_dependent_internal(ctx, table, data);
+    }
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_pop_temporary_open_space(ctx);
+    }
+  }
+  if (ctx->rc != GRN_SUCCESS) {
+    return;
+  }
+
+  grn_id range_id = grn_obj_get_range(ctx, column);
+  if (grn_obj_flush_dependent_need_flush(ctx, data, range_id)) {
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_push_temporary_open_space(ctx);
+    }
+    grn_obj *range = grn_ctx_at(ctx, range_id);
+    if (grn_obj_is_table(ctx, range)) {
+      grn_obj_flush_dependent_internal(ctx, range, data);
+    }
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_pop_temporary_open_space(ctx);
+    }
+  }
+  if (ctx->rc != GRN_SUCCESS) {
+    return;
+  }
+
+  for (grn_hook *hooks = DB_OBJ(column)->hooks[GRN_HOOK_SET];
+       hooks;
+       hooks = hooks->next) {
+    grn_obj_default_set_value_hook_data *hook_data =
+      (grn_obj_default_set_value_hook_data *)GRN_NEXT_ADDR(hooks);
+    if (grn_obj_flush_dependent_need_flush(ctx, data, hook_data->target)) {
+      if (data->is_close_opened_object_mode) {
+        grn_ctx_push_temporary_open_space(ctx);
+      }
+      grn_obj *index = grn_ctx_at(ctx, hook_data->target);
+      if (index) {
+        grn_obj_flush_dependent_internal(ctx, index, data);
+      }
+      if (data->is_close_opened_object_mode) {
+        grn_ctx_pop_temporary_open_space(ctx);
+      }
+      if (ctx->rc != GRN_SUCCESS) {
+        return;
+      }
+    }
+  }
+
+  grn_obj_flush(ctx, column);
+}
+
+static void
+grn_obj_flush_dependent_internal_column_index(grn_ctx *ctx,
+                                              grn_obj *column,
+                                              flush_dependent_data *data)
+{
+  grn_id lexicon_id = column->header.domain;
+  if (grn_obj_flush_dependent_need_flush(ctx, data, lexicon_id)) {
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_push_temporary_open_space(ctx);
+    }
+    grn_obj *lexicon = grn_ctx_at(ctx, lexicon_id);
+    if (lexicon) {
+      grn_obj_flush_dependent_internal(ctx, lexicon, data);
+    }
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_pop_temporary_open_space(ctx);
+    }
+  }
+  if (ctx->rc != GRN_SUCCESS) {
+    return;
+  }
+
+  grn_obj source_ids;
+  GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
+  grn_obj_get_info(ctx, column, GRN_INFO_SOURCE, &source_ids);
+  size_t n = GRN_UINT32_VECTOR_SIZE(&source_ids);
+  for (size_t i = 0; i < n; i++) {
+    grn_id source_id = GRN_UINT32_VALUE_AT(&source_ids, i);
+    if (!grn_obj_flush_dependent_need_flush(ctx, data, source_id)) {
+      if (ctx->rc == GRN_SUCCESS) {
+        continue;
+      } else {
+        break;
+      }
+    }
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_push_temporary_open_space(ctx);
+    }
+    grn_obj *source = grn_ctx_at(ctx, source_id);
+    if (source) {
+      grn_obj_flush_dependent_internal(ctx, source, data);
+    }
+    if (data->is_close_opened_object_mode) {
+      grn_ctx_pop_temporary_open_space(ctx);
+    }
+    if (ctx->rc != GRN_SUCCESS) {
+      break;
+    }
+  }
+  GRN_OBJ_FIN(ctx, &source_ids);
+  if (ctx->rc != GRN_SUCCESS) {
+    return;
+  }
+
+  grn_obj_flush(ctx, column);
+}
+
+static void
+grn_obj_flush_dependent_internal(grn_ctx *ctx,
+                                 grn_obj *obj,
+                                 flush_dependent_data *data)
+{
+  switch (obj->header.type) {
+  case GRN_DB :
+    grn_obj_flush_dependent_internal_db(ctx, obj, data);
+    break;
+  case GRN_TABLE_NO_KEY :
+  case GRN_TABLE_HASH_KEY :
+  case GRN_TABLE_PAT_KEY :
+  case GRN_TABLE_DAT_KEY :
+    grn_obj_flush_dependent_internal_table(ctx, obj, data);
+    break;
+  case GRN_COLUMN_FIX_SIZE :
+  case GRN_COLUMN_VAR_SIZE :
+    grn_obj_flush_dependent_internal_column_data(ctx, obj, data);
+    break;
+  case GRN_COLUMN_INDEX :
+    grn_obj_flush_dependent_internal_column_index(ctx, obj, data);
+    break;
+  default :
+    {
+      grn_obj inspected;
+      GRN_TEXT_INIT(&inspected, 0);
+      grn_inspect(ctx, &inspected, obj);
+      ERR(GRN_INVALID_ARGUMENT,
+          "[flush] object must be DB, table or column: <%.*s>",
+          (int)GRN_TEXT_LEN(&inspected),
+          GRN_TEXT_VALUE(&inspected));
+      GRN_OBJ_FIN(ctx, &inspected);
+    }
+    break;
+  }
+}
+
+grn_rc
+grn_obj_flush_dependent(grn_ctx *ctx, grn_obj *obj)
+{
+  GRN_API_ENTER;
+
+  flush_dependent_data data;
+  data.flushed = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
+                                 GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY);
+  if (!data.flushed) {
+    grn_rc rc = ctx->rc;
+    if (rc == GRN_SUCCESS) {
+      rc = GRN_NO_MEMORY_AVAILABLE;
+    }
+    char message[GRN_CTX_MSGSIZE];
+    grn_strcpy(message, GRN_CTX_MSGSIZE, ctx->errbuf);
+    char name[GRN_TABLE_MAX_KEY_SIZE];
+    int name_size;
+    name_size = grn_obj_name(ctx, obj, name, GRN_TABLE_MAX_KEY_SIZE);
+    ERR(rc,
+        "[flush][dependent] failed to create an internal hash table "
+        "to manage flushed objects: <%.*s>: %s",
+        name_size, name,
+        message);
+    GRN_API_RETURN(ctx->rc);
+  }
+
+  data.is_close_opened_object_mode = (grn_thread_get_limit() == 1);
+
+  grn_id id = grn_obj_id(ctx, obj);
+  if (grn_obj_flush_dependent_need_flush(ctx, &data, id)) {
+    grn_obj_flush_dependent_internal(ctx, obj, &data);
+  }
+
+  grn_hash_close(ctx, data.flushed);
+
+  GRN_API_RETURN(ctx->rc);
+}
+
 grn_obj *
 grn_obj_db(grn_ctx *ctx, grn_obj *obj)
 {

  Modified: lib/proc.c (+53 -59)
===================================================================
--- lib/proc.c    2019-04-12 17:27:42 +0900 (140e20a39)
+++ lib/proc.c    2019-04-12 17:49:44 +0900 (d84adfc85)
@@ -3712,29 +3712,19 @@ proc_plugin_unregister(grn_ctx *ctx, int nargs, grn_obj **args,
 static grn_obj *
 proc_io_flush(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
 {
-  grn_obj *target_name;
-  grn_obj *recursive;
-  grn_obj *only_opened;
-  grn_obj *db;
-  grn_obj *target;
-  grn_rc rc;
-  grn_bool is_recursive;
-  grn_bool is_only_opened;
-
-  target_name = VAR(0);
-  recursive = VAR(1);
-  only_opened = VAR(2);
+  grn_obj *db = grn_ctx_db(ctx);
 
-  db = grn_ctx_db(ctx);
-
-  if (GRN_TEXT_LEN(target_name) > 0) {
-    target = grn_ctx_get(ctx,
-                         GRN_TEXT_VALUE(target_name),
-                         GRN_TEXT_LEN(target_name));
+  grn_raw_string target_name;
+  target_name.value = grn_plugin_proc_get_var_string(ctx, user_data,
+                                                     "target_name", -1,
+                                                     &(target_name.length));
+  grn_obj *target;
+  if (target_name.length > 0) {
+    target = grn_ctx_get(ctx, target_name.value, target_name.length);
     if (!target) {
       ERR(GRN_INVALID_ARGUMENT, "[io_flush] unknown target: <%.*s>",
-          (int)GRN_TEXT_LEN(target_name),
-          GRN_TEXT_VALUE(target_name));
+          (int)target_name.length,
+          target_name.value);
       GRN_OUTPUT_BOOL(GRN_FALSE);
       return NULL;
     }
@@ -3742,7 +3732,7 @@ proc_io_flush(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
     target = db;
   }
 
-  rc = grn_obj_lock(ctx, db, GRN_ID_NIL, grn_lock_timeout);
+  grn_rc rc = grn_obj_lock(ctx, db, GRN_ID_NIL, grn_lock_timeout);
   if (rc != GRN_SUCCESS) {
     char errbuf[GRN_CTX_MSGSIZE];
     grn_strcpy(errbuf, GRN_CTX_MSGSIZE, ctx->errbuf);
@@ -3750,52 +3740,55 @@ proc_io_flush(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
     GRN_OUTPUT_BOOL(GRN_FALSE);
     return NULL;
   }
-  is_recursive = grn_proc_option_value_bool(ctx, recursive, GRN_TRUE);
-  is_only_opened = grn_proc_option_value_bool(ctx, only_opened, GRN_FALSE);
-  {
-    if (target->header.type == GRN_DB && is_only_opened) {
-      GRN_TABLE_EACH_BEGIN_FLAGS(ctx, target, cursor, id, GRN_CURSOR_BY_ID) {
-        grn_obj *sub_target;
 
-        if (id < GRN_N_RESERVED_TYPES) {
-          continue;
-        }
+  bool is_recursive = grn_plugin_proc_get_var_bool(ctx, user_data,
+                                                   "recursive", -1,
+                                                   GRN_TRUE);
+  bool is_only_opened = grn_plugin_proc_get_var_bool(ctx, user_data,
+                                                     "only_opened", -1,
+                                                     GRN_FALSE);
+  bool is_dependent = grn_plugin_proc_get_var_bool(ctx, user_data,
+                                                   "dependent", -1,
+                                                   GRN_TRUE);
+  if (target->header.type == GRN_DB && is_only_opened) {
+    GRN_TABLE_EACH_BEGIN_FLAGS(ctx, target, cursor, id, GRN_CURSOR_BY_ID) {
+      if (id < GRN_N_RESERVED_TYPES) {
+        continue;
+      }
 
-        if (!grn_ctx_is_opened(ctx, id)) {
-          continue;
-        }
+      if (!grn_ctx_is_opened(ctx, id)) {
+        continue;
+      }
 
-        sub_target = grn_ctx_at(ctx, id);
-        rc = grn_obj_flush(ctx, sub_target);
-        if (rc != GRN_SUCCESS) {
-          break;
-        }
-      } GRN_TABLE_EACH_END(ctx, cursor);
-      if (rc == GRN_SUCCESS) {
-        rc = grn_obj_flush(ctx, target);
+      grn_obj *sub_target = grn_ctx_at(ctx, id);
+      rc = grn_obj_flush(ctx, sub_target);
+      if (rc != GRN_SUCCESS) {
+        break;
       }
+    } GRN_TABLE_EACH_END(ctx, cursor);
+    if (rc == GRN_SUCCESS) {
+      rc = grn_obj_flush(ctx, target);
+    }
+  } else {
+    if (is_dependent) {
+      rc = grn_obj_flush_dependent(ctx, target);
+    } else if (is_recursive) {
+      rc = grn_obj_flush_recursive(ctx, target);
     } else {
-      if (is_recursive) {
-        rc = grn_obj_flush_recursive(ctx, target);
-      } else {
-        rc = grn_obj_flush(ctx, target);
-      }
+      rc = grn_obj_flush(ctx, target);
     }
   }
-  {
-    grn_rc unlock_rc;
-    unlock_rc = grn_obj_unlock(ctx, db, GRN_ID_NIL);
-    if (rc == GRN_SUCCESS) {
-      rc = unlock_rc;
-    }
+
+  grn_rc unlock_rc = grn_obj_unlock(ctx, db, GRN_ID_NIL);
+  if (rc == GRN_SUCCESS) {
+    rc = unlock_rc;
   }
-  {
-    grn_rc flush_rc;
-    flush_rc = grn_obj_flush(ctx, db);
-    if (rc == GRN_SUCCESS) {
-      rc = flush_rc;
-    }
+
+  grn_rc flush_rc = grn_obj_flush(ctx, db);
+  if (rc == GRN_SUCCESS) {
+    rc = flush_rc;
   }
+
   GRN_OUTPUT_BOOL(rc == GRN_SUCCESS);
 
   return NULL;
@@ -4300,7 +4293,8 @@ grn_db_init_builtin_commands(grn_ctx *ctx)
   DEF_VAR(vars[0], "target_name");
   DEF_VAR(vars[1], "recursive");
   DEF_VAR(vars[2], "only_opened");
-  DEF_COMMAND("io_flush", proc_io_flush, 3, vars);
+  DEF_VAR(vars[3], "dependent");
+  DEF_COMMAND("io_flush", proc_io_flush, 4, vars);
 
   grn_proc_init_object_exist(ctx);
 

  Modified: test/command/suite/io_flush/default.expected (+16 -0)
===================================================================
--- test/command/suite/io_flush/default.expected    2019-04-12 17:27:42 +0900 (8fe29dfa9)
+++ test/command/suite/io_flush/default.expected    2019-04-12 17:49:44 +0900 (74e09674f)
@@ -8,3 +8,19 @@ column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 [[0,0.0,0.0],true]
 io_flush
 [[0,0.0,0.0],true]
+#>io_flush
+#:000000000000000 flush[Users]
+#:000000000000000 flush[Users.name]
+#:000000000000000 flush[Terms.users_name]
+#:000000000000000 flush[Terms]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#<000000000000000 rc=0

  Modified: test/command/suite/io_flush/default.test (+2 -0)
===================================================================
--- test/command/suite/io_flush/default.test    2019-04-12 17:27:42 +0900 (24b8aae3a)
+++ test/command/suite/io_flush/default.test    2019-04-12 17:49:44 +0900 (cecbf84b2)
@@ -6,4 +6,6 @@ table_create Terms TABLE_PAT_KEY ShortText \
   --normalizer NormalizerAuto
 column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 
+#@collect-query-log true
 io_flush
+#@collect-query-log false

  Modified: test/command/suite/io_flush/many_data.expected (+12 -0)
===================================================================
--- test/command/suite/io_flush/many_data.expected    2019-04-12 17:27:42 +0900 (dc5d372bf)
+++ test/command/suite/io_flush/many_data.expected    2019-04-12 17:49:44 +0900 (b88f6358c)
@@ -8,3 +8,15 @@ column_create Lexicon sources_value COLUMN_INDEX Sources value
 [[0,0.0,0.0],true]
 io_flush Lexicon.sources_value
 [[0,0.0,0.0],true]
+#>io_flush --target_name "Lexicon.sources_value"
+#:000000000000000 flush[Sources]
+#:000000000000000 flush[Sources.value]
+#:000000000000000 flush[Lexicon.sources_value]
+#:000000000000000 flush[Lexicon]
+#:000000000000000 flush[Lexicon.sources_value]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#<000000000000000 rc=0

  Modified: test/command/suite/io_flush/many_data.test (+2 -0)
===================================================================
--- test/command/suite/io_flush/many_data.test    2019-04-12 17:27:42 +0900 (c7d7bed33)
+++ test/command/suite/io_flush/many_data.test    2019-04-12 17:49:44 +0900 (e3e023397)
@@ -12,5 +12,7 @@ column_create Lexicon sources_value COLUMN_INDEX Sources value
 #@generate-series 0 1090000 Sources '{"value" => i}'
 #@enable-logging
 
+#@collect-query-log true
 io_flush Lexicon.sources_value
+#@collect-query-log false
 #@timeout default

  Modified: test/command/suite/io_flush/only_opened/yes.expected (+14 -0)
===================================================================
--- test/command/suite/io_flush/only_opened/yes.expected    2019-04-12 17:27:42 +0900 (6719cf2cb)
+++ test/command/suite/io_flush/only_opened/yes.expected    2019-04-12 17:49:44 +0900 (2c922a969)
@@ -39,3 +39,17 @@ select Users
 ]
 io_flush --only_opened yes
 [[0,0.0,0.0],true]
+#>io_flush --only_opened "yes"
+#:000000000000000 flush[Users]
+#:000000000000000 flush[Users.name]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#<000000000000000 rc=0

  Modified: test/command/suite/io_flush/only_opened/yes.test (+2 -0)
===================================================================
--- test/command/suite/io_flush/only_opened/yes.test    2019-04-12 17:27:42 +0900 (ffc82c02a)
+++ test/command/suite/io_flush/only_opened/yes.test    2019-04-12 17:49:44 +0900 (a94ffff72)
@@ -13,4 +13,6 @@ database_unmap
 
 select Users
 
+#@collect-query-log true
 io_flush --only_opened yes
+#@collect-query-log false

  Modified: test/command/suite/io_flush/recursive/no.expected (+13 -1)
===================================================================
--- test/command/suite/io_flush/recursive/no.expected    2019-04-12 17:27:42 +0900 (433f9789f)
+++ test/command/suite/io_flush/recursive/no.expected    2019-04-12 17:49:44 +0900 (5173c3ef7)
@@ -6,5 +6,17 @@ table_create Terms TABLE_PAT_KEY ShortText   --default_tokenizer TokenBigram   -
 [[0,0.0,0.0],true]
 column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 [[0,0.0,0.0],true]
-io_flush --recursive no
+io_flush --recursive no --dependent no
 [[0,0.0,0.0],true]
+#>io_flush --dependent "no" --recursive "no"
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#<000000000000000 rc=0

  Modified: test/command/suite/io_flush/recursive/no.test (+3 -1)
===================================================================
--- test/command/suite/io_flush/recursive/no.test    2019-04-12 17:27:42 +0900 (80ca1ad7a)
+++ test/command/suite/io_flush/recursive/no.test    2019-04-12 17:49:44 +0900 (cf50d7df9)
@@ -6,4 +6,6 @@ table_create Terms TABLE_PAT_KEY ShortText \
   --normalizer NormalizerAuto
 column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 
-io_flush --recursive no
+#@collect-query-log true
+io_flush --recursive no --dependent no
+#@collect-query-log false

  Modified: test/command/suite/io_flush/target_name/column.expected (+11 -0)
===================================================================
--- test/command/suite/io_flush/target_name/column.expected    2019-04-12 17:27:42 +0900 (a6adc492e)
+++ test/command/suite/io_flush/target_name/column.expected    2019-04-12 17:49:44 +0900 (cf57c25a2)
@@ -8,3 +8,14 @@ column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 [[0,0.0,0.0],true]
 io_flush Users.name
 [[0,0.0,0.0],true]
+#>io_flush --target_name "Users.name"
+#:000000000000000 flush[Users]
+#:000000000000000 flush[Terms]
+#:000000000000000 flush[Terms.users_name]
+#:000000000000000 flush[Users.name]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#<000000000000000 rc=0

  Modified: test/command/suite/io_flush/target_name/column.test (+2 -0)
===================================================================
--- test/command/suite/io_flush/target_name/column.test    2019-04-12 17:27:42 +0900 (a67f928b1)
+++ test/command/suite/io_flush/target_name/column.test    2019-04-12 17:49:44 +0900 (9147c93cf)
@@ -6,4 +6,6 @@ table_create Terms TABLE_PAT_KEY ShortText \
   --normalizer NormalizerAuto
 column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 
+#@collect-query-log true
 io_flush Users.name
+#@collect-query-log false

  Modified: test/command/suite/io_flush/target_name/nonexistent.test (+1 -0)
===================================================================
--- test/command/suite/io_flush/target_name/nonexistent.test    2019-04-12 17:27:42 +0900 (90bcb8795)
+++ test/command/suite/io_flush/target_name/nonexistent.test    2019-04-12 17:49:44 +0900 (701ecb1a8)
@@ -1 +1,2 @@
 io_flush Nonexistent
+

  Modified: test/command/suite/io_flush/target_name/table.expected (+11 -0)
===================================================================
--- test/command/suite/io_flush/target_name/table.expected    2019-04-12 17:27:42 +0900 (797ff20fc)
+++ test/command/suite/io_flush/target_name/table.expected    2019-04-12 17:49:44 +0900 (69109a1a5)
@@ -8,3 +8,14 @@ column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 [[0,0.0,0.0],true]
 io_flush Users
 [[0,0.0,0.0],true]
+#>io_flush --target_name "Users"
+#:000000000000000 flush[Terms]
+#:000000000000000 flush[Terms.users_name]
+#:000000000000000 flush[Users.name]
+#:000000000000000 flush[Users]
+#:000000000000000 flush[(anonymous:table:dat_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(anonymous:table:hash_key)]
+#:000000000000000 flush[(anonymous:column:var_size)]
+#:000000000000000 flush[(DB)]
+#<000000000000000 rc=0

  Modified: test/command/suite/io_flush/target_name/table.test (+2 -0)
===================================================================
--- test/command/suite/io_flush/target_name/table.test    2019-04-12 17:27:42 +0900 (b5623c4c8)
+++ test/command/suite/io_flush/target_name/table.test    2019-04-12 17:49:44 +0900 (edb72b16a)
@@ -6,4 +6,6 @@ table_create Terms TABLE_PAT_KEY ShortText \
   --normalizer NormalizerAuto
 column_create Terms users_name COLUMN_INDEX|WITH_POSITION Users name
 
+#@collect-query-log true
 io_flush Users
+#@collect-query-log false
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.osdn.me/mailman/archives/groonga-commit/attachments/20190412/4b3a0746/attachment-0001.html>


More information about the Groonga-commit mailing list
Back to archive index