int main(void) { /*! [example connection] */ WT_ASYNC_OP *op; WT_CONNECTION *wt_conn; WT_SESSION *session; int i, ret; char k[MAX_KEYS][16], v[MAX_KEYS][16]; if ((ret = wiredtiger_open(home, NULL, "create,cache_size=100MB,async=(enabled=true,ops_max=10,threads=2)", &wt_conn)) != 0) { fprintf(stderr, "Error connecting to %s: %s\n", home, wiredtiger_strerror(ret)); return (ret); } /*! [example connection] */ /*! [example table create] */ ret = wt_conn->open_session(wt_conn, NULL, NULL, &session); ret = session->create(session, uri, "key_format=S,value_format=S"); /*! [example table create] */ for (i = 0; i < MAX_KEYS; i++) { /*! [Allocate a handle] */ op = NULL; retry: ret = wt_conn->async_new_op(wt_conn, uri, NULL, &cb, &op); if (ret != 0) { /* * If we used up all the ops, pause and retry to * give the workers a chance to process them. */ fprintf(stderr, "Iteration %d: async_new_op ret %d\n",i,ret); sleep(1); goto retry; } /*! [Allocate a handle] */ snprintf(k[i], sizeof(k), "key%d", i); snprintf(v[i], sizeof(v), "value%d", i); /*! [Set the operation's string key] */ op->set_key(op, k[i]); /*! [Set the operation's string key] */ /*! [Set the operation's string value] */ op->set_value(op, v[i]); /*! [Set the operation's string value] */ /*! [example insert] */ ret = op->insert(op); /*! [example insert] */ } /*! [flush] */ wt_conn->async_flush(wt_conn); /*! [flush] */ /*! [Compact a table] */ ret = wt_conn->async_new_op(wt_conn, uri, "timeout=10", &cb, &op); op->compact(op); /*! [Compact a table] */ for (i = 0; i < MAX_KEYS; i++) { op = NULL; retry2: ret = wt_conn->async_new_op(wt_conn, uri, NULL, &cb, &op); if (ret != 0) { /* * If we used up all the ops, pause and retry to * give the workers a chance to process them. */ fprintf(stderr, "Iteration %d: async_new_op ret %d\n",i,ret); sleep(1); goto retry2; } snprintf(k[i], sizeof(k), "key%d", i); op->set_key(op, k[i]); /*! [search] */ op->search(op); /*! [search] */ } /*! [example close] */ /* * Connection close automatically does an async_flush so it will * allow all queued search operations to complete. */ ret = wt_conn->close(wt_conn, NULL); /*! [example close] */ return (ret); }
int main(void) { WT_ASYNC_OP *op; WT_CONNECTION *conn; WT_SESSION *session; int i, ret; char k[MAX_KEYS][16], v[MAX_KEYS][16]; /*! [async example connection] */ ret = wiredtiger_open(home, NULL, "create,cache_size=100MB," "async=(enabled=true,ops_max=20,threads=2)", &conn); /*! [async example connection] */ /*! [async example table create] */ ret = conn->open_session(conn, NULL, NULL, &session); ret = session->create( session, "table:async", "key_format=S,value_format=S"); /*! [async example table create] */ /* Insert a set of keys asynchronously. */ for (i = 0; i < MAX_KEYS; i++) { /*! [async handle allocation] */ while ((ret = conn->async_new_op(conn, "table:async", NULL, &ex_asynckeys.iface, &op)) != 0) { /* * If we used up all the handles, pause and retry to * give the workers a chance to catch up. */ fprintf(stderr, "asynchronous operation handle not available\n"); if (ret == EBUSY) sleep(1); else return (ret); } /*! [async handle allocation] */ /*! [async insert] */ /* * Set the operation's string key and value, and then do * an asynchronous insert. */ /*! [async set the operation's string key] */ snprintf(k[i], sizeof(k), "key%d", i); op->set_key(op, k[i]); /*! [async set the operation's string key] */ /*! [async set the operation's string value] */ snprintf(v[i], sizeof(v), "value%d", i); op->set_value(op, v[i]); /*! [async set the operation's string value] */ ret = op->insert(op); /*! [async insert] */ } /*! [async flush] */ /* Wait for all outstanding operations to complete. */ ret = conn->async_flush(conn); /*! [async flush] */ /*! [async compaction] */ /* * Compact a table asynchronously, limiting the run-time to 5 minutes. */ ret = conn->async_new_op( conn, "table:async", "timeout=300", &ex_asynckeys.iface, &op); ret = op->compact(op); /*! [async compaction] */ /* Search for the keys we just inserted, asynchronously. */ for (i = 0; i < MAX_KEYS; i++) { while ((ret = conn->async_new_op(conn, "table:async", NULL, &ex_asynckeys.iface, &op)) != 0) { /* * If we used up all the handles, pause and retry to * give the workers a chance to catch up. */ fprintf(stderr, "asynchronous operation handle not available\n"); if (ret == EBUSY) sleep(1); else return (ret); } /*! [async search] */ /* * Set the operation's string key and value, and then do * an asynchronous search. */ snprintf(k[i], sizeof(k), "key%d", i); op->set_key(op, k[i]); op->search(op); /*! [async search] */ } /* * Connection close automatically does an async_flush so it will wait * for all queued search operations to complete. */ ret = conn->close(conn, NULL); printf("Searched for %d keys\n", ex_asynckeys.num_keys); return (ret); }