[Groonga-commit] groonga/grngo at ddb9c2a [master] Update GetValue() to support vector types except Text.

Back to archive index

susumu.yata null+****@clear*****
Fri Jul 24 18:55:05 JST 2015


susumu.yata	2015-07-24 18:55:05 +0900 (Fri, 24 Jul 2015)

  New Revision: ddb9c2abcfebdf5604f970cd1ae653411f2746a0
  https://github.com/groonga/grngo/commit/ddb9c2abcfebdf5604f970cd1ae653411f2746a0

  Message:
    Update GetValue() to support vector types except Text.

  Modified files:
    grngo.c
    grngo.go
    grngo.h
    grngo_test.go

  Modified: grngo.c (+112 -926)
===================================================================
--- grngo.c    2015-07-24 15:48:53 +0900 (c98c587)
+++ grngo.c    2015-07-24 18:55:05 +0900 (441eca0)
@@ -615,7 +615,7 @@ _grngo_open_bufs(grngo_column *column) {
   }
   grn_ctx *ctx = column->db->ctx;
   for (i = 0; i < (column->n_srcs - 1); i++) {
-    column->src_bufs[i] = grn_obj_open(ctx, GRN_VECTOR, 0, GRN_DB_UINT32);
+    column->src_bufs[i] = grn_obj_open(ctx, GRN_UVECTOR, 0, GRN_DB_UINT32);
     if (!column->src_bufs[i]) {
       if (ctx->rc != GRN_SUCCESS) {
         return ctx->rc;
@@ -649,7 +649,7 @@ _grngo_open_bufs(grngo_column *column) {
       break;
     }
     default: {
-      column->src_bufs[i] = grn_obj_open(ctx, GRN_VECTOR, 0, value_type);
+      column->src_bufs[i] = grn_obj_open(ctx, GRN_UVECTOR, 0, value_type);
       if (!column->src_bufs[i]) {
         if (ctx->rc != GRN_SUCCESS) {
           return ctx->rc;
@@ -1073,970 +1073,156 @@ grngo_set_geo_point_vector(grngo_column *column, grn_id id,
   return rc;
 }
 
-grn_rc
-grngo_get(grngo_column *column, grn_id id, void **value) {
-  if (!column || !value) {
-    return GRN_INVALID_ARGUMENT;
-  }
+static grn_rc
+_grngo_get_ref(grngo_column *column, size_t src_id,
+               const grn_id *ids, size_t n_ids,
+               const grn_id **next_ids, size_t *next_n_ids) {
   grn_ctx *ctx = column->db->ctx;
-  if (grn_table_at(ctx, column->table->obj, id) == GRN_ID_NIL) {
-    return GRN_INVALID_ARGUMENT;
-  }
-  const grn_id *ids = &id;
-  size_t n_ids = 1;
-  size_t i, j;
-  for (i = 0; i < (column->n_srcs - 1); i++) {
-    GRN_BULK_REWIND(column->src_bufs[i]);
-    // TODO: Vector.
-    for (j = 0; j < n_ids; j++) {
-      grn_obj_get_value(ctx, column->srcs[i], ids[j], column->src_bufs[i]);
-      if (ctx->rc != GRN_SUCCESS) {
-        return ctx->rc;
-      }
-    }
-    ids = (const grn_id *)GRN_BULK_HEAD(column->src_bufs[i]);
-    n_ids = grn_vector_size(ctx, column->src_bufs[i]);
-  }
-  GRN_BULK_REWIND(column->src_bufs[i]);
-  // TODO: Vector.
-  if (column->text_buf) {
-    GRN_BULK_REWIND(column->text_buf);
+  grn_obj *src = column->srcs[src_id];
+  grn_obj *src_buf = column->src_bufs[src_id];
+  GRN_BULK_REWIND(src_buf);
+  if (_grngo_is_vector(src)) {
+    size_t i;
     size_t offset = 0;
-    for (j = 0; j < n_ids; j++) {
-      grn_obj_get_value(ctx, column->srcs[i], ids[j], column->src_bufs[i]);
+    for (i = 0; i < n_ids; i++) {
+      grn_obj_get_value(ctx, src, ids[i], src_buf);
       if (ctx->rc != GRN_SUCCESS) {
         return ctx->rc;
       }
-      size_t size = GRN_BULK_VSIZE(column->src_bufs[i]);
-      grngo_text text = { NULL, size - offset };
-      grn_rc rc = grn_bulk_write(ctx, column->text_buf,
-                                 (char *)&text, sizeof(text));
+      size_t size = grn_vector_size(ctx, src_buf);
+      grngo_vector vector = { NULL, size - offset };
+      grn_rc rc = grn_bulk_write(ctx, column->vector_buf,
+                                 (char *)&vector, sizeof(vector));
       if (rc != GRN_SUCCESS) {
         return rc;
       }
       offset = size;
     }
-    char *ptr = GRN_BULK_HEAD(column->src_bufs[i]);
-    grngo_text *texts = (grngo_text *)GRN_BULK_HEAD(column->text_buf);
-    for (j = 0; j < n_ids; j++) {
-      texts[j].ptr = ptr;
-      ptr += texts[j].size;
-    }
-    *value = texts;
   } else {
-    for (j = 0; j < n_ids; j++) {
-      // TODO: Vector and Text.
-      grn_obj_get_value(ctx, column->srcs[i], ids[j], column->src_bufs[i]);
+    size_t i;
+    for (i = 0; i < n_ids; i++) {
+      grn_obj_get_value(ctx, src, ids[i], src_buf);
       if (ctx->rc != GRN_SUCCESS) {
         return ctx->rc;
       }
     }
-    *value = GRN_BULK_HEAD(column->src_bufs[i]);
-  }
-  return GRN_SUCCESS;
-}
-
-// -- old... --
-
-grn_rc grngo_find_table(grn_ctx *ctx, const char *name, size_t name_len,
-                        grn_obj **table) {
-  if (!ctx || !name || !table) {
-    return GRN_INVALID_ARGUMENT;
-  }
-  grn_obj *obj = grn_ctx_get(ctx, name, name_len);
-  if (!obj) {
-    if (ctx->rc != GRN_SUCCESS) {
-      return ctx->rc;
-    }
-    return GRN_UNKNOWN_ERROR;
-  }
-  if (!grn_obj_is_table(ctx, obj)) {
-    grn_obj_unlink(ctx, obj);
-    return GRN_INVALID_FORMAT;
   }
-  *table = obj;
+  *next_ids = (const grn_id *)GRN_BULK_HEAD(src_buf);
+  *next_n_ids = grn_vector_size(ctx, src_buf);
   return GRN_SUCCESS;
 }
 
-grn_rc grngo_table_get_name(grn_ctx *ctx, grn_obj *table, char **name) {
-  if (!ctx || !table || !grn_obj_is_table(ctx, table) || !name) {
-    return GRN_INVALID_ARGUMENT;
-  }
-  char buf[GRN_TABLE_MAX_KEY_SIZE];
-  int len = grn_obj_name(ctx, table, buf, GRN_TABLE_MAX_KEY_SIZE);
-  if (len <= 0) {
-    if (ctx->rc != GRN_SUCCESS) {
-      return ctx->rc;
-    }
-    return GRN_UNKNOWN_ERROR;
-  }
-  char *table_name = (char *)malloc(len + 1);
-  if (!table_name) {
-    return GRN_NO_MEMORY_AVAILABLE;
-  }
-  memcpy(table_name, buf, len);
-  table_name[len] = '\0';
-  *name = table_name;
-  return GRN_SUCCESS;
-}
-
-static void grngo_table_type_info_init(grngo_table_type_info *type_info) {
-  type_info->data_type = GRN_DB_VOID;
-  type_info->ref_table = NULL;
-}
-
-grn_rc grngo_table_get_key_info(grn_ctx *ctx, grn_obj *table,
-                                grngo_table_type_info *key_info) {
-  if (!ctx || !table || !grn_obj_is_table(ctx, table) || !key_info) {
-    return GRN_INVALID_ARGUMENT;
-  }
-  grngo_table_type_info_init(key_info);
-  if (table->header.type == GRN_TABLE_NO_KEY) {
-    return GRN_SUCCESS;
-  }
-  if (table->header.domain <= GRNGO_MAX_BUILTIN_TYPE_ID) {
-    key_info->data_type = table->header.domain;
-    return GRN_SUCCESS;
-  }
-  grn_obj *ref_table = grn_ctx_at(ctx, table->header.domain);
-  if (!ref_table || !grn_obj_is_table(ctx, ref_table)) {
-    if (ctx->rc != GRN_SUCCESS) {
-      return ctx->rc;
-    }
-    return GRN_UNKNOWN_ERROR;
-  }
-  key_info->ref_table = ref_table;
-  return GRN_SUCCESS;
-}
-
-grn_rc grngo_table_get_value_info(grn_ctx *ctx, grn_obj *table,
-                                  grngo_table_type_info *value_info) {
-  if (!ctx || !table || !grn_obj_is_table(ctx, table) || !value_info) {
-    return GRN_INVALID_ARGUMENT;
-  }
-  grngo_table_type_info_init(value_info);
-  grn_id range = grn_obj_get_range(ctx, table);
-  if (range <= GRNGO_MAX_BUILTIN_TYPE_ID) {
-    value_info->data_type = range;
-    return GRN_SUCCESS;
-  }
-  grn_obj *ref_table = grn_ctx_at(ctx, range);
-  if (!ref_table || !grn_obj_is_table(ctx, ref_table)) {
-    if (ctx->rc != GRN_SUCCESS) {
-      return ctx->rc;
-    }
-    return GRN_UNKNOWN_ERROR;
-  }
-  value_info->ref_table = ref_table;
-  return GRN_SUCCESS;
-}
-
-static void grngo_column_type_info_init(grngo_column_type_info *type_info) {
-  type_info->data_type = GRN_DB_VOID;
-  type_info->is_vector = GRN_FALSE;
-  type_info->ref_table = NULL;
-}
-
-grn_rc grngo_column_get_value_info(grn_ctx *ctx, grn_obj *column,
-                                   grngo_column_type_info *value_info) {
-  if (!ctx || !column || !value_info) {
-    return GRN_INVALID_ARGUMENT;
-  }
-  grngo_column_type_info_init(value_info);
-  switch (column->header.type) {
-    case GRN_COLUMN_FIX_SIZE: {
-      break;
-    }
-    case GRN_COLUMN_VAR_SIZE: {
-      grn_obj_flags type = column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK;
-      if (type == GRN_OBJ_COLUMN_VECTOR) {
-        value_info->is_vector = GRN_TRUE;
-      }
-      break;
-    }
-    default: {
-      return GRN_INVALID_ARGUMENT;
-    }
-  }
-  grn_id range = grn_obj_get_range(ctx, column);
-  if (range <= GRNGO_MAX_BUILTIN_TYPE_ID) {
-    value_info->data_type = range;
-    return GRN_SUCCESS;
-  }
-  grn_obj *ref_table = grn_ctx_at(ctx, range);
-  if (!ref_table || !grn_obj_is_table(ctx, ref_table)) {
-    if (ctx->rc != GRN_SUCCESS) {
-      return ctx->rc;
-    }
-    return GRN_UNKNOWN_ERROR;
-  }
-  value_info->ref_table = ref_table;
-  return GRN_SUCCESS;
-}
-
-// grngo_table_insertion_error generates an error result.
-static grngo_table_insertion_result grngo_table_insertion_error(grn_rc rc) {
-  grngo_table_insertion_result result;
-  result.rc = rc;
-  result.inserted = GRN_FALSE;
-  result.id = GRN_ID_NIL;
-  return result;
-}
-
-// grngo_table_insert_row calls grn_table_add to insert a row.
-static grngo_table_insertion_result grngo_table_insert_row(
-    grn_ctx *ctx, grn_obj *table, const void *key, size_t key_size) {
-  if (!ctx || !table || !grn_obj_is_table(ctx, table) ||
-      (!key && (key_size != 0))) {
-    return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
-  }
-  int inserted;
-  grn_id id = grn_table_add(ctx, table, key, key_size, &inserted);
-  if (id == GRN_ID_NIL) {
-    if (ctx->rc != GRN_SUCCESS) {
-      return grngo_table_insertion_error(ctx->rc);
-    }
-    return grngo_table_insertion_error(GRN_UNKNOWN_ERROR);
-  }
-  grngo_table_insertion_result result;
-  result.rc = GRN_SUCCESS;
-  result.inserted = (grn_bool)inserted;
-  result.id = id;
-  return result;
-}
-
-grngo_table_insertion_result grngo_table_insert_void(
-    grn_ctx *ctx, grn_obj *table) {
-  return grngo_table_insert_row(ctx, table, NULL, 0);
-}
-
-grngo_table_insertion_result grngo_table_insert_bool(
-    grn_ctx *ctx, grn_obj *table, grn_bool key) {
-  return grngo_table_insert_row(ctx, table, &key, sizeof(key));
-}
-
-grngo_table_insertion_result grngo_table_insert_int(
-    grn_ctx *ctx, grn_obj *table, grn_builtin_type builtin_type, int64_t key) {
-  switch (builtin_type) {
-    case GRN_DB_INT8: {
-      if ((key < INT8_MIN) || (key > INT8_MAX)) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
+static grn_rc
+_grngo_get_value(grngo_column *column, const grn_id *ids, size_t n_ids) {
+  grn_ctx *ctx = column->db->ctx;
+  size_t src_id = column->n_srcs - 1;
+  grn_obj *src = column->srcs[src_id];
+  grn_obj *src_buf = column->src_bufs[src_id];
+  GRN_BULK_REWIND(src_buf);
+  if (_grngo_is_vector(src)) {
+    size_t i;
+    size_t offset = 0;
+    for (i = 0; i < n_ids; i++) {
+      grn_obj_get_value(ctx, src, ids[i], src_buf);
+      if (ctx->rc != GRN_SUCCESS) {
+        return ctx->rc;
       }
-      int8_t tmp_key = (int8_t)key;
-      return grngo_table_insert_row(ctx, table, &tmp_key, sizeof(tmp_key));
-    }
-    case GRN_DB_INT16: {
-      if ((key < INT16_MIN) || (key > INT16_MAX)) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
+      size_t size = grn_vector_size(ctx, src_buf);
+      grngo_vector vector = { NULL, size - offset };
+      grn_rc rc = grn_bulk_write(ctx, column->vector_buf,
+                                 (char *)&vector, sizeof(vector));
+      if (rc != GRN_SUCCESS) {
+        return rc;
       }
-      int16_t tmp_key = (int16_t)key;
-      return grngo_table_insert_row(ctx, table, &tmp_key, sizeof(tmp_key));
+      offset = size;
     }
-    case GRN_DB_INT32: {
-      if ((key < INT32_MIN) || (key > INT32_MAX)) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
+    if (column->text_buf) {
+      size_t n_texts = offset;
+      for (i = 0; i < n_texts; i++) {
+        grngo_text text;
+        text.size = grn_vector_get_element(ctx, src_buf, i,
+                                           &text.ptr, NULL, NULL);
+        grn_rc rc = grn_bulk_write(ctx, column->text_buf,
+                                   (char *)&text, sizeof(text));
+        if (rc != GRN_SUCCESS) {
+          return rc;
+        }
       }
-      int32_t tmp_key = (int32_t)key;
-      return grngo_table_insert_row(ctx, table, &tmp_key, sizeof(tmp_key));
-    }
-    case GRN_DB_INT64:
-    case GRN_DB_TIME: {
-      return grngo_table_insert_row(ctx, table, &key, sizeof(key));
     }
-    case GRN_DB_UINT8: {
-      if ((key < 0) || (key > (int64_t)UINT8_MAX)) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
+  } else if (column->text_buf) {
+    GRN_BULK_REWIND(column->text_buf);
+    size_t i;
+    size_t offset = 0;
+    for (i = 0; i < n_ids; i++) {
+      grn_obj_get_value(ctx, src, ids[i], src_buf);
+      if (ctx->rc != GRN_SUCCESS) {
+        return ctx->rc;
       }
-      uint8_t tmp_key = (uint8_t)key;
-      return grngo_table_insert_row(ctx, table, &tmp_key, sizeof(tmp_key));
-    }
-    case GRN_DB_UINT16: {
-      if ((key < 0) || (key > (int64_t)UINT16_MAX)) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
+      size_t size = GRN_BULK_VSIZE(src_buf);
+      grngo_text text = { NULL, size - offset };
+      grn_rc rc = grn_bulk_write(ctx, column->text_buf,
+                                 (char *)&text, sizeof(text));
+      if (rc != GRN_SUCCESS) {
+        return rc;
       }
-      uint16_t tmp_key = (uint16_t)key;
-      return grngo_table_insert_row(ctx, table, &tmp_key, sizeof(tmp_key));
+      offset = size;
     }
-    case GRN_DB_UINT32: {
-      if ((key < 0) || (key > (int64_t)UINT32_MAX)) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
-      }
-      uint32_t tmp_key = (uint32_t)key;
-      return grngo_table_insert_row(ctx, table, &tmp_key, sizeof(tmp_key));
+    char *ptr = GRN_BULK_HEAD(src_buf);
+    grngo_text *texts = (grngo_text *)GRN_BULK_HEAD(column->text_buf);
+    for (i = 0; i < n_ids; i++) {
+      texts[i].ptr = ptr;
+      ptr += texts[i].size;
     }
-    case GRN_DB_UINT64: {
-      if (key < 0) {
-        return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
+  } else {
+    size_t i;
+    for (i = 0; i < n_ids; i++) {
+      grn_obj_get_value(ctx, src, ids[i], src_buf);
+      if (ctx->rc != GRN_SUCCESS) {
+        return ctx->rc;
       }
-      return grngo_table_insert_row(ctx, table, &key, sizeof(key));
     }
-    default: {
-      return grngo_table_insertion_error(GRN_UNKNOWN_ERROR);
-    }
-  }
-}
-
-grngo_table_insertion_result grngo_table_insert_float(
-    grn_ctx *ctx, grn_obj *table, double key) {
-  if (isnan(key)) {
-    return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
   }
-  return grngo_table_insert_row(ctx, table, &key, sizeof(key));
-}
-
-grngo_table_insertion_result grngo_table_insert_text(
-    grn_ctx *ctx, grn_obj *table, const grngo_text *key) {
-  if (!key || (!key->ptr && (key->size != 0))) {
-    return grngo_table_insertion_error(GRN_INVALID_ARGUMENT);
-  }
-  return grngo_table_insert_row(ctx, table, key->ptr, key->size);
-}
-
-grngo_table_insertion_result grngo_table_insert_geo_point(
-    grn_ctx *ctx, grn_obj *table, const grn_geo_point *key) {
-  return grngo_table_insert_row(ctx, table, key, sizeof(*key));
-}
-
-grn_bool grngo_column_set_bool(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, grn_bool value) {
-  grn_obj obj;
-  GRN_BOOL_INIT(&obj, 0);
-  GRN_BOOL_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int8(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, int8_t value) {
-  grn_obj obj;
-  GRN_INT8_INIT(&obj, 0);
-  GRN_INT8_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int16(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, int16_t value) {
-  grn_obj obj;
-  GRN_INT16_INIT(&obj, 0);
-  GRN_INT16_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int32(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, int32_t value) {
-  grn_obj obj;
-  GRN_INT32_INIT(&obj, 0);
-  GRN_INT32_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int64(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, int64_t value) {
-  grn_obj obj;
-  GRN_INT64_INIT(&obj, 0);
-  GRN_INT64_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint8(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, uint8_t value) {
-  grn_obj obj;
-  GRN_UINT8_INIT(&obj, 0);
-  GRN_UINT8_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint16(grn_ctx *ctx, grn_obj *column,
-                                 grn_id id, uint16_t value) {
-  grn_obj obj;
-  GRN_UINT16_INIT(&obj, 0);
-  GRN_UINT16_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint32(grn_ctx *ctx, grn_obj *column,
-                                 grn_id id, uint32_t value) {
-  grn_obj obj;
-  GRN_UINT32_INIT(&obj, 0);
-  GRN_UINT32_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint64(grn_ctx *ctx, grn_obj *column,
-                                 grn_id id, uint64_t value) {
-  grn_obj obj;
-  GRN_UINT64_INIT(&obj, 0);
-  GRN_UINT64_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_time(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, int64_t value) {
-  grn_obj obj;
-  GRN_TIME_INIT(&obj, 0);
-  GRN_TIME_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_float(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, double value) {
-  grn_obj obj;
-  GRN_FLOAT_INIT(&obj, 0);
-  GRN_FLOAT_SET(ctx, &obj, value);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_text(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, const grngo_text *value) {
-  grn_obj obj;
-  GRN_TEXT_INIT(&obj, 0);
-  if (value) {
-    GRN_TEXT_SET(ctx, &obj, value->ptr, value->size);
-  } else {
-    GRN_TEXT_SET(ctx, &obj, NULL, 0);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_geo_point(grn_ctx *ctx, grn_obj *column,
-                                    grn_builtin_type data_type,
-                                    grn_id id, grn_geo_point value) {
-  grn_obj obj;
-  if (data_type == GRN_DB_TOKYO_GEO_POINT) {
-    GRN_TOKYO_GEO_POINT_INIT(&obj, 0);
-  } else {
-    GRN_WGS84_GEO_POINT_INIT(&obj, 0);
-  }
-  GRN_GEO_POINT_SET(ctx, &obj, value.latitude, value.longitude);
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_bool_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value) {
-  grn_obj obj;
-  GRN_BOOL_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_BOOL_SET_AT(ctx, &obj, i, ((const grn_bool *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int8_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value) {
-  grn_obj obj;
-  GRN_INT8_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_INT8_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int16_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value) {
-  grn_obj obj;
-  GRN_INT16_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_INT16_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int32_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value) {
-  grn_obj obj;
-  GRN_INT32_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_INT32_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_int64_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value) {
-  grn_obj obj;
-  GRN_INT64_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_INT64_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint8_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value) {
-  grn_obj obj;
-  GRN_UINT8_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_UINT8_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint16_vector(grn_ctx *ctx, grn_obj *column,
-                                        grn_id id,
-                                        const grngo_vector *value) {
-  grn_obj obj;
-  GRN_UINT16_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_UINT16_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint32_vector(grn_ctx *ctx, grn_obj *column,
-                                        grn_id id,
-                                        const grngo_vector *value) {
-  grn_obj obj;
-  GRN_UINT32_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_UINT32_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_uint64_vector(grn_ctx *ctx, grn_obj *column,
-                                        grn_id id,
-                                        const grngo_vector *value) {
-  grn_obj obj;
-  GRN_UINT64_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_UINT64_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_time_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value) {
-  grn_obj obj;
-  GRN_TIME_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_TIME_SET_AT(ctx, &obj, i, ((const int64_t *)value->ptr)[i]);
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
+  return GRN_SUCCESS;
 }
 
-grn_bool grngo_column_set_float_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value) {
-  grn_obj obj;
-  GRN_FLOAT_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  for (i = 0; i < value->size; i++) {
-    GRN_FLOAT_SET_AT(ctx, &obj, i, ((const double *)value->ptr)[i]);
+grn_rc
+grngo_get(grngo_column *column, grn_id id, void **value) {
+  if (!column || !value) {
+    return GRN_INVALID_ARGUMENT;
   }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_text_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value) {
-  grn_obj obj;
-  GRN_TEXT_INIT(&obj, GRN_OBJ_VECTOR);
-  size_t i;
-  const grngo_text *values = (const grngo_text *)value->ptr;
-  for (i = 0; i < value->size; i++) {
-    grn_vector_add_element(ctx, &obj, values[i].ptr, values[i].size,
-                           0, obj.header.domain);
+  grn_ctx *ctx = column->db->ctx;
+  if (grn_table_at(ctx, column->table->obj, id) == GRN_ID_NIL) {
+    return GRN_INVALID_ARGUMENT;
   }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_set_geo_point_vector(grn_ctx *ctx, grn_obj *column,
-                                           grn_builtin_type data_type,
-                                           grn_id id,
-                                           const grngo_vector *value) {
-  grn_obj obj;
-  if (data_type == GRN_DB_TOKYO_GEO_POINT) {
-    GRN_TOKYO_GEO_POINT_INIT(&obj, GRN_OBJ_VECTOR);
-  } else {
-    GRN_WGS84_GEO_POINT_INIT(&obj, GRN_OBJ_VECTOR);
+  if (column->vector_buf) {
+    GRN_BULK_REWIND(column->vector_buf);
   }
+  const grn_id *ids = &id;
+  size_t n_ids = 1;
   size_t i;
-  const grn_geo_point *values = (const grn_geo_point *)value->ptr;
-  for (i = 0; i < value->size; i++) {
-    grn_bulk_write(ctx, &obj, (const char *)&values[i], sizeof(values[i]));
-  }
-  grn_rc rc = grn_obj_set_value(ctx, column, id, &obj, GRN_OBJ_SET);
-  GRN_OBJ_FIN(ctx, &obj);
-  return rc == GRN_SUCCESS;
-}
-
-grn_bool grngo_column_get_bool(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, grn_bool *value) {
-  grn_obj value_obj;
-  GRN_BOOL_INIT(&value_obj, 0);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  *value = GRN_BOOL_VALUE(&value_obj);
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_int(grn_ctx *ctx, grn_obj *column,
-                              grn_builtin_type data_type,
-                              grn_id id, int64_t *value) {
-  grn_obj value_obj;
-  switch (data_type) {
-    case GRN_DB_INT8: {
-      GRN_INT8_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_INT8_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_INT16: {
-      GRN_INT16_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_INT16_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_INT32: {
-      GRN_INT32_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_INT32_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_INT64: {
-      GRN_INT64_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_INT64_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_UINT8: {
-      GRN_UINT8_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_UINT8_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_UINT16: {
-      GRN_UINT16_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_UINT16_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_UINT32: {
-      GRN_UINT32_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_UINT32_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_UINT64: {
-      GRN_UINT64_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_UINT64_VALUE(&value_obj);
-      break;
-    }
-    case GRN_DB_TIME: {
-      GRN_TIME_INIT(&value_obj, 0);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      *value = GRN_TIME_VALUE(&value_obj);
-      break;
+  for (i = 0; i < (column->n_srcs - 1); i++) {
+    grn_rc rc = _grngo_get_ref(column, i, ids, n_ids, &ids, &n_ids);
+    if (rc != GRN_SUCCESS) {
+      return rc;
     }
   }
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_float(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, double *value) {
-  grn_obj value_obj;
-  GRN_FLOAT_INIT(&value_obj, 0);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  *value = GRN_FLOAT_VALUE(&value_obj);
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_text(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, grngo_text *value) {
-  grn_obj value_obj;
-  GRN_TEXT_INIT(&value_obj, 0);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  size_t size = GRN_TEXT_LEN(&value_obj);
-  if (size <= value->size) {
-    memcpy(value->ptr, GRN_TEXT_VALUE(&value_obj), size);
-  }
-  value->size = size;
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_geo_point(grn_ctx *ctx, grn_obj *column,
-                                    grn_id id, grn_geo_point *value) {
-  grn_obj value_obj;
-  GRN_WGS84_GEO_POINT_INIT(&value_obj, 0);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  GRN_GEO_POINT_VALUE(&value_obj, value->latitude, value->longitude);
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_bool_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id, grngo_vector *value) {
-  grn_obj value_obj;
-  GRN_BOOL_INIT(&value_obj, GRN_OBJ_VECTOR);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-  size_t size = size_in_bytes / sizeof(grn_bool);
-  if (size <= value->size) {
-    memcpy(value->ptr, GRN_BULK_HEAD(&value_obj), size_in_bytes);
-  }
-  value->size = size;
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_int_vector(grn_ctx *ctx, grn_obj *column,
-                                     grn_builtin_type data_type,
-                                     grn_id id, grngo_vector *value) {
-  grn_obj value_obj;
-  switch (data_type) {
-    case GRN_DB_INT8: {
-      GRN_INT8_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(int8_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_INT8_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_INT16: {
-      GRN_INT16_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(int16_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_INT16_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_INT32: {
-      GRN_INT32_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(int32_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_INT32_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_INT64: {
-      GRN_INT64_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(int64_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_INT64_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_UINT8: {
-      GRN_UINT8_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(uint8_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_UINT8_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_UINT16: {
-      GRN_UINT16_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(uint16_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_UINT16_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_UINT32: {
-      GRN_UINT32_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(uint32_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_UINT32_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_UINT64: {
-      GRN_UINT64_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(uint64_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_UINT64_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
-    case GRN_DB_TIME: {
-      GRN_TIME_INIT(&value_obj, GRN_OBJ_VECTOR);
-      grn_obj_get_value(ctx, column, id, &value_obj);
-      size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-      size_t size = size_in_bytes / sizeof(int64_t);
-      if (size <= value->size) {
-        size_t i;
-        for (i = 0; i < size; i++) {
-          ((int64_t *)value->ptr)[i] = GRN_TIME_VALUE_AT(&value_obj, i);
-        }
-      }
-      value->size = size;
-      break;
-    }
+  grn_rc rc = _grngo_get_value(column, ids, n_ids);
+  if (rc != GRN_SUCCESS) {
+    return GRN_SUCCESS;
   }
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_float_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id, grngo_vector *value) {
-  grn_obj value_obj;
-  GRN_FLOAT_INIT(&value_obj, GRN_OBJ_VECTOR);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-  size_t size = size_in_bytes / sizeof(double);
-  if (size <= value->size) {
-    memcpy(value->ptr, GRN_BULK_HEAD(&value_obj), size_in_bytes);
-  }
-  value->size = size;
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_text_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id, grngo_vector *value) {
-  grn_obj value_obj;
-  GRN_TEXT_INIT(&value_obj, GRN_OBJ_VECTOR);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  size_t size = grn_vector_size(ctx, &value_obj);
-  if (size <= value->size) {
-    size_t i;
-    for (i = 0; i < size; i++) {
-      // NOTE: grn_vector_get_element() assigns the address of the text body
-      //       to text_ptr, but the body may be overwritten in the next call.
-      const char *text_ptr;
-      unsigned int text_size = grn_vector_get_element(ctx, &value_obj, i,
-                                                      &text_ptr, NULL, NULL);
-      grngo_text *text = &((grngo_text *)value->ptr)[i];
-      if (text_size <= text->size) {
-        memcpy(text->ptr, text_ptr, text_size);
-      }
-      text->size = text_size;
+  if (column->dimension != 0) {
+    // TODO
+    grngo_vector *vectors = (grngo_vector *)GRN_BULK_HEAD(column->vector_buf);
+    if (column->text_buf) {
+      vectors[0].ptr = GRN_BULK_HEAD(column->text_buf);
+    } else {
+      vectors[0].ptr = GRN_BULK_HEAD(column->src_bufs[i]);
     }
+    *value = GRN_BULK_HEAD(column->vector_buf);
+  } else if (column->text_buf) {
+    *value = GRN_BULK_HEAD(column->text_buf);
+  } else {
+    *value = GRN_BULK_HEAD(column->src_bufs[i]);
   }
-  value->size = size;
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
-}
-
-grn_bool grngo_column_get_geo_point_vector(grn_ctx *ctx, grn_obj *column,
-                                           grn_id id, grngo_vector *value) {
-  grn_obj value_obj;
-  GRN_WGS84_GEO_POINT_INIT(&value_obj, GRN_OBJ_VECTOR);
-  grn_obj_get_value(ctx, column, id, &value_obj);
-  size_t size_in_bytes = GRN_BULK_VSIZE(&value_obj);
-  size_t size = size_in_bytes / sizeof(grn_geo_point);
-  if (size <= value->size) {
-    memcpy(value->ptr, GRN_BULK_HEAD(&value_obj), size_in_bytes);
-  }
-  value->size = size;
-  GRN_OBJ_FIN(ctx, &value_obj);
-  return GRN_TRUE;
+  return GRN_SUCCESS;
 }

  Modified: grngo.go (+134 -242)
===================================================================
--- grngo.go    2015-07-24 15:48:53 +0900 (a5936b4)
+++ grngo.go    2015-07-24 18:55:05 +0900 (5b82f54)
@@ -1042,254 +1042,146 @@ func (column *Column) SetValue(id uint32, value interface{}) error {
 
 // GetValue gets a value.
 func (column *Column) GetValue(id uint32) (interface{}, error) {
-	if column.c.dimension != 0 {
-		return nil, fmt.Errorf("Vector is not supported yet")
+	if column.c.dimension > 1 {
+		return nil, fmt.Errorf("Deep vectors are not supported yet")
 	}
 	var ptr unsafe.Pointer
 	rc := C.grngo_get(column.c, C.grn_id(id), &ptr)
 	if rc != C.GRN_SUCCESS {
 		return nil, newGrnError("grngo_get()", rc, column.table.db)
 	}
-	switch column.c.value_type {
-	case C.GRN_DB_BOOL:
-		cValue := *(*C.grn_bool)(ptr)
-		return cValue == C.GRN_TRUE, nil
-	case C.GRN_DB_INT8:
-		return int64(*(*C.int8_t)(ptr)), nil
-	case C.GRN_DB_INT16:
-		return int64(*(*C.int16_t)(ptr)), nil
-	case C.GRN_DB_INT32:
-		return int64(*(*C.int32_t)(ptr)), nil
-	case C.GRN_DB_INT64:
-		return int64(*(*C.int64_t)(ptr)), nil
-	case C.GRN_DB_UINT8:
-		return int64(*(*C.uint8_t)(ptr)), nil
-	case C.GRN_DB_UINT16:
-		return int64(*(*C.uint16_t)(ptr)), nil
-	case C.GRN_DB_UINT32:
-		return int64(*(*C.uint32_t)(ptr)), nil
-	case C.GRN_DB_UINT64:
-		return int64(*(*C.uint64_t)(ptr)), nil
-	case C.GRN_DB_FLOAT:
-		return float64(*(*C.double)(ptr)), nil
-	case C.GRN_DB_TIME:
-		return int64(*(*C.int64_t)(ptr)), nil
-	case C.GRN_DB_SHORT_TEXT, C.GRN_DB_TEXT, C.GRN_DB_LONG_TEXT:
-		cValue := *(*C.grngo_text)(ptr)
-		return C.GoBytes(unsafe.Pointer(cValue.ptr), C.int(cValue.size)), nil
-	case C.GRN_DB_TOKYO_GEO_POINT, C.GRN_DB_WGS84_GEO_POINT:
-		cValue := *(*C.grn_geo_point)(ptr)
-		return GeoPoint{int32(cValue.latitude), int32(cValue.longitude)}, nil
-	default:
-		return nil, fmt.Errorf("unsupported value type")
+	if column.c.dimension == 0 {
+		switch column.c.value_type {
+		case C.GRN_DB_BOOL:
+			cValue := *(*C.grn_bool)(ptr)
+			return cValue == C.GRN_TRUE, nil
+		case C.GRN_DB_INT8:
+			return int64(*(*C.int8_t)(ptr)), nil
+		case C.GRN_DB_INT16:
+			return int64(*(*C.int16_t)(ptr)), nil
+		case C.GRN_DB_INT32:
+			return int64(*(*C.int32_t)(ptr)), nil
+		case C.GRN_DB_INT64:
+			return int64(*(*C.int64_t)(ptr)), nil
+		case C.GRN_DB_UINT8:
+			return int64(*(*C.uint8_t)(ptr)), nil
+		case C.GRN_DB_UINT16:
+			return int64(*(*C.uint16_t)(ptr)), nil
+		case C.GRN_DB_UINT32:
+			return int64(*(*C.uint32_t)(ptr)), nil
+		case C.GRN_DB_UINT64:
+			return int64(*(*C.uint64_t)(ptr)), nil
+		case C.GRN_DB_FLOAT:
+			return float64(*(*C.double)(ptr)), nil
+		case C.GRN_DB_TIME:
+			return int64(*(*C.int64_t)(ptr)), nil
+		case C.GRN_DB_SHORT_TEXT, C.GRN_DB_TEXT, C.GRN_DB_LONG_TEXT:
+			cValue := *(*C.grngo_text)(ptr)
+			return C.GoBytes(unsafe.Pointer(cValue.ptr), C.int(cValue.size)), nil
+		case C.GRN_DB_TOKYO_GEO_POINT, C.GRN_DB_WGS84_GEO_POINT:
+			cValue := *(*C.grn_geo_point)(ptr)
+			return GeoPoint{int32(cValue.latitude), int32(cValue.longitude)}, nil
+		default:
+			return nil, fmt.Errorf("unsupported value type")
+		}
+	} else {
+		cVector := *(*C.grngo_vector)(ptr)
+    header := reflect.SliceHeader{
+			Data: uintptr(unsafe.Pointer(cVector.ptr)),
+			Len:  int(cVector.size),
+			Cap:  int(cVector.size),
+    }
+		switch column.c.value_type {
+		case C.GRN_DB_BOOL:
+      cValue := *(*[]C.grn_bool)(unsafe.Pointer(&header))
+			value := make([]bool, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = cValue[i] == C.GRN_TRUE
+			}
+			return value, nil
+		case C.GRN_DB_INT8:
+      cValue := *(*[]C.int8_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_INT16:
+      cValue := *(*[]C.int16_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_INT32:
+      cValue := *(*[]C.int32_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_INT64:
+      cValue := *(*[]C.int64_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_UINT8:
+      cValue := *(*[]C.uint8_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_UINT16:
+      cValue := *(*[]C.uint16_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_UINT32:
+      cValue := *(*[]C.uint32_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_UINT64:
+      cValue := *(*[]C.uint64_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_FLOAT:
+      cValue := *(*[]C.double)(unsafe.Pointer(&header))
+			value := make([]float64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = float64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_TIME:
+      cValue := *(*[]C.int64_t)(unsafe.Pointer(&header))
+			value := make([]int64, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i] = int64(cValue[i])
+			}
+			return value, nil
+		case C.GRN_DB_SHORT_TEXT, C.GRN_DB_TEXT, C.GRN_DB_LONG_TEXT:
+			return nil, fmt.Errorf("not supported yet")
+		case C.GRN_DB_TOKYO_GEO_POINT, C.GRN_DB_WGS84_GEO_POINT:
+      cValue := *(*[]C.grn_geo_point)(unsafe.Pointer(&header))
+			value := make([]GeoPoint, len(cValue))
+			for i := 0; i < len(value); i++ {
+				value[i].Latitude = int32(cValue[i].latitude)
+				value[i].Longitude = int32(cValue[i].longitude)
+			}
+			return value, nil
+		default:
+			return nil, fmt.Errorf("unsupported value type")
+		}
 	}
 	return nil, fmt.Errorf("unknown error")
 }
-
-//// getBool gets a Bool value.
-//func (column *Column) getBool(id uint32) (interface{}, error) {
-//	var grnValue C.grn_bool
-//	if ok := C.grngo_column_get_bool(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_bool() failed")
-//	}
-//	return grnValue == C.GRN_TRUE, nil
-//}
-
-//// getInt gets an Int value.
-//func (column *Column) getInt(id uint32) (interface{}, error) {
-//	var grnValue C.int64_t
-//	if ok := C.grngo_column_get_int(column.table.db.ctx, column.obj,
-//		C.grn_builtin_type(column.valueType),
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_int() failed")
-//	}
-//	return int64(grnValue), nil
-//}
-
-//// getFloat gets a Float value.
-//func (column *Column) getFloat(id uint32) (interface{}, error) {
-//	var grnValue C.double
-//	if ok := C.grngo_column_get_float(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_float() failed")
-//	}
-//	return float64(grnValue), nil
-//}
-
-//// getText gets a Text value.
-//func (column *Column) getText(id uint32) (interface{}, error) {
-//	var grnValue C.grngo_text
-//	if ok := C.grngo_column_get_text(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_text() failed")
-//	}
-//	if grnValue.size == 0 {
-//		return make([]byte, 0), nil
-//	}
-//	value := make([]byte, int(grnValue.size))
-//	grnValue.ptr = (*C.char)(unsafe.Pointer(&value[0]))
-//	if ok := C.grngo_column_get_text(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_text() failed")
-//	}
-//	return value, nil
-//}
-
-//// getGeoPoint gets a GeoPoint value.
-//func (column *Column) getGeoPoint(id uint32) (interface{}, error) {
-//	var grnValue C.grn_geo_point
-//	if ok := C.grngo_column_get_geo_point(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_geo_point() failed")
-//	}
-//	return GeoPoint{int32(grnValue.latitude), int32(grnValue.longitude)}, nil
-//}
-
-//// getBoolVector gets a BoolVector.
-//func (column *Column) getBoolVector(id uint32) (interface{}, error) {
-//	var grnVector C.grngo_vector
-//	if ok := C.grngo_column_get_bool_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnVector); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_bool_vector() failed")
-//	}
-//	if grnVector.size == 0 {
-//		return make([]bool, 0), nil
-//	}
-//	grnValue := make([]C.grn_bool, int(grnVector.size))
-//	grnVector.ptr = unsafe.Pointer(&grnValue[0])
-//	if ok := C.grngo_column_get_bool_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnVector); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_bool_vector() failed")
-//	}
-//	value := make([]bool, int(grnVector.size))
-//	for i, v := range grnValue {
-//		value[i] = (v == C.GRN_TRUE)
-//	}
-//	return value, nil
-//}
-
-//// getIntVector gets a IntVector.
-//func (column *Column) getIntVector(id uint32) (interface{}, error) {
-//	var grnValue C.grngo_vector
-//	if ok := C.grngo_column_get_int_vector(column.table.db.ctx, column.obj,
-//		C.grn_builtin_type(column.valueType),
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_int_vector() failed")
-//	}
-//	if grnValue.size == 0 {
-//		return make([]int64, 0), nil
-//	}
-//	value := make([]int64, int(grnValue.size))
-//	grnValue.ptr = unsafe.Pointer(&value[0])
-//	if ok := C.grngo_column_get_int_vector(column.table.db.ctx, column.obj,
-//		C.grn_builtin_type(column.valueType),
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_int_vector() failed")
-//	}
-//	return value, nil
-//}
-
-//// getFloatVector gets a FloatVector.
-//func (column *Column) getFloatVector(id uint32) (interface{}, error) {
-//	var grnValue C.grngo_vector
-//	if ok := C.grngo_column_get_float_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_float_vector() failed")
-//	}
-//	if grnValue.size == 0 {
-//		return make([]float64, 0), nil
-//	}
-//	value := make([]float64, int(grnValue.size))
-//	grnValue.ptr = unsafe.Pointer(&value[0])
-//	if ok := C.grngo_column_get_float_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_float_vector() failed")
-//	}
-//	return value, nil
-//}
-
-//// getTextVector gets a TextVector.
-//func (column *Column) getTextVector(id uint32) (interface{}, error) {
-//	var grnVector C.grngo_vector
-//	if ok := C.grngo_column_get_text_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnVector); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_text_vector() failed")
-//	}
-//	if grnVector.size == 0 {
-//		return make([][]byte, 0), nil
-//	}
-//	grnValues := make([]C.grngo_text, int(grnVector.size))
-//	grnVector.ptr = unsafe.Pointer(&grnValues[0])
-//	if ok := C.grngo_column_get_text_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnVector); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_text_vector() failed")
-//	}
-//	value := make([][]byte, int(grnVector.size))
-//	for i, grnValue := range grnValues {
-//		if grnValue.size != 0 {
-//			value[i] = make([]byte, int(grnValue.size))
-//			grnValues[i].ptr = (*C.char)(unsafe.Pointer(&value[i][0]))
-//		}
-//	}
-//	if ok := C.grngo_column_get_text_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnVector); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_text_vector() failed")
-//	}
-//	return value, nil
-//}
-
-//// getGeoPointVector gets a GeoPointVector.
-//func (column *Column) getGeoPointVector(id uint32) (interface{}, error) {
-//	var grnValue C.grngo_vector
-//	if ok := C.grngo_column_get_geo_point_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_geo_point_vector() failed")
-//	}
-//	if grnValue.size == 0 {
-//		return make([]GeoPoint, 0), nil
-//	}
-//	value := make([]GeoPoint, int(grnValue.size))
-//	grnValue.ptr = unsafe.Pointer(&value[0])
-//	if ok := C.grngo_column_get_geo_point_vector(column.table.db.ctx, column.obj,
-//		C.grn_id(id), &grnValue); ok != C.GRN_TRUE {
-//		return nil, fmt.Errorf("grngo_column_get_geo_point_vector() failed")
-//	}
-//	return value, nil
-//}
-
-//// GetValue gets a value.
-//func (column *Column) GetValue(id uint32) (interface{}, error) {
-//	if !column.isVector {
-//		switch column.valueType {
-//		case Bool:
-//			return column.getBool(id)
-//		case Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64:
-//			return column.getInt(id)
-//		case Float:
-//			return column.getFloat(id)
-//		case Time:
-//			return column.getInt(id)
-//		case ShortText, Text, LongText:
-//			return column.getText(id)
-//		case TokyoGeoPoint, WGS84GeoPoint:
-//			return column.getGeoPoint(id)
-//		}
-//	} else {
-//		switch column.valueType {
-//		case Bool:
-//			return column.getBoolVector(id)
-//		case Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64:
-//			return column.getIntVector(id)
-//		case Float:
-//			return column.getFloatVector(id)
-//		case Time:
-//			return column.getIntVector(id)
-//		case ShortText, Text, LongText:
-//			return column.getTextVector(id)
-//		case TokyoGeoPoint, WGS84GeoPoint:
-//			return column.getGeoPointVector(id)
-//		}
-//	}
-//	return nil, fmt.Errorf("undefined value type: valueType = %d", column.valueType)
-//}

  Modified: grngo.h (+4 -194)
===================================================================
--- grngo.h    2015-07-24 15:48:53 +0900 (69490b1)
+++ grngo.h    2015-07-24 18:55:05 +0900 (7a23a58)
@@ -15,13 +15,13 @@ extern "C" {
 // -- miscellaneous --
 
 typedef struct {
-  char   *ptr;
-  size_t size;
+  const char *ptr;
+  size_t     size;
 } grngo_text;
 
 typedef struct {
-  void   *ptr;
-  size_t size;
+  const void *ptr;
+  size_t     size;
 } grngo_vector;
 
 // -- grngo_db --
@@ -102,196 +102,6 @@ grn_rc grngo_set_geo_point_vector(grngo_column *column, grn_id id,
 
 grn_rc grngo_get(grngo_column *column, grn_id id, void **value);
 
-// -- old... --
-
-// grngo_find_table finds a table.
-grn_rc grngo_find_table(grn_ctx *ctx, const char *name, size_t name_len,
-                        grn_obj **table);
-// grngo_table_get_name gets the name (zero-terminated) of a table.
-// The address of the name is written to **name.
-// Note that the name must be freed by free().
-grn_rc grngo_table_get_name(grn_ctx *ctx, grn_obj *table, char **name);
-
-typedef struct {
-  grn_builtin_type data_type;  // Data type (GRN_DB_VOID, GRN_DB_BOOL, etc.).
-                               // If the type is table reference, GRN_DB_VOID
-                               // is stored.
-  grn_obj          *ref_table; // The referenced table of table reference.
-} grngo_table_type_info;
-
-// grngo_table_get_key_info gets information of the table keys (_key).
-//
-// Note that key_info->ref_table should be unlinked by grn_obj_unlink() if it
-// is not NULL.
-grn_rc grngo_table_get_key_info(grn_ctx *ctx, grn_obj *table,
-                                grngo_table_type_info *key_info);
-// grngo_table_get_value_info gets information of the table values (_value).
-//
-// Note that value_info->ref_table should be unlinked by grn_obj_unlink() if it
-// is not NULL.
-grn_rc grngo_table_get_value_info(grn_ctx *ctx, grn_obj *table,
-                                  grngo_table_type_info *value_info);
-
-typedef struct {
-  grn_builtin_type data_type;  // Data type (GRN_DB_VOID, GRN_DB_BOOL, etc.).
-                               // If the type is table reference, GRN_DB_VOID
-                               // is stored.
-  grn_bool         is_vector;  // Whether or not the data type is vector.
-  grn_obj          *ref_table; // The referenced table of table reference.
-} grngo_column_type_info;
-
-// grngo_column_get_value_info() gets information of the column values.
-//
-// Note that value_info->ref_table should be unlinked by grn_obj_unlink() if it
-// is not NULL.
-grn_rc grngo_column_get_value_info(grn_ctx *ctx, grn_obj *column,
-                                   grngo_column_type_info *value_info);
-
-typedef struct {
-  grn_rc   rc;       // rc stores a return code.
-  grn_bool inserted; // inserted stores whether a row was inserted or not.
-  grn_id   id;       // id stores the ID of an inserted or found row.
-                     // GRN_ID_NIL means that an operation failed.
-} grngo_table_insertion_result;
-
-// grngo_table_insert_void inserts an empty row.
-grngo_table_insertion_result grngo_table_insert_void(
-    grn_ctx *ctx, grn_obj *table);
-// grngo_table_insert_bool inserts a row with a Bool key.
-grngo_table_insertion_result grngo_table_insert_bool(
-    grn_ctx *ctx, grn_obj *table, grn_bool key);
-// grngo_table_insert_int inserts a row with an (U)IntXX key.
-grngo_table_insertion_result grngo_table_insert_int(
-    grn_ctx *ctx, grn_obj *table, grn_builtin_type builtin_type, int64_t key);
-// grngo_table_insert_float inserts a row with a Float key.
-grngo_table_insertion_result grngo_table_insert_float(
-    grn_ctx *ctx, grn_obj *table, double key);
-// grngo_table_insert_text inserts a row with a ShortText key.
-grngo_table_insertion_result grngo_table_insert_text(
-    grn_ctx *ctx, grn_obj *table, const grngo_text *key);
-// grngo_table_insert_geo_point inserts a row with a (Tokyo/WGS84)GeoPoint key.
-grngo_table_insertion_result grngo_table_insert_geo_point(
-    grn_ctx *ctx, grn_obj *table, const grn_geo_point *key);
-
-// grngo_column_set_bool() assigns a Bool value.
-grn_bool grngo_column_set_bool(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, grn_bool value);
-// grngo_column_set_int() assigns an Int value.
-grn_bool grngo_column_set_int8(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, int8_t value);
-grn_bool grngo_column_set_int16(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, int16_t value);
-grn_bool grngo_column_set_int32(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, int32_t value);
-grn_bool grngo_column_set_int64(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, int64_t value);
-grn_bool grngo_column_set_uint8(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, uint8_t value);
-grn_bool grngo_column_set_uint16(grn_ctx *ctx, grn_obj *column,
-                                 grn_id id, uint16_t value);
-grn_bool grngo_column_set_uint32(grn_ctx *ctx, grn_obj *column,
-                                 grn_id id, uint32_t value);
-grn_bool grngo_column_set_uint64(grn_ctx *ctx, grn_obj *column,
-                                 grn_id id, uint64_t value);
-grn_bool grngo_column_set_time(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, int64_t value);
-// grngo_column_set_float() assigns a Float value.
-grn_bool grngo_column_set_float(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, double value);
-// grngo_column_set_text() assigns a Text value.
-grn_bool grngo_column_set_text(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, const grngo_text *value);
-// grngo_column_set_geo_point() assigns a GeoPoint value.
-grn_bool grngo_column_set_geo_point(grn_ctx *ctx, grn_obj *column,
-                                    grn_builtin_type data_type,
-                                    grn_id id, grn_geo_point value);
-// grngo_column_set_bool_vector() assigns a Bool vector.
-grn_bool grngo_column_set_bool_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value);
-// grngo_column_set_int_vector() assigns an Int vector.
-grn_bool grngo_column_set_int8_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value);
-grn_bool grngo_column_set_int16_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value);
-grn_bool grngo_column_set_int32_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value);
-grn_bool grngo_column_set_int64_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value);
-grn_bool grngo_column_set_uint8_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value);
-grn_bool grngo_column_set_uint16_vector(grn_ctx *ctx, grn_obj *column,
-                                        grn_id id,
-                                        const grngo_vector *value);
-grn_bool grngo_column_set_uint32_vector(grn_ctx *ctx, grn_obj *column,
-                                        grn_id id,
-                                        const grngo_vector *value);
-grn_bool grngo_column_set_uint64_vector(grn_ctx *ctx, grn_obj *column,
-                                        grn_id id,
-                                        const grngo_vector *value);
-grn_bool grngo_column_set_time_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value);
-// grngo_column_set_float_vector() assigns a Float vector.
-grn_bool grngo_column_set_float_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id,
-                                       const grngo_vector *value);
-// grngo_column_set_text_vector() assigns a Text vector.
-// value must refer to an array of grngo_text.
-grn_bool grngo_column_set_text_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id,
-                                      const grngo_vector *value);
-// grngo_column_set_geo_point_vector() assigns a GeoPoint vector.
-grn_bool grngo_column_set_geo_point_vector(grn_ctx *ctx, grn_obj *column,
-                                           grn_builtin_type data_type,
-                                           grn_id id,
-                                           const grngo_vector *value);
-
-// grngo_column_get_X_vector() sets *(X *)(value.ptr)[i] if value->size >=
-// the actual vector size.
-// In the case of Text, bodies are copied to (X *)(value.ptr)[i].ptr if
-// (X *)(value.ptr)[i].size >= the actual body size.
-// Then, grngo_column_get_X_vector() sets value->size.
-
-// grngo_column_get_bool() gets a stored Bool value.
-grn_bool grngo_column_get_bool(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, grn_bool *value);
-// grngo_column_get_int() gets a stored Int value.
-grn_bool grngo_column_get_int(grn_ctx *ctx, grn_obj *column,
-                              grn_builtin_type data_type,
-                              grn_id id, int64_t *value);
-// grngo_column_get_float() gets a stored Float value.
-grn_bool grngo_column_get_float(grn_ctx *ctx, grn_obj *column,
-                                grn_id id, double *value);
-// grngo_column_get_text() gets a stored Text value.
-grn_bool grngo_column_get_text(grn_ctx *ctx, grn_obj *column,
-                               grn_id id, grngo_text *value);
-// grngo_column_get_geo_point() gets a stored GeoPoint value.
-grn_bool grngo_column_get_geo_point(grn_ctx *ctx, grn_obj *column,
-                                    grn_id id, grn_geo_point *value);
-// grngo_column_get_bool_vector() gets a stored Bool vector.
-grn_bool grngo_column_get_bool_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id, grngo_vector *value);
-// grngo_column_get_int_vector() gets a stored Int vector.
-grn_bool grngo_column_get_int_vector(grn_ctx *ctx, grn_obj *column,
-                                     grn_builtin_type data_type,
-                                     grn_id id, grngo_vector *value);
-// grngo_column_get_float_vector() gets a stored Float vector.
-grn_bool grngo_column_get_float_vector(grn_ctx *ctx, grn_obj *column,
-                                       grn_id id, grngo_vector *value);
-// grngo_column_get_text_vector() gets a stored Text vector.
-// value must refer to an array of grngo_text.
-grn_bool grngo_column_get_text_vector(grn_ctx *ctx, grn_obj *column,
-                                      grn_id id, grngo_vector *value);
-// grngo_column_get_geo_point_vector() gets a stored GeoPoint vector.
-grn_bool grngo_column_get_geo_point_vector(grn_ctx *ctx, grn_obj *column,
-                                           grn_id id, grngo_vector *value);
-
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

  Modified: grngo_test.go (+48 -48)
===================================================================
--- grngo_test.go    2015-07-24 15:48:53 +0900 (42e0196)
+++ grngo_test.go    2015-07-24 18:55:05 +0900 (edf1ae8)
@@ -1129,69 +1129,69 @@ func TestColumnGetValueForWGS84GeoPoint(t *testing.T) {
 	testColumnGetValue(t, "WGS84GeoPoint")
 }
 
-//func TestColumnGetValueForBoolVector(t *testing.T) {
-//	testColumnGetValue(t, "[]Bool")
-//}
+func TestColumnGetValueForBoolVector(t *testing.T) {
+	testColumnGetValue(t, "[]Bool")
+}
 
-//func TestColumnGetValueForInt8Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]Int8")
-//}
+func TestColumnGetValueForInt8Vector(t *testing.T) {
+	testColumnGetValue(t, "[]Int8")
+}
 
-//func TestColumnGetValueForInt16Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]Int16")
-//}
+func TestColumnGetValueForInt16Vector(t *testing.T) {
+	testColumnGetValue(t, "[]Int16")
+}
 
-//func TestColumnGetValueForInt32Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]Int32")
-//}
+func TestColumnGetValueForInt32Vector(t *testing.T) {
+	testColumnGetValue(t, "[]Int32")
+}
 
-//func TestColumnGetValueForInt64Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]Int64")
-//}
+func TestColumnGetValueForInt64Vector(t *testing.T) {
+	testColumnGetValue(t, "[]Int64")
+}
 
-//func TestColumnGetValueForUInt8Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]UInt8")
-//}
+func TestColumnGetValueForUInt8Vector(t *testing.T) {
+	testColumnGetValue(t, "[]UInt8")
+}
 
-//func TestColumnGetValueForUInt16Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]UInt16")
-//}
+func TestColumnGetValueForUInt16Vector(t *testing.T) {
+	testColumnGetValue(t, "[]UInt16")
+}
 
-//func TestColumnGetValueForUInt32Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]UInt32")
-//}
+func TestColumnGetValueForUInt32Vector(t *testing.T) {
+	testColumnGetValue(t, "[]UInt32")
+}
 
-//func TestColumnGetValueForUInt64Vector(t *testing.T) {
-//	testColumnGetValue(t, "[]UInt64")
-//}
+func TestColumnGetValueForUInt64Vector(t *testing.T) {
+	testColumnGetValue(t, "[]UInt64")
+}
 
-//func TestColumnGetValueForFloatVector(t *testing.T) {
-//	testColumnGetValue(t, "[]Float")
-//}
+func TestColumnGetValueForFloatVector(t *testing.T) {
+	testColumnGetValue(t, "[]Float")
+}
 
-//func TestColumnGetValueForTimeVector(t *testing.T) {
-//	testColumnGetValue(t, "[]Time")
-//}
+func TestColumnGetValueForTimeVector(t *testing.T) {
+	testColumnGetValue(t, "[]Time")
+}
 
-//func TestColumnGetValueForShortTextVector(t *testing.T) {
-//	testColumnGetValue(t, "[]ShortText")
-//}
+func TestColumnGetValueForShortTextVector(t *testing.T) {
+	testColumnGetValue(t, "[]ShortText")
+}
 
-//func TestColumnGetValueForTextVector(t *testing.T) {
-//	testColumnGetValue(t, "[]Text")
-//}
+func TestColumnGetValueForTextVector(t *testing.T) {
+	testColumnGetValue(t, "[]Text")
+}
 
-//func TestColumnGetValueForLongTextVector(t *testing.T) {
-//	testColumnGetValue(t, "[]LongText")
-//}
+func TestColumnGetValueForLongTextVector(t *testing.T) {
+	testColumnGetValue(t, "[]LongText")
+}
 
-//func TestColumnGetValueForTokyoGeoPointVector(t *testing.T) {
-//	testColumnGetValue(t, "[]TokyoGeoPoint")
-//}
+func TestColumnGetValueForTokyoGeoPointVector(t *testing.T) {
+	testColumnGetValue(t, "[]TokyoGeoPoint")
+}
 
-//func TestColumnGetValueForWGS84GeoPointVector(t *testing.T) {
-//	testColumnGetValue(t, "[]WGS84GeoPoint")
-//}
+func TestColumnGetValueForWGS84GeoPointVector(t *testing.T) {
+	testColumnGetValue(t, "[]WGS84GeoPoint")
+}
 
 // Benchmarks.
 




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