bool write_record(aerospike* p_as) { as_error err; // Create an as_record object with four bins with different value types. By // using as_record_inita(), we won't need to destroy the record if we only // set bins using as_record_set_int64(), as_record_set_str(), and // as_record_set_raw(). as_record rec; as_record_inita(&rec, 4); as_record_set_int64(&rec, "test-bin-1", 1111); as_record_set_int64(&rec, "test-bin-2", 2222); as_record_set_str(&rec, "test-bin-3", "test-bin-3-data"); static const uint8_t bytes[] = { 1, 2, 3 }; as_record_set_raw(&rec, "test-bin-4", bytes, 3); // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. if (aerospike_key_put(p_as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); return false; } LOG("write succeeded"); return true; }
bool write_record(aerospike* p_as) { as_error err; // Create an as_record object with two (integer type) bins. By using // as_record_inita(), we won't need to destroy the record if we only set // bins using as_record_set_int64(). as_record rec; as_record_inita(&rec, 2); as_record_set_int64(&rec, "test-bin-1", 1000); as_record_set_int64(&rec, "test-bin-2", 1000); // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. if (aerospike_key_put(p_as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); return false; } LOG("write succeeded"); return true; }
bool insert_records(aerospike* p_as) { // Create an as_record object with up to three integer value bins. By using // as_record_inita(), we won't need to destroy the record if we only set // bins using as_record_set_int64(). as_record rec; as_record_inita(&rec, 3); // Re-using rec, write records into the database such that each record's key // and (test-bin) value is based on the loop index. for (uint32_t i = 0; i < g_n_keys; i++) { as_error err; // Set up a default as_policy_write object. as_policy_write wpol; as_policy_write_init(&wpol); // No need to destroy a stack as_key object, if we only use // as_key_init_int64(). as_key key; as_key_init_int64(&key, g_namespace, g_set, (int64_t)i); // In general it's ok to reset a bin value - all as_record_set_... calls // destroy any previous value. if (i < 10) { // Only write one bin in the first ten records. as_record_set_int64(&rec, "test-bin-1", (int64_t)i); // By default, we don't store the key with the record in the // database. For these records, the key will not be returned in the // scan callback. } else { // Write three bins in all remaining records. as_record_set_int64(&rec, "test-bin-1", (int64_t)i); as_record_set_int64(&rec, "test-bin-2", (int64_t)(100 + i)); as_record_set_int64(&rec, "test-bin-3", (int64_t)(1000 + i)); // If we want the key to be returned in the scan callback, we must // store it with the record in the database. AS_POLICY_KEY_SEND // causes the key to be stored. wpol.key = AS_POLICY_KEY_SEND; } // Write a record to the database. if (aerospike_key_put(p_as, &err, &wpol, &key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); return false; } } LOG("insert succeeded"); return true; }
bool insert_records(aerospike* p_as) { // Create an as_record object with one (integer value) bin. By using // as_record_inita(), we won't need to destroy the record if we only set // bins using as_record_set_int64(). as_record rec; as_record_inita(&rec, 1); // Re-using rec, write records into the database such that each record's key // and (test-bin) value is based on the loop index. for (uint32_t i = 0; i < g_n_keys; i++) { as_error err; // No need to destroy a stack as_key object, if we only use // as_key_init_int64(). as_key key; as_key_init_int64(&key, g_namespace, g_set, (int64_t)i); // In general it's ok to reset a bin value - all as_record_set_... calls // destroy any previous value. as_record_set_int64(&rec, "test-bin", (int64_t)i); // Write a record to the database. if (aerospike_key_put(p_as, &err, NULL, &key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); return false; } } LOG("insert succeeded"); return true; }
static bool asc_raw_write(aerospike* p_as, as_key* p_key, uint8_t *buf, uint32_t size) { as_error err; as_status status; uint32_t lstack_size = (size+(CHUNK_SIZE-1))/CHUNK_SIZE; uint32_t offset, chksize; // Create a large stack object to use as_ldt lstack; as_ldt_init(&lstack, "data", AS_LDT_LSTACK, NULL); // Make arraylist as_arraylist vals; as_arraylist_inita(&vals, lstack_size); as_bytes *p_bval; p_bval = (as_bytes *)alloca(lstack_size * sizeof(as_bytes)); for (offset = 0; offset < size; offset += chksize, p_bval++) { chksize = MIN(size - offset, CHUNK_SIZE); as_bytes_init_wrap(p_bval, buf + offset, chksize, false); as_arraylist_insert_bytes(&vals, 0, p_bval); } // Push bytes #if 1 // FIXME it's a workaround uint32_t i; for (i = 0; i < vals.size; i++) { status = aerospike_lstack_push(p_as, &err, NULL, p_key, &lstack, vals.elements[i]); if (status != AEROSPIKE_OK) { ERROR("aerospike_lstack_push() - returned %d - %s", err.code, err.message); return false; } } #else status = aerospike_lstack_push_all(p_as, &err, NULL, p_key, &lstack, (as_list *)&vals); if (status != AEROSPIKE_OK) { ERROR("aerospike_lstack_push_all() - returned %d - %s", err.code, err.message); return false; } #endif // Write metadata as_record rec; as_record_inita(&rec, 1); as_record_set_int64(&rec, "size", size); aerospike_key_put(p_as, &err, NULL, p_key, &rec); return true; }
as_record * SourceRecord::record() { if (!record_) { record_ = as_record_new(11); as_record_set_int64(record_, "latest_time", time_); as_record_set_str(record_, "adv_id", advId_.c_str()); as_record_set_str(record_, "sid", sid_.c_str()); as_record_set_str(record_, "adx_id", adxId_.c_str()); as_record_set_str(record_, "mt_uid", mtUid_.c_str()); as_record_set_str(record_, "pid", pid_.c_str()); as_record_set_str(record_, "request_id", requestId_.c_str()); as_record_set_str(record_, "create_id", createId_.c_str()); as_record_set_str(record_, "geo_id", geoId_.c_str()); as_record_set_str(record_, "referer_url", refererUrl_.c_str()); as_record_set_str(record_, "bid_price", bidPrice_.c_str()); } return record_; }
static bool asc_raw_write(aerospike* p_as, as_key* p_key, uint8_t *buf, uint32_t size) { as_status status; as_error err; // Prepare the record as_record rec; as_record_inita(&rec, 2); as_record_set_int64(&rec, "size", size); // Write the record to the database. as_record_set_raw(&rec, "data", (uint8_t *)buf, size); status = aerospike_key_put(p_as, &err, NULL, p_key, &rec); if (status != AEROSPIKE_OK) { ERROR("aerospike_key_put() returned %d - %s", err.code, err.message); return false; } return true; }
bool insert_records(aerospike* p_as) { srand((unsigned int)time(0)); // Create an as_record object with an integer value bin, and a string value // bin, where the string is a list of comma-separated numbers. By using // as_record_inita(), we won't need to destroy the record if we only set // bins using as_record_set_int64() and as_record_set_str(). as_record rec; as_record_inita(&rec, 2); // Re-using rec, write records into the database such that each record's key // and test-bin value is based on the loop index. for (uint32_t i = 0; i < g_n_keys; i++) { as_error err; // No need to destroy a stack as_key object, if we only use // as_key_init_int64(). as_key key; as_key_init_int64(&key, g_namespace, g_set, (int64_t)i); // In general it's ok to reset a bin value - all as_record_set_... calls // destroy any previous value. as_record_set_int64(&rec, "test-bin", (int64_t)i); char numbers[(TOKENS_PER_BIN * 3) + 1]; as_record_set_str(&rec, "numbers-bin", generate_numbers(numbers)); // Write a record to the database. if (aerospike_key_put(p_as, &err, NULL, &key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); return false; } } LOG("insert succeeded"); return true; }
static void insert_data(int numrecs, const char *setname) { as_status rc; char strval[SET_STRSZ], strkey[SET_STRSZ]; as_error err; as_error_reset(&err); for (int i=0; i<numrecs; i++) { sprintf(strval, "str-%s-%d", setname ? setname : "noset", i); sprintf(strkey, "key-%s-%d", setname, i); // Map bin as_hashmap m; as_hashmap_init(&m, 8); as_stringmap_set_int64((as_map *) &m, "x", i); as_stringmap_set_int64((as_map *) &m, "y", i+1); as_stringmap_set_int64((as_map *) &m, "z", i+2); as_record r; as_record_init(&r, 3); as_record_set_int64(&r, "bin1", i); as_record_set_str(&r, "bin2", strval); as_record_set_map(&r, "bin3", (as_map *) &m); as_key k; as_key_init(&k, NS, setname, strkey); rc = aerospike_key_put(as, &err, NULL, &k, &r); if (rc != AEROSPIKE_OK) { error("digest put failed with error %d", rc); } as_hashmap_destroy(&m); as_key_destroy(&k); as_record_destroy(&r); } }
/** * Creates 100 records and 9 indexes. * * Records are structured as: * {a: String, b: Integer, c: Integer, d: Integer, e: Integer} * * The key is "a-b-c-d-e" * * The values are: * a = "abc" * b = 100 * c = <current index> * d = c % 10 * e = b + (c + 1) * (d + 1) / 2 */ bool query_foreach_create() { as_error err; as_error_reset(&err); int n_recs = 100; as_status status; as_index_task task; // create index on "a" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "a", "idx_test_a", AS_INDEX_STRING); index_process_return_code(status, &err, &task); // create index on "b" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "b", "idx_test_b", AS_INDEX_NUMERIC); index_process_return_code(status, &err, &task); // create index on "c" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "c", "idx_test_c", AS_INDEX_NUMERIC); index_process_return_code(status, &err, &task); // create index on "d" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "d", "idx_test_d", AS_INDEX_NUMERIC); index_process_return_code(status, &err, &task); // create complex index on "x" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "x", "idx_test_x", AS_INDEX_TYPE_LIST, AS_INDEX_STRING); index_process_return_code(status, &err, &task); // create complex index on "y" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "y", "idx_test_y", AS_INDEX_TYPE_MAPKEYS, AS_INDEX_STRING); index_process_return_code(status, &err, &task); // create complex index on "y" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "y", "idx_test_y1", AS_INDEX_TYPE_MAPVALUES, AS_INDEX_STRING); index_process_return_code(status, &err, &task); // create complex index on "z" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "z", "idx_test_z", AS_INDEX_TYPE_LIST, AS_INDEX_NUMERIC); index_process_return_code(status, &err, &task); char* buffer = alloca(n_recs * 1024 + 1); uint32_t the_ttl = AS_RECORD_NO_EXPIRE_TTL; // insert records for ( int i = 0; i < n_recs; i++ ) { if (i == 10) { // We change the TTL from never to 100 days the_ttl = 100 * 24 * 60 * 60; } else if (i == 42) { // NOTE - We pause on the 42nd iteration for a few // milliseconds and note the time. We can then use the // as_predexp_rec_last_update_after predicate below to find // the later records. as_sleep(5); g_epochns = cf_clock_getabsolute() * 1000 * 1000; as_sleep(5); // Also on the 42nd iteration we change the TTL to // 10 days for the remaining records. the_ttl = 10 * 24 * 60 * 60; } char * a = "abc"; int b = n_recs; int c = i; int d = i % 10; int e = b + (c + 1) * (d + 1) / 2; int g = i; // Only set on odd records. char f[64]; snprintf(f, sizeof(f), "0x%04x", i); char keystr[64] = { '\0' }; snprintf(keystr, 64, "%s-%d-%d-%d-%d", a, b, c, d, e); // Make list as_arraylist list; as_arraylist_init(&list, 3, 0); if ( (i%3) == 0) { as_arraylist_append_str(&list, "x"); as_arraylist_append_str(&list, "x1"); as_arraylist_append_str(&list, "x2"); } else { as_arraylist_append_str(&list, "not_x1"); as_arraylist_append_str(&list, "not_x2"); as_arraylist_append_str(&list, "not_x3"); } // Make map as_hashmap map; as_hashmap_init(&map, 1); if ( (i%7) == 0) { as_stringmap_set_str((as_map *) &map, "ykey", "yvalue"); } else { as_stringmap_set_str((as_map *) &map, "ykey_not", "yvalue_not"); } // Make list of integers as_arraylist list2; as_arraylist_init(&list2, 5, 0); as_arraylist_append_int64(&list2, i); as_arraylist_append_int64(&list2, i+1); as_arraylist_append_int64(&list2, i+2); as_arraylist_append_int64(&list2, i+3); as_arraylist_append_int64(&list2, i+4); // Make a string of variable size for (int jj = 0; jj < i * 1024; ++jj) { buffer[jj] = 'X'; } buffer[i * 1024] = '\0'; // We only create the g bin for odd records. bool create_g_bin = i % 2 == 1; as_record r; as_record_init(&r, 10 + (create_g_bin ? 1 : 0)); as_record_set_str(&r, "a", a); as_record_set_int64(&r, "b", b); as_record_set_int64(&r, "c", c); as_record_set_int64(&r, "d", d); as_record_set_int64(&r, "e", e); as_record_set_str(&r, "f", f); if (create_g_bin) { as_record_set_int64(&r, "g", g); } as_record_set_list(&r, "x", (as_list *) &list); as_record_set_map(&r, "y", (as_map *) &map); as_record_set_list(&r, "z", (as_list *) &list2); as_record_set_str(&r, "bigstr", buffer); r.ttl = the_ttl; as_key key; as_key_init(&key, NAMESPACE, SET, keystr); aerospike_key_put(as, &err, NULL, &key, &r); as_record_destroy(&r); if (err.code != AEROSPIKE_OK) { error("aerospike_key_put() failed %d %s", err.code, err.message); return false; } as_record *r1 = NULL; aerospike_key_exists(as, &err, NULL, &key, &r1); as_key_destroy(&key); if (err.code != AEROSPIKE_OK) { error("aerospike_key_exists() failed %d %s", err.code, err.message); return false; } if (! r1) { error("key not found %s", keystr); return false; } as_record_destroy(r1); } return true; }
/** * Creates 100 records and 9 indexes. * * Records are structured as: * {a: String, b: Integer, c: Integer, d: Integer, e: Integer} * * The key is "a-b-c-d-e" * * The values are: * a = "abc" * b = 100 * c = <current index> * d = c % 10 * e = b + (c + 1) * (d + 1) / 2 */ bool query_foreach_create() { as_error err; as_error_reset(&err); int n_recs = 100; as_status status; as_index_task task; // create index on "a" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "a", "idx_test_a", AS_INDEX_STRING); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create index on "b" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "b", "idx_test_b", AS_INDEX_NUMERIC); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create index on "c" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "c", "idx_test_c", AS_INDEX_NUMERIC); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create index on "d" status = aerospike_index_create(as, &err, &task, NULL, NAMESPACE, SET, "d", "idx_test_d", AS_INDEX_NUMERIC); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create complex index on "x" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "x", "idx_test_x", AS_INDEX_TYPE_LIST, AS_INDEX_STRING); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create complex index on "y" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "y", "idx_test_y", AS_INDEX_TYPE_MAPKEYS, AS_INDEX_STRING); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create complex index on "y" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "y", "idx_test_y1", AS_INDEX_TYPE_MAPVALUES, AS_INDEX_STRING); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // create complex index on "z" status = aerospike_index_create_complex(as, &err, &task, NULL, NAMESPACE, SET, "z", "idx_test_z", AS_INDEX_TYPE_LIST, AS_INDEX_NUMERIC); if ( status == AEROSPIKE_OK ) { aerospike_index_create_wait(&err, &task, 0); } else { info("error(%d): %s", err.code, err.message); } // insert records for ( int i = 0; i < n_recs; i++ ) { char * a = "abc"; int b = n_recs; int c = i; int d = i % 10; int e = b + (c + 1) * (d + 1) / 2; char keystr[64] = { '\0' }; snprintf(keystr, 64, "%s-%d-%d-%d-%d", a, b, c, d, e); // Make list as_arraylist list; as_arraylist_init(&list, 3, 0); if ( (i%3) == 0) { as_arraylist_append_str(&list, "x"); as_arraylist_append_str(&list, "x1"); as_arraylist_append_str(&list, "x2"); } else { as_arraylist_append_str(&list, "not_x1"); as_arraylist_append_str(&list, "not_x2"); as_arraylist_append_str(&list, "not_x3"); } // Make map as_hashmap map; as_hashmap_init(&map, 1); if ( (i%7) == 0) { as_stringmap_set_str((as_map *) &map, "ykey", "yvalue"); } else { as_stringmap_set_str((as_map *) &map, "ykey_not", "yvalue_not"); } // Make list of integers as_arraylist list2; as_arraylist_init(&list2, 5, 0); as_arraylist_append_int64(&list2, i); as_arraylist_append_int64(&list2, i+1); as_arraylist_append_int64(&list2, i+2); as_arraylist_append_int64(&list2, i+3); as_arraylist_append_int64(&list2, i+4); as_record r; as_record_init(&r, 9); as_record_set_str(&r, "a", a); as_record_set_int64(&r, "b", b); as_record_set_int64(&r, "c", c); as_record_set_int64(&r, "d", d); as_record_set_int64(&r, "e", e); as_record_set_list(&r, "x", (as_list *) &list); as_record_set_map(&r, "y", (as_map *) &map); as_record_set_list(&r, "z", (as_list *) &list2); as_key key; as_key_init(&key, NAMESPACE, SET, keystr); aerospike_key_put(as, &err, NULL, &key, &r); as_record_destroy(&r); if (err.code != AEROSPIKE_OK) { error("aerospike_key_put() failed %d %s", err.code, err.message); return false; } as_record *r1 = NULL; aerospike_key_exists(as, &err, NULL, &key, &r1); as_key_destroy(&key); if (err.code != AEROSPIKE_OK) { error("aerospike_key_exists() failed %d %s", err.code, err.message); return false; } if (! r1) { error("key not found %s", keystr); return false; } as_record_destroy(r1); } return true; }
int main(int argc, char* argv[]) { // Parse command line arguments. if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) { exit(-1); } // Connect to the aerospike database cluster. aerospike as; example_connect_to_aerospike(&as); // Start clean. example_remove_test_record(&as); as_error err; // Create an as_record object with two bins with different value types. By // using as_record_inita(), we won't need to destroy the record if we only // set bins using as_record_set_int64(), as_record_set_str(), and // as_record_set_nil(). as_record rec; as_record_inita(&rec, 2); as_record_set_int64(&rec, "test-bin-1", 1234); as_record_set_str(&rec, "test-bin-2", "test-bin-2-data"); // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. if (aerospike_key_put(&as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("write succeeded"); if (! example_read_test_record(&as)) { example_cleanup(&as); exit(-1); } // Generate a different as_record object to write. In general it's ok to // reuse the stack object by calling as_record_inita() again, as long as the // previous contents are destroyed if necessary. as_record_inita(&rec, 2); as_record_set_int64(&rec, "test-bin-2", 2222); as_record_set_str(&rec, "test-bin-3", "test-bin-3-data"); // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. This will change the type and value of // test-bin-2, will add test-bin-3, and will leave test-bin-one unchanged. if (aerospike_key_put(&as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("write succeeded"); if (! example_read_test_record(&as)) { example_cleanup(&as); exit(-1); } // Generate another as_record object to write. as_record_inita(&rec, 1); as_record_set_nil(&rec, "test-bin-3"); // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. This will remove test-bin-3 and // will leave test-bin-1 and test-bin-2 unchanged. if (aerospike_key_put(&as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("write succeeded"); if (! example_read_test_record(&as)) { example_cleanup(&as); exit(-1); } // Generate another as_record object to write. as_record_inita(&rec, 1); as_record_set_int64(&rec, "test-bin-1", 1111); // Require that the write succeeds only if the record doesn't exist. as_policy_write wpol; as_policy_write_init(&wpol); wpol.exists = AS_POLICY_EXISTS_CREATE; // Log its contents. LOG("as_record object to create in database:"); example_dump_record(&rec); // Try to create the record. This should fail since the record already // exists in the database. if (aerospike_key_put(&as, &err, &wpol, &g_key, &rec) != AEROSPIKE_ERR_RECORD_EXISTS) { LOG("aerospike_key_put() returned %d - %s, expected " "AEROSPIKE_ERR_RECORD_EXISTS", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("create failed as expected"); // Remove the record from the database so we can demonstrate create success. if (aerospike_key_remove(&as, &err, NULL, &g_key) != AEROSPIKE_OK) { LOG("aerospike_key_remove() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("record removed from database, trying create again"); // Try to create the record again. This should succeed since the record is // not currently in the database. if (aerospike_key_put(&as, &err, &wpol, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("create succeeded"); if (! example_read_test_record(&as)) { example_cleanup(&as); exit(-1); } // Cleanup and disconnect from the database cluster. example_cleanup(&as); LOG("put example successfully completed"); return 0; }
static as_record add_bins_to_rec(lua_State *L, int index, int numBins) { as_record rec; as_record_init(&rec, numBins); // Push another reference to the table on top of the stack (so we know // where it is, and this function can work for negative, positive and // pseudo indices lua_pushvalue(L, index); // stack now contains: -1 => table lua_pushnil(L); // stack now contains: -1 => nil; -2 => table while (lua_next(L, -2)) { // stack now contains: -1 => value; -2 => key; -3 => table // copy the key so that lua_tostring does not modify the original lua_pushvalue(L, -2); // stack now contains: -1 => key; -2 => value; -3 => key; -4 => table const char *binName = lua_tostring(L, -1); // add to record if (lua_isnumber(L, -2)){ int intValue = lua_tointeger(L, -2); as_record_set_int64(&rec, binName, intValue); } else if (lua_isstring(L, -2)){ const char *value = lua_tostring(L, -2); as_record_set_str(&rec, binName, value); } else if (lua_istable(L, -2)){ // make a as_list and populate it as_arraylist *list = as_arraylist_new(3, 3); lua_pushvalue(L, -2); lua_pushnil(L); // This is needed for it to even get the first value while (lua_next(L, -2)) { lua_pushvalue(L, -2); //const char *key = lua_tostring(L, -1); const char *value = lua_tostring(L, -2); // populate the as_list as_arraylist_append_str(list, value); //printf("%s => %s\n", key, value); lua_pop(L, 2); } lua_pop(L, 1); // put the list in a bin as_record_set_list(&rec, binName, (as_list*)as_val_reserve(list)); } // pop value + copy of key, leaving original key lua_pop(L, 2); // stack now contains: -1 => key; -2 => table } // stack now contains: -1 => table (when lua_next returns 0 it pops the key // but does not push anything.) // Pop table lua_pop(L, 1); // Stack is now the same as it was on entry to this function return rec; }
int main(int argc, char* argv[]) { // Parse command line arguments. if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) { exit(-1); } // Connect to the aerospike database cluster. aerospike as; example_connect_to_aerospike(&as); // Start clean. example_remove_test_record(&as); as_error err; // Create an as_record object with one (integer value) bin. By using // as_record_inita(), we won't need to destroy the record if we only set // bins using as_record_set_int64(). as_record rec; as_record_inita(&rec, 1); as_record_set_int64(&rec, TEST_BIN, 1001); // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. If the record isn't already in the // database, it will be created with generation = 1. if (aerospike_key_put(&as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("write succeeded"); uint16_t gen; // Read the record back, and get its generation. if (! read_generation(&as, &gen)) { example_cleanup(&as); exit(-1); } // Update the as_record object with a different bin value. In general it's // ok to do this - all as_record_set_... calls destroy any previous value. as_record_set_int64(&rec, TEST_BIN, 1002); // Set its generation equal to that of the record in the database. rec.gen = gen; // Require that the next write will only succeed if generations match. as_policy_write wpol; as_policy_write_init(&wpol); wpol.gen = AS_POLICY_GEN_EQ; // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Re-write the record in the database. The write should succeed, and // increment the generation. if (aerospike_key_put(&as, &err, &wpol, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("re-write requiring generation = %u succeeded", rec.gen); // Read the record back, and get its generation. if (! read_generation(&as, &gen)) { example_cleanup(&as); exit(-1); } // Update the record object with a different bin value. as_record_set_int64(&rec, TEST_BIN, 1003); // Set its generation way past that of the record in the database. rec.gen = gen + 10; // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Try to re-write the record in the database. Use the same write policy, // requiring generations to match. This write should fail. if (aerospike_key_put(&as, &err, &wpol, &g_key, &rec) != AEROSPIKE_ERR_RECORD_GENERATION) { LOG("aerospike_key_put() returned %d - %s, expected " "AEROSPIKE_ERR_RECORD_GENERATION", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("re-write requiring generation = %u failed as expected", rec.gen); // Now require that the next write will only succeed if the specified // generation is greater than that of the record in the database. wpol.gen = AS_POLICY_GEN_GT; // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Try again. This write should succeed, and increment the generation. (Note // that it does not write the record with the local generation!) if (aerospike_key_put(&as, &err, &wpol, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("re-write requiring generation < %u succeeded", rec.gen); // Read the record back, and get its generation. if (! read_generation(&as, &gen)) { example_cleanup(&as); exit(-1); } // Cleanup and disconnect from the database cluster. example_cleanup(&as); LOG("generation example successfully completed"); return 0; }
int main(int argc, char* argv[]) { // Parse command line arguments. if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) { exit(-1); } // Connect to the aerospike database cluster. aerospike as; example_connect_to_aerospike(&as); // Start clean. example_remove_test_record(&as); as_error err; // Create an as_record object with one (integer value) bin. By using // as_record_inita(), we won't need to destroy the record if we only set // bins using as_record_set_int64(). as_record rec; as_record_inita(&rec, 1); as_record_set_int64(&rec, "test-bin", 1234); // Set the TTL of the record so it will last a minute. rec.ttl = 60; // Log its contents. LOG("as_record object to write to database:"); example_dump_record(&rec); // Write the record to the database. if (aerospike_key_put(&as, &err, NULL, &g_key, &rec) != AEROSPIKE_OK) { LOG("aerospike_key_put() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("write succeeded"); if (! example_read_test_record(&as)) { example_cleanup(&as); exit(-1); } // Create an as_operations object with a touch operation. Generally, if // using as_operations_inita(), we won't need to destroy the object unless // we call as_operations_add_write() with an externally allocated // as_bin_value. as_operations ops; as_operations_inita(&ops, 1); as_operations_add_touch(&ops); // Set the TTL of the record so it will last two minutes. ops.ttl = 120; // Log the operation. LOG("as_operations object to apply to database:"); example_dump_operations(&ops); // Apply the operation. Note that it does increment the record generation. if (aerospike_key_operate(&as, &err, NULL, &g_key, &ops, NULL) != AEROSPIKE_OK) { LOG("aerospike_key_operate() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("operation succeeded"); if (! example_read_test_record(&as)) { example_cleanup(&as); exit(-1); } // Cleanup and disconnect from the database cluster. example_cleanup(&as); LOG("touch example successfully completed"); return 0; }
void clbin_to_asval(cl_bin * bin, as_serializer * ser, as_val ** val) { if ( val == NULL ) return; switch( bin->object.type ) { case CL_NULL :{ *val = (as_val *) &as_nil; break; } case CL_INT : { *val = (as_val *) as_integer_new(bin->object.u.i64); break; } case CL_STR : { // steal the pointer from the object into the val *val = (as_val *) as_string_new(strdup(bin->object.u.str), true /*ismalloc*/); // TODO: re-evaluate the follow zero-copy for strings from cl_bins // *val = (as_val *) as_string_new(bin->object.u.str, true /*ismalloc*/); // bin->object.free = NULL; break; } case CL_LIST : case CL_MAP : { // use a temporary buffer, which doesn't need to be destroyed as_buffer buf = { .capacity = (uint32_t) bin->object.sz, .size = (uint32_t) bin->object.sz, .data = (uint8_t *) bin->object.u.blob }; // print_buffer(&buf); as_serializer_deserialize(ser, &buf, val); break; } case CL_BLOB: case CL_JAVA_BLOB: case CL_CSHARP_BLOB: case CL_PYTHON_BLOB: case CL_RUBY_BLOB: case CL_ERLANG_BLOB: default : { *val = NULL; uint8_t * raw = malloc(sizeof(bin->object.sz)); memcpy(raw, bin->object.u.blob, bin->object.sz); as_bytes * b = as_bytes_new_wrap(raw, (uint32_t)bin->object.sz, true /*ismalloc*/); b->type = (as_bytes_type)bin->object.type; *val = (as_val *) b; break; } } } void clbin_to_asrecord(cl_bin * bin, as_record * r) { switch(bin->object.type) { case CL_NULL: { as_record_set_nil(r, bin->bin_name); break; } case CL_INT: { as_record_set_int64(r, bin->bin_name, bin->object.u.i64); break; } case CL_STR: { as_record_set_strp(r, bin->bin_name, bin->object.u.str, true); // the following completes the handoff of the value. bin->object.free = NULL; break; } case CL_LIST: case CL_MAP: { as_val * val = NULL; as_buffer buffer; buffer.data = (uint8_t *) bin->object.u.blob; buffer.size = (uint32_t)bin->object.sz; as_serializer ser; as_msgpack_init(&ser); as_serializer_deserialize(&ser, &buffer, &val); as_serializer_destroy(&ser); as_record_set(r, bin->bin_name, (as_bin_value *) val); break; } default: { as_record_set_rawp(r, bin->bin_name, bin->object.u.blob, (uint32_t)bin->object.sz, true); // the following completes the handoff of the value. bin->object.free = NULL; break; } } } void clbins_to_asrecord(cl_bin * bins, uint32_t nbins, as_record * r) { uint32_t n = nbins < r->bins.capacity ? nbins : r->bins.capacity; for ( int i = 0; i < n; i++ ) { clbin_to_asrecord(&bins[i], r); } }