diff --git a/examples/index.c b/examples/index.c
index 9fed93b259..1c4e0936d0 100644
--- a/examples/index.c
+++ b/examples/index.c
@@ -34,7 +34,7 @@ grn_index_create(grn_ctx *ctx, const char *path)
     char buffer[PATH_MAX];
     strcpy(buffer, path);
     strcat(buffer, ".SEN");
-    if ((key_type = grn_ctx_get(ctx, GRN_DB_SHORTTEXT))) {
+    if ((key_type = grn_ctx_at(ctx, GRN_DB_SHORTTEXT))) {
       if ((keys = grn_table_create(ctx, "<keys>", 6, buffer,
                                    GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
                                    key_type, 0))) {
@@ -43,7 +43,7 @@ grn_index_create(grn_ctx *ctx, const char *path)
         if ((lexicon = grn_table_create(ctx, "<lexicon>", 9, buffer,
                                         GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
                                         key_type, 0))) {
-          if ((tokenizer = grn_ctx_get(ctx, GRN_DB_MECAB))) {
+          if ((tokenizer = grn_ctx_at(ctx, GRN_DB_MECAB))) {
             grn_obj_set_info(ctx, lexicon, GRN_INFO_DEFAULT_TOKENIZER, tokenizer);
             strcpy(buffer, path);
             strcat(buffer, ".SEN.i");
@@ -75,12 +75,12 @@ grn_index_open(grn_ctx *ctx, const char *path)
     char buffer[PATH_MAX];
     strcpy(buffer, path);
     strcat(buffer, ".SEN");
-    if ((key_type = grn_ctx_get(ctx, GRN_DB_SHORTTEXT))) {
+    if ((key_type = grn_ctx_at(ctx, GRN_DB_SHORTTEXT))) {
       if ((keys = grn_table_open(ctx, "<keys>", 6, buffer))) {
         strcpy(buffer, path);
         strcat(buffer, ".SEN.l");
         if ((lexicon = grn_table_open(ctx, "<lexicon>", 9, buffer))) {
-          if ((tokenizer = grn_ctx_get(ctx, GRN_DB_MECAB))) {
+          if ((tokenizer = grn_ctx_at(ctx, GRN_DB_MECAB))) {
             grn_obj_set_info(ctx, lexicon, GRN_INFO_DEFAULT_TOKENIZER, tokenizer);
             strcpy(buffer, path);
             strcat(buffer, ".SEN.i");
diff --git a/examples/kv.c b/examples/kv.c
index 213c5d5452..68f3b7554f 100644
--- a/examples/kv.c
+++ b/examples/kv.c
@@ -64,11 +64,11 @@ column_put(void)
 {
   int i, s = 0;
   grn_obj buf;
-  grn_obj *key_type = grn_ctx_get(&ctx, GRN_DB_SHORTTEXT);
+  grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORTTEXT);
   grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL,
                                     GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
                                     key_type, 0);
-  grn_obj *value_type = grn_ctx_get(&ctx, GRN_DB_TEXT);
+  grn_obj *value_type = grn_ctx_at(&ctx, GRN_DB_TEXT);
   grn_obj *column = grn_column_create(&ctx, table, "c1", 2, NULL,
                                       GRN_OBJ_PERSISTENT, value_type);
   if (!table || !column) { return -1; }
@@ -105,8 +105,8 @@ column_get(void)
 {
   int i, s = 0;
   grn_obj buf;
-  grn_obj *table = grn_ctx_lookup(&ctx, "<t1>", 4);
-  grn_obj *column = grn_ctx_lookup(&ctx, "<t1>.c1", 7);
+  grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4);
+  grn_obj *column = grn_ctx_get(&ctx, "<t1>.c1", 7);
   if (!table || !column) { return -1; }
   GRN_TEXT_INIT(&buf);
   for (i = 0; i < nloops; i++) {
@@ -149,7 +149,7 @@ table_put(void)
 {
   int i;
   grn_obj buf;
-  grn_obj *key_type = grn_ctx_get(&ctx, GRN_DB_SHORTTEXT);
+  grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORTTEXT);
   grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL,
                                     GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
                                     key_type, value_size);
@@ -179,7 +179,7 @@ table_put2(void)
 {
   int i;
   grn_obj keybuf, valbuf;
-  grn_obj *key_type = grn_ctx_get(&ctx, GRN_DB_SHORTTEXT);
+  grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORTTEXT);
   grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL,
                                     GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
                                     key_type, value_size);
@@ -211,7 +211,7 @@ table_put_allocate(void)
 {
   int i;
   grn_obj *buf;
-  grn_obj *key_type = grn_ctx_get(&ctx, GRN_DB_SHORTTEXT);
+  grn_obj *key_type = grn_ctx_at(&ctx, GRN_DB_SHORTTEXT);
   grn_obj *table = grn_table_create(&ctx, "<t1>", 4, NULL,
                                     GRN_OBJ_TABLE_HASH_KEY|GRN_OBJ_PERSISTENT,
                                     key_type, value_size);
@@ -244,7 +244,7 @@ table_get(void)
 {
   int i;
   grn_obj buf;
-  grn_obj *table = grn_ctx_lookup(&ctx, "<t1>", 4);
+  grn_obj *table = grn_ctx_get(&ctx, "<t1>", 4);
   if (!table) { return -1; }
   GRN_TEXT_INIT(&buf);
   for (i = 0; i < nloops; i++) {
diff --git a/groonga.h b/groonga.h
index d1d8821706..740dc00e78 100644
--- a/groonga.h
+++ b/groonga.h
@@ -372,17 +372,17 @@ GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db);
 GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
 
 /**
- * grn_ctx_lookup:
+ * grn_ctx_get:
  * @name: 検索しようとするオブジェクトの名前。
  * @name_size: @nameのbyte長。
  *
  * ctxが使用するdbからnameに対応するオブジェクトを検索して返す。
  * nameに一致するオブジェクトが存在しなければNULLを返す。
  **/
-GRN_API grn_obj *grn_ctx_lookup(grn_ctx *ctx, const char *name, unsigned name_size);
+GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, unsigned name_size);
 
 /**
- * grn_ctx_get:
+ * grn_ctx_at:
  * @id: 検索しようとするオブジェクトのid。
  *
  * ctx、またはctxが使用するdbからidに対応するオブジェクトを検索して返す。
@@ -407,7 +407,7 @@ typedef enum {
   GRN_DB_MECAB,
 } grn_builtin_type;
 
-GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, grn_id id);
+GRN_API grn_obj *grn_ctx_at(grn_ctx *ctx, grn_id id);
 
 /**
  * grn_type_create:
diff --git a/lib/ctx.c b/lib/ctx.c
index c7bc44d37d..264a2eab8e 100644
--- a/lib/ctx.c
+++ b/lib/ctx.c
@@ -1279,7 +1279,7 @@ grn_cell_clear(grn_ctx *ctx, grn_cell *o)
     case GRN_TABLE_HASH_KEY :
     case GRN_TABLE_PAT_KEY :
     case GRN_TABLE_NO_KEY :
-      grn_obj_close(ctx, grn_ctx_get(ctx, o->u.o.id));
+      grn_obj_close(ctx, grn_ctx_at(ctx, o->u.o.id));
       break;
     case GRN_CELL_STR :
       if (o->u.b.value) {
@@ -1512,7 +1512,7 @@ search(grn_ctx *ctx, grn_obj *qe, grn_proc_data *user_data,
   grn_obj *res = argc > 3 ? (grn_obj *)argv[3].ptr : NULL;
   // grn_obj *op = argc > 4 ? (grn_obj *)argv[4].ptr : NULL;
   if (index->header.type == GRN_BULK) {
-    index = grn_ctx_lookup(ctx, GRN_BULK_HEAD(index), GRN_BULK_VSIZE(index));
+    index = grn_ctx_get(ctx, GRN_BULK_HEAD(index), GRN_BULK_VSIZE(index));
   }
   if (!query) { return GRN_INVALID_ARGUMENT; }
   if (!index || index->header.type != GRN_COLUMN_INDEX) {
@@ -1520,7 +1520,7 @@ search(grn_ctx *ctx, grn_obj *qe, grn_proc_data *user_data,
   }
   if (!res) {
     grn_obj *table;
-    if (!(table = grn_ctx_get(ctx, ((grn_db_obj *)index)->range))) {
+    if (!(table = grn_ctx_at(ctx, ((grn_db_obj *)index)->range))) {
       return GRN_INVALID_ARGUMENT;
     }
     res = grn_table_create(ctx, NULL, 0, NULL,
@@ -1608,7 +1608,7 @@ grn_ctx_qe_init(grn_ctx *ctx)
                                     sizeof(grn_ctx_qe),
                                     GRN_OBJ_KEY_VAR_SIZE|GRN_HASH_TINY);
     {
-      grn_proc *init = (grn_proc *)grn_ctx_lookup(ctx, "<proc:init>", 11);
+      grn_proc *init = (grn_proc *)grn_ctx_get(ctx, "<proc:init>", 11);
       if (init) {
         init->funcs[PROC_INIT](ctx, (grn_obj *)ctx->impl->qe, NULL, 0, NULL);
       }
@@ -1697,7 +1697,7 @@ grn_ctx_qe_parse(grn_ctx *ctx, const char *key, int key_size)
     char *tokbuf[17 + 1];
     int i, n = grn_str_tok(head, GRN_BULK_VSIZE(str), ' ', tokbuf, 16, NULL);
     if (n <= 17) {
-      grn_obj *obj = grn_ctx_lookup(ctx, head, tokbuf[0] - head);
+      grn_obj *obj = grn_ctx_get(ctx, head, tokbuf[0] - head);
       if (obj && obj->header.type == GRN_PROC) {
         if ((d->source = GRN_MALLOCN(grn_ctx_qe_source, 1))) {
           d->source->func = ((grn_proc *)obj)->funcs[PROC_INIT];
@@ -1744,7 +1744,7 @@ grn_ctx_qe_get_(grn_ctx *ctx, grn_ctx_qe *qe)
     if (qe->source) {
       qe->value = qe_exec(ctx, qe->source);
     } else {
-      qe->value = grn_ctx_lookup(ctx, key, key_size);
+      qe->value = grn_ctx_get(ctx, key, key_size);
     }
   }
   return qe->value;
@@ -1787,7 +1787,7 @@ grn_ctx_qe_get(grn_ctx *ctx, const char *key, int key_size)
   if (grn_ctx_qe_init(ctx)) { return NULL; }
   if (!(qe = qe_at(ctx, key, key_size))) {
     if (!(qe = grn_ctx_qe_parse(ctx, key, key_size))) {
-      return grn_ctx_lookup(ctx, key, key_size);
+      return grn_ctx_get(ctx, key, key_size);
     }
   }
   return grn_ctx_qe_get_(ctx, qe);
diff --git a/lib/db.c b/lib/db.c
index 092c1e6da9..8f55020453 100644
--- a/lib/db.c
+++ b/lib/db.c
@@ -185,7 +185,7 @@ static grn_id grn_obj_register(grn_ctx *ctx, grn_obj *db,
 static grn_rc grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, int removep);
 
 grn_obj *
-grn_ctx_lookup(grn_ctx *ctx, const char *name, unsigned name_size)
+grn_ctx_get(grn_ctx *ctx, const char *name, unsigned name_size)
 {
   grn_id id;
   grn_obj *obj = NULL;
@@ -196,7 +196,7 @@ grn_ctx_lookup(grn_ctx *ctx, const char *name, unsigned name_size)
   if (DB_P(db)) {
     grn_db *s = (grn_db *)db;
     if ((id = grn_pat_get(ctx, s->keys, name, name_size, NULL))) {
-      obj = grn_ctx_get(ctx, id);
+      obj = grn_ctx_at(ctx, id);
     }
   }
   GRN_API_RETURN(obj);
@@ -342,7 +342,7 @@ grn_proc_create(grn_ctx *ctx,
       GRN_API_RETURN(NULL);
     }
     if (!added) {
-      res = (grn_proc *)grn_ctx_get(ctx, id);
+      res = (grn_proc *)grn_ctx_at(ctx, id);
       if (res && res->funcs[PROC_INIT]) {
         ERR(GRN_INVALID_ARGUMENT, "already used name");
         GRN_API_RETURN(NULL);
@@ -552,7 +552,7 @@ grn_table_open(grn_ctx *ctx, const char *name, unsigned name_size, const char *p
     ERR(GRN_INVALID_ARGUMENT, "invalid db assigned");
     GRN_API_RETURN(NULL);
   } else {
-    grn_obj *res = grn_ctx_lookup(ctx, name, name_size);
+    grn_obj *res = grn_ctx_get(ctx, name, name_size);
     if (res) {
       const char *path2 = grn_obj_path(ctx, res);
       if (path && (!path2 || strcmp(path, path2))) { GRN_API_RETURN(NULL); }
@@ -1460,7 +1460,7 @@ grn_table_group(grn_ctx *ctx, grn_obj *table,
     if (n_keys == 1 && n_results == 1) {
       if ((tc = grn_table_cursor_open(ctx, table, NULL, 0, NULL, 0, 0))) {
         grn_id id;
-        grn_obj *range = grn_ctx_get(ctx, grn_obj_get_range(ctx, keys->key));
+        grn_obj *range = grn_ctx_at(ctx, grn_obj_get_range(ctx, keys->key));
         int idp = GRN_OBJ_TABLEP(range);
         while ((id = grn_table_cursor_next(ctx, tc))) {
           void *value;
@@ -1658,7 +1658,7 @@ grn_table_column(grn_ctx *ctx, grn_obj *table, const char *name, unsigned name_s
         buf[len++] = GRN_DB_DELIMITER;
         if (len + name_size <= GRN_PAT_MAX_KEY_SIZE) {
           memcpy(buf + len, name, name_size);
-          column = grn_ctx_lookup(ctx, buf, len + name_size);
+          column = grn_ctx_get(ctx, buf, len + name_size);
         } else {
           ERR(GRN_INVALID_ARGUMENT, "name is too long");
         }
@@ -1874,7 +1874,7 @@ grn_column_open(grn_ctx *ctx, grn_obj *table,
     ERR(GRN_INVALID_ARGUMENT, "todo : not supported yet");
     goto exit;
   }
-  res = grn_ctx_lookup(ctx, fullname, name_size);
+  res = grn_ctx_get(ctx, fullname, name_size);
   if (res) {
     const char *path2 = grn_obj_path(ctx, res);
     if (path && (!path2 || strcmp(path, path2))) { goto exit; }
@@ -1969,7 +1969,7 @@ default_set_value_hook(grn_ctx *ctx, grn_obj *obj, grn_proc_data *user_data,
     //    int flags = argv[3].int_value;
     grn_hook *h = pctx->currh;
     default_set_value_hook_data *data = (void *)NEXT_ADDR(h);
-    grn_obj *target = grn_ctx_get(ctx, data->target);
+    grn_obj *target = grn_ctx_at(ctx, data->target);
     int section = data->section;
     switch (target->header.type) {
     case GRN_COLUMN_INDEX :
@@ -2269,15 +2269,15 @@ grn_obj_get_accessor(grn_ctx *ctx, grn_obj *obj, const char *name, unsigned name
     }
     switch (res->action) {
     case GRN_ACCESSOR_GET_KEY :
-      obj = grn_ctx_get(ctx, res->obj->header.domain);
+      obj = grn_ctx_at(ctx, res->obj->header.domain);
       break;
     case GRN_ACCESSOR_GET_VALUE :
     case GRN_ACCESSOR_GET_SCORE :
     case GRN_ACCESSOR_GET_NSUBRECS :
-      obj = grn_ctx_get(ctx, DB_OBJ(res->obj)->range);
+      obj = grn_ctx_at(ctx, DB_OBJ(res->obj)->range);
       break;
     case GRN_ACCESSOR_GET_COLUMN_VALUE :
-      obj = grn_ctx_get(ctx, DB_OBJ(res->obj)->range);
+      obj = grn_ctx_at(ctx, DB_OBJ(res->obj)->range);
       break;
     case GRN_ACCESSOR_LOOKUP :
       /* todo */
@@ -2303,7 +2303,7 @@ grn_obj_get_accessor(grn_ctx *ctx, grn_obj *obj, const char *name, unsigned name
         for (rp = &res; !done; rp = &(*rp)->next) {
           *rp = accessor_new(ctx);
           (*rp)->obj = obj;
-          obj = grn_ctx_get(ctx, obj->header.domain);
+          obj = grn_ctx_at(ctx, obj->header.domain);
           switch (obj->header.type) {
           case GRN_DB :
             (*rp)->action = GRN_ACCESSOR_GET_KEY;
@@ -2361,7 +2361,7 @@ grn_obj_get_accessor(grn_ctx *ctx, grn_obj *obj, const char *name, unsigned name
               res = NULL;
               goto exit;
             }
-            obj = grn_ctx_get(ctx, obj->header.domain);
+            obj = grn_ctx_at(ctx, obj->header.domain);
           }
         }
         break;
@@ -2391,7 +2391,7 @@ grn_obj_get_accessor(grn_ctx *ctx, grn_obj *obj, const char *name, unsigned name
               res = NULL;
               goto exit;
             }
-            obj = grn_ctx_get(ctx, obj->header.domain);
+            obj = grn_ctx_at(ctx, obj->header.domain);
           }
         }
         break;
@@ -2420,7 +2420,7 @@ grn_obj_get_accessor(grn_ctx *ctx, grn_obj *obj, const char *name, unsigned name
           break;
         } else {
           (*rp)->obj = obj;
-          obj = grn_ctx_get(ctx, obj->header.domain);
+          obj = grn_ctx_at(ctx, obj->header.domain);
           switch (obj->header.type) {
           case GRN_TABLE_PAT_KEY :
           case GRN_TABLE_HASH_KEY :
@@ -2567,7 +2567,7 @@ grn_accessor_get_value(grn_ctx *ctx, grn_accessor *a, grn_id id, grn_obj *value)
       vs = GRN_BULK_VSIZE(&buf);
       break;
     case GRN_ACCESSOR_GET_DB_OBJ :
-      value = grn_ctx_get(ctx, id);
+      value = grn_ctx_at(ctx, id);
       grn_obj_close(ctx, &buf);
       return value;
       break;
@@ -2778,7 +2778,7 @@ grn_obj_set_value(grn_ctx *ctx, grn_obj *obj, grn_id id,
         break;
       case GRN_OBJ_COLUMN_VECTOR :
         {
-          grn_obj *lexicon = grn_ctx_get(ctx, DB_OBJ(obj)->range);
+          grn_obj *lexicon = grn_ctx_at(ctx, DB_OBJ(obj)->range);
           if (GRN_OBJ_TABLEP(lexicon)) {
             grn_obj buf;
             GRN_TEXT_INIT(&buf);
@@ -2990,7 +2990,7 @@ grn_obj_get_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value)
     switch (obj->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) {
     case GRN_OBJ_COLUMN_VECTOR :
       {
-        grn_obj *lexicon = grn_ctx_get(ctx, DB_OBJ(obj)->range);
+        grn_obj *lexicon = grn_ctx_at(ctx, DB_OBJ(obj)->range);
         if (GRN_OBJ_TABLEP(lexicon)) {
           grn_io_win jw;
           void *v = grn_ja_ref(ctx, (grn_ja *)obj, id, &jw, &len);
@@ -3078,7 +3078,7 @@ grn_column_table(grn_ctx *ctx, grn_obj *column)
   grn_db_obj *col = DB_OBJ(column);
   GRN_API_ENTER;
   if (col) {
-    obj = grn_ctx_get(ctx, col->header.domain);
+    obj = grn_ctx_at(ctx, col->header.domain);
   }
   GRN_API_RETURN(obj);
 }
@@ -3161,7 +3161,7 @@ update_source_hook(grn_ctx *ctx, grn_obj *obj)
   GRN_TEXT_SET_REF(&data, &hook_data, sizeof hook_data);
   for (i = 1; i <= n; i++, s++) {
     hook_data.section = i;
-    if ((source = grn_ctx_get(ctx, *s))) {
+    if ((source = grn_ctx_at(ctx, *s))) {
       grn_obj_add_hook(ctx, source, GRN_HOOK_SET, 0, NULL, &data);
     }
   }
@@ -3208,7 +3208,7 @@ grn_hook_unpack(grn_ctx *ctx, grn_db_obj *obj, const char *buf, uint32_t buf_siz
         return GRN_NO_MEMORY_AVAILABLE;
       }
       if (id) {
-        new->proc = (grn_proc *)grn_ctx_get(ctx, id);
+        new->proc = (grn_proc *)grn_ctx_at(ctx, id);
         if (!new->proc) {
           GRN_FREE(new);
           return ctx->rc;
@@ -3453,7 +3453,7 @@ grn_obj_remove(grn_ctx *ctx, grn_obj *obj)
         if (grn_table_columns(ctx, obj, "", 0, (grn_obj *)cols)) {
           grn_id *key;
           GRN_HASH_EACH(cols, id, &key, NULL, NULL, {
-            grn_obj *col = grn_ctx_get(ctx, *key);
+            grn_obj *col = grn_ctx_at(ctx, *key);
             if (col) { grn_obj_remove(ctx, col); }
           });
         }
@@ -3576,7 +3576,7 @@ grn_db_obj_init(grn_ctx *ctx, grn_obj *db, grn_id id, grn_db_obj *obj)
 }
 
 grn_obj *
-grn_ctx_get(grn_ctx *ctx, grn_id id)
+grn_ctx_at(grn_ctx *ctx, grn_id id)
 {
   grn_obj *res = NULL;
   if (!ctx || !ctx->impl || !id) { return res; }
@@ -3645,7 +3645,7 @@ grn_ctx_get(grn_ctx *ctx, grn_id id)
               case GRN_COLUMN_INDEX :
                 GET_PATH(spec, buffer, s, id);
                 {
-                  grn_obj *table = grn_ctx_get(ctx, spec->header.domain);
+                  grn_obj *table = grn_ctx_at(ctx, spec->header.domain);
                   MUTEX_LOCK(s->lock);
                   if (!*vp) { *vp = (grn_obj *)grn_ii_open(ctx, buffer, table); }
                   MUTEX_UNLOCK(s->lock);
@@ -4166,7 +4166,7 @@ grn_table_sort(grn_ctx *ctx, grn_obj *table, int limit,
     int j;
     grn_table_sort_key *kp;
     for (kp = keys, j = n_keys; j; kp++, j--) {
-      grn_obj *range = grn_ctx_get(ctx, grn_obj_get_range(ctx, kp->key));
+      grn_obj *range = grn_ctx_at(ctx, grn_obj_get_range(ctx, kp->key));
       if (range->header.type == GRN_TYPE) {
         if (range->header.flags & GRN_OBJ_KEY_VAR_SIZE) {
           kp->offset = KEY_BULK;
@@ -4255,7 +4255,7 @@ static grn_obj *
 deftype(grn_ctx *ctx, const char *name,
         grn_obj_flags flags,  unsigned int size)
 {
-  grn_obj *o = grn_ctx_lookup(ctx, name, strlen(name));
+  grn_obj *o = grn_ctx_get(ctx, name, strlen(name));
   if (!o) { o = grn_type_create(ctx, name, strlen(name), flags, size); }
   return o;
 }
diff --git a/lib/hash.c b/lib/hash.c
index f7e6c1b589..983bf26753 100644
--- a/lib/hash.c
+++ b/lib/hash.c
@@ -757,7 +757,7 @@ io_hash_init(grn_hash *ih, grn_ctx *ctx, const char *path, uint32_t key_size,
   ih->io = io;
   ih->header = header;
   ih->lock = &header->lock;
-  ih->tokenizer = grn_ctx_get(ctx, header->tokenizer);
+  ih->tokenizer = grn_ctx_at(ctx, header->tokenizer);
   return GRN_SUCCESS;
 }
 
@@ -846,7 +846,7 @@ grn_hash_open(grn_ctx *ctx, const char *path)
           hash->io = io;
           hash->header = header;
           hash->lock = &header->lock;
-          hash->tokenizer = grn_ctx_get(ctx, header->tokenizer);
+          hash->tokenizer = grn_ctx_at(ctx, header->tokenizer);
           return (grn_hash *)hash;
         } else {
           GRN_LOG(ctx, GRN_LOG_NOTICE, "invalid hash flag. (%x)", header->flags);
diff --git a/lib/pat.c b/lib/pat.c
index c15cb8ff0f..1f874f530e 100644
--- a/lib/pat.c
+++ b/lib/pat.c
@@ -400,7 +400,7 @@ grn_pat_create(grn_ctx *ctx, const char *path, uint32_t key_size,
   pat->header = header;
   pat->key_size = key_size;
   pat->value_size = value_size;
-  pat->tokenizer = grn_ctx_get(ctx, header->tokenizer);
+  pat->tokenizer = grn_ctx_at(ctx, header->tokenizer);
   pat->encoding = encoding;
   pat->obj.flags = flags;
   if (!(node0 = pat_get(ctx, pat, 0))) {
@@ -440,7 +440,7 @@ grn_pat_open(grn_ctx *ctx, const char *path)
   pat->value_size = header->value_size;
   pat->encoding = header->encoding;
   pat->obj.flags = header->flags;
-  pat->tokenizer = grn_ctx_get(ctx, header->tokenizer);
+  pat->tokenizer = grn_ctx_at(ctx, header->tokenizer);
   PAT_AT(pat, 0, node0);
   if (!node0) {
     grn_io_close(ctx, io);
diff --git a/lib/ql.c b/lib/ql.c
index e619c3aafd..dd110f044f 100644
--- a/lib/ql.c
+++ b/lib/ql.c
@@ -23,7 +23,7 @@
 #include "snip.h"
 
 #define DB_OBJ(obj) ((grn_db_obj *)obj)
-#define RVALUE(obj) (grn_ctx_get(ctx, (obj)->u.o.id))
+#define RVALUE(obj) (grn_ctx_at(ctx, (obj)->u.o.id))
 #define INTERN2(s,l) (grn_ql_mk_symbol(ctx, s, l))
 
 static grn_cell *ha_object(grn_ctx *ctx, grn_cell *args, grn_ql_co *co);
@@ -99,7 +99,7 @@ obj2cell(grn_ctx *ctx, grn_obj *obj, grn_cell *cell)
     {
       void *v = GRN_BULK_HEAD(obj);
       grn_id rid = obj->header.domain;
-      grn_obj *range = grn_ctx_get(ctx, rid);
+      grn_obj *range = grn_ctx_at(ctx, rid);
       if (v) {
         if (range && range->header.type == GRN_TYPE) {
           switch (rid) {
@@ -392,13 +392,13 @@ get_cell(grn_ctx *ctx, grn_obj *db_obj)
 static grn_obj *
 get_obj(grn_ctx *ctx, grn_cell *cell)
 {
-  return GRN_DB_OBJP(cell) ? grn_ctx_get(ctx, cell->u.o.id) : NULL;
+  return GRN_DB_OBJP(cell) ? grn_ctx_at(ctx, cell->u.o.id) : NULL;
 }
 
 static grn_obj *
 get_domain(grn_ctx *ctx, grn_cell *cell)
 {
-  return grn_ctx_get(ctx, cell->header.domain);
+  return grn_ctx_at(ctx, cell->header.domain);
 }
 
 static void
@@ -461,9 +461,9 @@ grn_ql_table_get(grn_ctx *ctx, grn_obj *table, const void *key, unsigned key_siz
 static grn_obj *
 get_column(grn_ctx *ctx, grn_id tid, char *msg, unsigned msg_size, grn_id *id)
 {
-  grn_obj *table = grn_ctx_get(ctx, tid);
+  grn_obj *table = grn_ctx_at(ctx, tid);
   for (;;) {
-    grn_obj *domain = grn_ctx_get(ctx, DB_OBJ(table)->header.domain);
+    grn_obj *domain = grn_ctx_at(ctx, DB_OBJ(table)->header.domain);
     if (!domain || domain->header.type == GRN_TYPE) { break; }
     if (id) {
       if (!grn_table_get_key(ctx, table, *id, id, sizeof(grn_id))) { return NULL; }
@@ -594,7 +594,7 @@ cell2obj(grn_ctx *ctx, grn_cell *cell, grn_obj *column, grn_obj *obj)
 {
   if ((column->header.flags & GRN_OBJ_COLUMN_TYPE_MASK) == GRN_OBJ_COLUMN_SCALAR) {
     grn_id rid = grn_obj_get_range(ctx, column);
-    grn_obj *range = grn_ctx_get(ctx, rid);
+    grn_obj *range = grn_ctx_at(ctx, rid);
     if (range && range->header.type == GRN_TYPE) {
       switch (rid) {
       case GRN_DB_INT32 :
@@ -874,7 +874,7 @@ table_create(grn_ctx *ctx, const char *name, unsigned name_size,
   grn_obj *table = grn_table_create(ctx, name, name_size,
                                     NULL, flags, domain, value_size);
   if (!table) { QLERR("table create failed"); }
-  grn_obj_set_info(ctx, table, GRN_INFO_DEFAULT_TOKENIZER, grn_ctx_get(ctx, tokenizer));
+  grn_obj_set_info(ctx, table, GRN_INFO_DEFAULT_TOKENIZER, grn_ctx_at(ctx, tokenizer));
   return register_cell(ctx, table, name, name_size);
 }
 
@@ -907,7 +907,7 @@ inline static grn_cell *
 match_prepare(grn_ctx *ctx, match_spec *spec, grn_id base, grn_cell *args)
 {
   grn_cell *car, *expr;
-  grn_obj *r = grn_ctx_get(ctx, base);
+  grn_obj *r = grn_ctx_at(ctx, base);
   POP(expr, args);
   spec->ce = column_exp_open(ctx, r, expr, NIL);
   if (EVAL_BY_FUNCALLP(spec->ce)) {
@@ -948,7 +948,7 @@ match_prepare(grn_ctx *ctx, match_spec *spec, grn_id base, grn_cell *args)
   } else {
     char str[STRBUF_SIZE];
     uint16_t str_size;
-    grn_obj *table = grn_ctx_get(ctx, base);
+    grn_obj *table = grn_ctx_at(ctx, base);
     if (INTP(expr)) { spec->offset = IVALUE(expr); }
     POP(expr, args);
     if (INTP(expr)) { spec->limit = IVALUE(expr); }
@@ -985,7 +985,7 @@ match_prepare(grn_ctx *ctx, match_spec *spec, grn_id base, grn_cell *args)
 grn_obj *
 grn_ql_obj_key(grn_ctx *ctx, grn_cell *obj, grn_obj *value)
 {
-  grn_obj *table = grn_ctx_get(ctx, obj->header.domain);
+  grn_obj *table = grn_ctx_at(ctx, obj->header.domain);
   grn_obj *accessor = grn_obj_get_accessor(ctx, table, ":key", 4);
   if (accessor) {
     value = grn_obj_get_value(ctx, accessor, obj->u.o.id, value);
@@ -1094,7 +1094,7 @@ ha_table(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
   uint16_t msg_size;
   if (!(res = ctx->impl->code)) { QLERR("invalid receiver"); }
   base = ctx->impl->code->u.o.id;
-  if (!(table = grn_ctx_get(ctx, base))) { QLERR("invalid table"); }
+  if (!(table = grn_ctx_at(ctx, base))) { QLERR("invalid table"); }
   GRN_QL_CO_BEGIN(co);
   POP(car, args);
   if (obj2str(car, msg, &msg_size)) { QLERR("invalid argument"); }
@@ -1327,7 +1327,7 @@ ha_table(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
           if (!n_results) {
             for (rp = results; n_results < ce->n_keys; rp++, n_results++) {
               grn_id range = grn_obj_get_range(ctx, ce->keys[n_results].key);
-              rp->table = get_obj(ctx, rec_obj_new(ctx, grn_ctx_get(ctx, range), 0));
+              rp->table = get_obj(ctx, rec_obj_new(ctx, grn_ctx_at(ctx, range), 0));
               rp->key_begin = n_results;
               rp->key_end = rp->key_begin + 1;
             }
@@ -1734,7 +1734,7 @@ ha_table(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
               grn_obj *column;
               POP(car, r);
               cons.u.l.car = car;
-              column = grn_ctx_get(ctx, CAR(s)->u.o.id);
+              column = grn_ctx_at(ctx, CAR(s)->u.o.id);
               column_value(ctx, column, obj.u.o.id, &cons, &dummy);
             }
             stat->nrecs++;
@@ -1788,7 +1788,7 @@ ha_table(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
                 val.u.b.value = tokbuf[i - 1] + 1;
                 val.u.b.size = tokbuf[i] - val.u.b.value;
                 unesc(ctx, &val);
-                column = grn_ctx_get(ctx, CAR(s)->u.o.id);
+                column = grn_ctx_at(ctx, CAR(s)->u.o.id);
                 column_value(ctx, column, obj.u.o.id, &cons, &dummy);
               }
               stat->nrecs++;
@@ -1824,7 +1824,7 @@ ha_object(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
     if (*msg == ':' && msg[1] == 'i') {
       res = obj2oid(ctx, obj, NULL);
     } else {
-      grn_obj *domain = grn_ctx_get(ctx, obj->header.domain);
+      grn_obj *domain = grn_ctx_at(ctx, obj->header.domain);
       grn_obj *column = grn_obj_get_accessor(ctx, domain, msg, msg_size);
       if (!column) {
         QLERR("invalid column %s", msg);
@@ -1887,7 +1887,7 @@ grn_obj_query(grn_ctx *ctx, const char *str, unsigned int str_len,
 static void
 uvector2str(grn_ctx *ctx, grn_obj *obj, grn_obj *buf)
 {
-  grn_obj *range = grn_ctx_get(ctx, obj->header.domain);
+  grn_obj *range = grn_ctx_at(ctx, obj->header.domain);
   if (range && range->header.type == GRN_TYPE) {
     // todo
   } else {
@@ -1973,7 +1973,7 @@ ha_column(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
   grn_obj *column;
   if (!(res = ctx->impl->code)) { QLERR("invalid receiver"); }
   base = ctx->impl->code->u.o.id;
-  if (!(column = grn_ctx_get(ctx, base))) { QLERR("grn_ctx_get failed"); }
+  if (!(column = grn_ctx_at(ctx, base))) { QLERR("grn_ctx_get failed"); }
   POP(car, args);
   if (obj2str(car, msg, &msg_size)) { QLERR("invalid message"); }
   switch (*msg) {
@@ -2009,7 +2009,7 @@ ha_column(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
           }
         } else {
           grn_obj *table;
-          if (!(table = grn_ctx_get(ctx, DB_OBJ(column)->range))) { return F; }
+          if (!(table = grn_ctx_at(ctx, DB_OBJ(column)->range))) { return F; }
           res = rec_obj_new(ctx, table, 0);
           if (ERRP(ctx, GRN_WARN)) { return F; }
           op = GRN_SEL_OR;
@@ -2039,7 +2039,7 @@ ha_column(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
         switch (column->header.type) {
         case GRN_COLUMN_FIX_SIZE  :
         case GRN_COLUMN_VAR_SIZE  :
-          res = CONS(get_cell(ctx, grn_ctx_get(ctx, DB_OBJ(column)->range)), NIL);
+          res = CONS(get_cell(ctx, grn_ctx_at(ctx, DB_OBJ(column)->range)), NIL);
           break;
         case GRN_COLUMN_INDEX :
           {
@@ -2048,7 +2048,7 @@ ha_column(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
             res = CONS(INTERN("::match"), CONS(NIL, NIL));
             for (t = column->triggers; t; t = t->next) {
               if (t->type == grn_db_index_target) {
-                res = CONS(get_cell(ctx, grn_ctx_get(ctx, t->target)), res);
+                res = CONS(get_cell(ctx, grn_ctx_at(ctx, t->target)), res);
               }
             }
             */
@@ -2128,7 +2128,7 @@ nf_db(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
         uint32_t key_size;
         grn_pat *keys = (grn_pat *)grn_db_keys(ctx->impl->db);
         GRN_PAT_EACH(keys, id, &key, &key_size, &value, {
-          obj = grn_ctx_get(ctx, id);
+          obj = grn_ctx_at(ctx, id);
           grn_obj_clear_lock(ctx, obj);
         });
         res = grn_obj_clear_lock(ctx, ctx->impl->db) ? F : T;
@@ -2138,7 +2138,7 @@ nf_db(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
     case 'D' :
       POP(car, args);
       if (obj2str(car, msg, &msg_size)) { QLERR("invalid argument"); }
-      if (!(table = grn_ctx_lookup(ctx, msg, msg_size))) { QLERR("Invalid table"); }
+      if (!(table = grn_ctx_get(ctx, msg, msg_size))) { QLERR("Invalid table"); }
       grn_obj_remove(ctx, table);
       grn_hash_delete(ctx, ctx->impl->symbols, msg, msg_size, NULL);
       break;
@@ -2152,7 +2152,7 @@ nf_db(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
         if ((res = rec_obj_new(ctx, ctx->impl->db, 0)) == F) {
           QLERR("rec_obj_new failed.");
         }
-        r = (grn_hash *)grn_ctx_get(ctx, res->u.o.id);
+        r = (grn_hash *)grn_ctx_at(ctx, res->u.o.id);
         grn_pat_prefix_search(ctx, keys, msg, msg_size, r);
         {
           grn_id *rid;
@@ -2238,7 +2238,7 @@ nf_table_(grn_ctx *ctx, grn_cell *args, const char *name, uint16_t name_size)
   uint32_t value_size = 0;
   grn_obj_flags flags = (name && name_size) ? GRN_OBJ_PERSISTENT : GRN_OBJ_TEMPORARY;
   grn_encoding encoding = GRN_ENC_DEFAULT;
-  grn_obj *domain = grn_ctx_get(ctx, GRN_DB_SHORTTEXT);
+  grn_obj *domain = grn_ctx_at(ctx, GRN_DB_SHORTTEXT);
   grn_cell *car;
   grn_id tokenizer = GRN_DB_DELIMIT;
   char msg[STRBUF_SIZE];
@@ -2250,7 +2250,7 @@ nf_table_(grn_ctx *ctx, grn_cell *args, const char *name, uint16_t name_size)
     case GRN_TABLE_PAT_KEY :
     case GRN_TABLE_NO_KEY :
     case GRN_TYPE :
-      domain = grn_ctx_get(ctx, car->u.o.id);
+      domain = grn_ctx_at(ctx, car->u.o.id);
       break;
     case GRN_CELL_INT :
       value_size = (uint32_t) IVALUE(car);
@@ -2368,7 +2368,7 @@ nf_ptable(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
   grn_cell *car;
   POP(car, args);
   if (obj2str(car, name, &name_size)) { QLERR("invalid argument"); }
-  if (grn_ctx_lookup(ctx, name, name_size)) { return T; }
+  if (grn_ctx_get(ctx, name, name_size)) { return T; }
   return nf_table_(ctx, args, name, name_size);
 }
 
@@ -2511,7 +2511,7 @@ nf_snippet(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
   case GRN_TABLE_PAT_KEY :
     {
       patsnip_spec *spec;
-      grn_obj *table = grn_ctx_get(ctx, cond->u.o.id);
+      grn_obj *table = grn_ctx_at(ctx, cond->u.o.id);
       if (!table) { QLERR("table get failed."); }
       GRN_CELL_NEW(ctx, res);
       if (!(spec = GRN_MALLOC(sizeof(patsnip_spec)))) {
@@ -2676,7 +2676,7 @@ disp_j_with_format(grn_ctx *ctx, grn_cell *args, grn_obj *buf)
     {
       column_exp *ce;
       grn_cell *parameter, *columns;
-      grn_obj *u = car->u.p.value, *r = grn_ctx_get(ctx, u->header.domain);
+      grn_obj *u = car->u.p.value, *r = grn_ctx_at(ctx, u->header.domain);
       POP(parameter, args);
       POP(columns, args);
       if (!PAIRP(columns)) {
diff --git a/lib/scm.c b/lib/scm.c
index 73896d97ee..9c3ee25448 100644
--- a/lib/scm.c
+++ b/lib/scm.c
@@ -176,7 +176,7 @@ grn_ql_mk_symbol(grn_ctx *ctx, const char *name, int name_size)
   if (x->header.type == GRN_VOID && ctx->impl->db) {
     uint16_t symname_size;
     const char *symname = _grn_hash_strkey_by_val(x, &symname_size);
-    grn_obj *obj = grn_ctx_lookup(ctx, symname, symname_size);
+    grn_obj *obj = grn_ctx_get(ctx, symname, symname_size);
     if (obj) { grn_ql_obj_bind(obj, x); }
   }
   return x;
@@ -3059,7 +3059,7 @@ nf_containp(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
   switch (e->header.type) {
   case GRN_UVECTOR :
     {
-      grn_obj *u = e->u.p.value, *range = grn_ctx_get(ctx, u->header.domain);
+      grn_obj *u = e->u.p.value, *range = grn_ctx_at(ctx, u->header.domain);
       grn_id *v, *ve = (grn_id *)GRN_BULK_CURR(u);
       POP(e, args);
       switch (e->header.type) {
@@ -3131,7 +3131,7 @@ nf_containp(grn_ctx *ctx, grn_cell *args, grn_ql_co *co)
       switch (e->header.type) {
       case GRN_CELL_STR :
         {
-          grn_obj *range = grn_ctx_get(ctx, domain);
+          grn_obj *range = grn_ctx_at(ctx, domain);
           if (grn_table_get(ctx, range, STRVALUE(e), STRSIZE(e)) == id) { r = 1; }
         }
         break;
diff --git a/lib/str.c b/lib/str.c
index f525d0a17e..a39162abd5 100644
--- a/lib/str.c
+++ b/lib/str.c
@@ -1960,7 +1960,7 @@ grn_substring(grn_ctx *ctx, char **str, char **str_end, int start, int end, grn_
 static void
 uvector2str(grn_ctx *ctx, grn_obj *obj, grn_obj *buf)
 {
-  grn_obj *range = grn_ctx_get(ctx, obj->header.domain);
+  grn_obj *range = grn_ctx_at(ctx, obj->header.domain);
   if (range && range->header.type == GRN_TYPE) {
     // todo
   } else {
@@ -2014,7 +2014,7 @@ grn_text_otoj(grn_ctx *ctx, grn_obj *bulk, grn_obj *obj, grn_obj_format *format)
       break;
     default :
       {
-        grn_obj *table = grn_ctx_get(ctx, obj->header.domain);
+        grn_obj *table = grn_ctx_at(ctx, obj->header.domain);
         grn_obj *accessor = grn_obj_get_accessor(ctx, table, ":key", 4);
         if (accessor) {
           grn_obj_get_value(ctx, accessor, *((grn_id *)GRN_BULK_HEAD(obj)), &buf);
diff --git a/src/groonga.c b/src/groonga.c
index f1568cfd25..d715de8166 100644
--- a/src/groonga.c
+++ b/src/groonga.c
@@ -236,7 +236,7 @@ static grn_obj *cache_flags = NULL;
 static grn_obj *cache_expire = NULL;
 static grn_obj *cache_cas = NULL;
 
-#define CTX_LOOKUP(name) (grn_ctx_lookup(ctx, (name), strlen(name)))
+#define CTX_GET(name) (grn_ctx_get(ctx, (name), strlen(name)))
 
 static grn_obj *
 cache_init(grn_ctx *ctx)
@@ -244,16 +244,16 @@ cache_init(grn_ctx *ctx)
   if (cache_cas) { return cache_cas; }
   MUTEX_LOCK(cache_mutex);
   if (!cache_cas) {
-    if ((cache_table = CTX_LOOKUP("<cache>"))) {
-      cache_value = CTX_LOOKUP("<cache>.value");
-      cache_flags = CTX_LOOKUP("<cache>.flags");
-      cache_expire = CTX_LOOKUP("<cache>.expire");
-      cache_cas = CTX_LOOKUP("<cache>.cas");
+    if ((cache_table = CTX_GET("<cache>"))) {
+      cache_value = CTX_GET("<cache>.value");
+      cache_flags = CTX_GET("<cache>.flags");
+      cache_expire = CTX_GET("<cache>.expire");
+      cache_cas = CTX_GET("<cache>.cas");
     } else {
       if (!cache_table) {
-        grn_obj *uint_type = grn_ctx_get(ctx, GRN_DB_UINT32);
-        grn_obj *int64_type = grn_ctx_get(ctx, GRN_DB_INT64);
-        grn_obj *shorttext_type = grn_ctx_get(ctx, GRN_DB_SHORTTEXT);
+        grn_obj *uint_type = grn_ctx_at(ctx, GRN_DB_UINT32);
+        grn_obj *int64_type = grn_ctx_at(ctx, GRN_DB_INT64);
+        grn_obj *shorttext_type = grn_ctx_at(ctx, GRN_DB_SHORTTEXT);
         if ((cache_table = grn_table_create(ctx, "<cache>", 7, NULL,
                                             GRN_OBJ_TABLE_PAT_KEY|GRN_OBJ_PERSISTENT,
                                             shorttext_type, 0))) {
diff --git a/test/unit/core/test-column.c b/test/unit/core/test-column.c
index d87d5cf703..6901c69433 100644
--- a/test/unit/core/test-column.c
+++ b/test/unit/core/test-column.c
@@ -23,7 +23,7 @@
 
 #include "../lib/grn-assertions.h"
 
-#define LOOKUP(name) (grn_ctx_lookup(&context, name, strlen(name)))
+#define LOOKUP(name) (grn_ctx_get(&context, name, strlen(name)))
 
 void test_fix_size_set_value_set(void);
 
diff --git a/test/unit/core/test-inverted-index.c b/test/unit/core/test-inverted-index.c
index 02b8d1c572..1d346e6e16 100644
--- a/test/unit/core/test-inverted-index.c
+++ b/test/unit/core/test-inverted-index.c
@@ -114,7 +114,7 @@ setup(void)
                              type, VALUE_SIZE);
 
   grn_obj_set_info(context, lexicon, GRN_INFO_DEFAULT_TOKENIZER,
-                   grn_ctx_get(context, GRN_DB_BIGRAM));
+                   grn_ctx_at(context, GRN_DB_BIGRAM));
 
   g_free(table_path);
 
@@ -564,7 +564,7 @@ test_int_index(void)
   db = grn_db_create(context, db_path, NULL);
   g_free(db_path);
 
-  int_type = grn_ctx_get(context, GRN_DB_INT32);
+  int_type = grn_ctx_at(context, GRN_DB_INT32);
   cut_assert_not_null(int_type);
 
   name = "users";
diff --git a/test/unit/core/test-table-cursor.c b/test/unit/core/test-table-cursor.c
index 003efe659e..ac92313dd6 100644
--- a/test/unit/core/test-table-cursor.c
+++ b/test/unit/core/test-table-cursor.c
@@ -23,7 +23,7 @@
 
 #include "../lib/grn-assertions.h"
 
-#define OBJECT(name) (grn_ctx_lookup(&context, (name), strlen(name)))
+#define OBJECT(name) (grn_ctx_get(&context, (name), strlen(name)))
 
 void data_table(void);
 void test_table(gpointer data);
diff --git a/test/unit/core/test-table.c b/test/unit/core/test-table.c
index ebd8526611..6c943d0c44 100644
--- a/test/unit/core/test-table.c
+++ b/test/unit/core/test-table.c
@@ -23,7 +23,7 @@
 
 #include "../lib/grn-assertions.h"
 
-#define OBJECT(name) (grn_ctx_lookup(&context, (name), strlen(name)))
+#define OBJECT(name) (grn_ctx_get(&context, (name), strlen(name)))
 
 void test_array_set_data(void);
 void data_temporary_table_no_path(void);