/** * Test TWO is one more step in complexity -- it does the simple * push and peek with the Stumble data -- and so does a compress * and uncompress of the data using the inner UDF. Notice that * the CREATE of this LSTACK BIN must have the correct parameters * set for doing the inner UDF call (e.g. BINARY type, and entry * size). */ int run_test2(char *user_key) { static char * meth = "run_test2()"; int rc = 0; char * ldt_bin_name = "LSET_TEST2_BIN"; char * compress_func = "stumbleCompress5"; as_list *compress_args = as_arraylist_new( 1, 1 ); as_list *uncompress_args = as_arraylist_new( 1, 1 ); as_list_add_integer( compress_args, 1 ); // dummy argument int iterations = g_config->n_iterations; INFO("[DEBUG]<%s:%s>Call ldt_write_with_transform_test()\n", MOD, meth ); rc = ldt_write_list_with_transform_test( user_key, ldt_bin_name, NULL, iterations ); if (rc) { INFO("[ERROR]<%s:%s>write result: RC(%d)\n", MOD, meth, rc); goto Cleanup; } char * uncompress_func = "stumbleUnCompress5"; as_list_add_integer( uncompress_args, 1 ); // dummy argument INFO("[DEBUG]:<%s:%s>: calling ldt_read_with_filter_test()\n", MOD, meth ); rc = ldt_read_list_with_filter_test( user_key, ldt_bin_name, uncompress_func, uncompress_args, g_config->n_iterations ); if (rc) { INFO("[ERROR]:<%s:%s>: ldt_read_with_filter_test() RC(%d)\n", MOD, meth, rc); goto Cleanup; } Cleanup: as_list_destroy( uncompress_args ); as_list_destroy( compress_args ); return ( rc ); } // end run_test2
/** * Destroy an as_udf_call. */ void as_udf_call_destroy(as_udf_call * call) { if ( call ) { call->module[0] = '\0'; call->function[0] = '\0'; if (call->arglist) { as_list_destroy(call->arglist); call->arglist = NULL; } if ( call->_free ) { free(call); } } }
cl_rv cl_scan_udf_destroy(cl_scan_udf * udf) { udf->type = CL_SCAN_UDF_NONE; if ( udf->filename ) { free(udf->filename); udf->filename = NULL; } if ( udf->function ) { free(udf->function); udf->function = NULL; } if ( udf->arglist ) { as_list_destroy(udf->arglist); udf->arglist = NULL; } return CITRUSLEAF_OK; }
ERL_NIF_TERM as_ldt_lset_get(ErlNifEnv* env, handle_t* handle, void* obj) { ldt_get_args_t* args = (ldt_get_args_t*)obj; as_status res; as_error err; as_list* p_list = NULL; res = aerospike_lset_filter(&handle->instance, &err, NULL, &args->key, &args->ldt, NULL, NULL, &p_list); as_ldt_clean_get_args(env, args); if(res != AEROSPIKE_OK) return A_AS_ERROR(env, err); ERL_NIF_TERM* results; uint32_t nresults = as_list_size(p_list); results = malloc(sizeof(ERL_NIF_TERM) * nresults); as_arraylist_iterator it; as_arraylist_iterator_init(&it, (const as_arraylist*)p_list); int i = 0; // See if the elements match what we expect. while (as_arraylist_iterator_has_next(&it)) { const as_val* p_val = as_arraylist_iterator_next(&it); results[i++] = make_nif_term_from_as_val(env, p_val); } as_list_destroy(p_list); p_list = NULL; ERL_NIF_TERM returnValue; returnValue = enif_make_list_from_array(env, results, nresults); free(results); return A_OK_VALUE(env, returnValue); }
static bool asc_raw_read(aerospike* p_as, as_key* p_key, uint8_t *buf, uint32_t size) { as_status status; as_error err; uint32_t lstack_size; uint32_t offset, chksize; // Create a large stack object to use as_ldt lstack; as_ldt_init(&lstack, "data", AS_LDT_LSTACK, NULL); // Get stack size status = aerospike_lstack_size(p_as, &err, NULL, p_key, &lstack, &lstack_size); if (status != AEROSPIKE_OK) { ERROR("aerospike_lstack_size() returned %d - %s", err.code, err.message); return false; } // Peek all the values back again. as_list* p_list = NULL; status = aerospike_lstack_peek(p_as, &err, NULL, p_key, &lstack, lstack_size, &p_list); if (status != AEROSPIKE_OK) { ERROR("aerospike_lstack_peek() returned %d - %s", err.code, err.message); return false; } // Read the content as_val** p_val = ((const as_arraylist*)p_list)->elements; for (offset = 0; offset < size; offset += chksize) { const as_bytes* p_bytes = (const as_bytes*)*p_val++; chksize = MIN(size - offset, p_bytes->size); memcpy(buf + offset, p_bytes->value, chksize); } as_list_destroy(p_list); p_list = NULL; 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_ldt lstack; // Create a large stack bin to use. No need to destroy as_ldt if using // as_ldt_init() on stack object. if (! as_ldt_init(&lstack, "mystack", AS_LDT_LSTACK, NULL)) { LOG("unable to initialize ldt"); example_cleanup(&as); exit(-1); } as_error err; // No need to destroy as_integer if using as_integer_init() on stack object. as_integer ival; as_integer_init(&ival, 123); // Push a few values onto the stack. if (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&ival) != AEROSPIKE_OK) { LOG("first aerospike_lstack_push() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } // No need to destroy as_string if using as_string_init() on stack object. as_string sval; as_string_init(&sval, "string stack value", false); if (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&sval) != AEROSPIKE_OK) { LOG("second aerospike_lstack_push() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } LOG("2 values pushed"); uint32_t n_elements = 0; // Look at the stack size right now. if (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) != AEROSPIKE_OK) { LOG("aerospike_lstack_size() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } if (n_elements != 2) { LOG("unexpected stack size %u", n_elements); example_cleanup(&as); exit(-1); } LOG("stack size confirmed to be %u", n_elements); as_ldt lstack2; as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL); uint32_t peek_count = 3; as_list* p_list = NULL; // Peek a few values back. if (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, peek_count, &p_list) != AEROSPIKE_OK) { LOG("first aerospike_lstack_peek() returned %d - %s", err.code, err.message); as_list_destroy(p_list); example_cleanup(&as); exit(-1); } as_arraylist_iterator it; as_arraylist_iterator_init(&it, (const as_arraylist*)p_list); // See if the elements match what we expect. while (as_arraylist_iterator_has_next(&it)) { const as_val* p_val = as_arraylist_iterator_next(&it); char* p_str = as_val_tostring(p_val); LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str); free(p_str); } as_list_destroy(p_list); p_list = NULL; // Push 3 more items onto the stack. By using as_arraylist_inita() we avoid // some but not all internal heap usage, so we must call // as_arraylist_destroy(). as_arraylist vals; as_arraylist_inita(&vals, 3); as_arraylist_append_int64(&vals, 1000); as_arraylist_append_int64(&vals, 2000); as_arraylist_append_int64(&vals, 3000); if (aerospike_lstack_push_all(&as, &err, NULL, &g_key, &lstack, (const as_list*)&vals) != AEROSPIKE_OK) { LOG("aerospike_lstack_pushall() returned %d - %s", err.code, err.message); as_arraylist_destroy(&vals); example_cleanup(&as); exit(-1); } as_arraylist_destroy(&vals); LOG("3 more values pushed"); as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL); peek_count = 10; // Peek all the values back again. if (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, peek_count, &p_list) != AEROSPIKE_OK) { LOG("second aerospike_lstack_peek() returned %d - %s", err.code, err.message); as_list_destroy(p_list); example_cleanup(&as); exit(-1); } // See if the elements match what we expect. as_arraylist_iterator_init(&it, (const as_arraylist*)p_list); while (as_arraylist_iterator_has_next(&it)) { const as_val* p_val = as_arraylist_iterator_next(&it); char* p_str = as_val_tostring(p_val); LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str); free(p_str); } as_list_destroy(p_list); // Set capacity for the lstack. if (aerospike_lstack_set_capacity(&as, &err, NULL, &g_key, &lstack, 10000) != AEROSPIKE_OK) { LOG("aerospike_lstack_set_capacity() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } uint32_t cap_size = 0; // Get capacity from the lstack. if (aerospike_lstack_get_capacity(&as, &err, NULL, &g_key, &lstack, &cap_size) != AEROSPIKE_OK) { LOG("aerospike_lstack_get_capacity() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } if (cap_size != 10000) { LOG("unexpected capacity size %u", cap_size); example_cleanup(&as); exit(-1); } // Destroy the lstack. if (aerospike_lstack_destroy(&as, &err, NULL, &g_key, &lstack) != AEROSPIKE_OK) { LOG("aerospike_lstack_destroy() returned %d - %s", err.code, err.message); example_cleanup(&as); exit(-1); } n_elements = 0; // See if we can still do any lstack operations. if (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) == AEROSPIKE_OK) { LOG("aerospike_lstack_size() did not return error"); example_cleanup(&as); exit(-1); } // Cleanup and disconnect from the database cluster. example_cleanup(&as); LOG("lstack example successfully completed"); return 0; }
/** ******************************************************************************************************* * This function applies a registered udf module on a particular record. * * @param self AerospikeClient object * @param py_key The key under which to store the record. * @param py_module The module name. * @param py_function The UDF function to be applied on a record. * @param py_arglist The arguments to the UDF function * @param py_policy The optional policy parameters * * Returns the result of UDF function. ******************************************************************************************************* */ PyObject * AerospikeClient_Apply_Invoke( AerospikeClient * self, PyObject * py_key, PyObject * py_module, PyObject * py_function, PyObject * py_arglist, PyObject * py_policy) { // Python Return Value PyObject * py_result = NULL; // Aerospike Client Arguments as_error err; as_policy_apply apply_policy; as_policy_apply * apply_policy_p = NULL; as_key key; char * module = NULL; char * function = NULL; as_list * arglist = NULL; as_val * result = NULL; PyObject * py_umodule = NULL; PyObject * py_ufunction = NULL; // Initialisation flags bool key_initialised = false; // Initialize error as_error_init(&err); if( !PyList_Check(py_arglist) ) { PyErr_SetString(PyExc_TypeError, "expected UDF method arguments in a 'list'"); return NULL; } if (!self || !self->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python key object to as_key pyobject_to_key(&err, py_key, &key); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // Key is initialiased successfully key_initialised = true; // Convert python list to as_list pyobject_to_list(self, &err, py_arglist, &arglist, NULL, -1); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } if ( PyUnicode_Check(py_module) ) { py_umodule = PyUnicode_AsUTF8String(py_module); module = PyStr_AsString(py_umodule); } else if ( PyStr_Check(py_module) ) { module = PyStr_AsString(py_module); } else { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf module argument must be a string or unicode string"); goto CLEANUP; } if ( PyUnicode_Check(py_function) ) { py_ufunction = PyUnicode_AsUTF8String(py_function); function = PyStr_AsString(py_ufunction); } else if ( PyStr_Check(py_function) ) { function = PyStr_AsString(py_function); } else { as_error_update(&err, AEROSPIKE_ERR_CLIENT, "function name must be a string or unicode string"); goto CLEANUP; } // Invoke operation aerospike_key_apply(self->as, &err, apply_policy_p, &key, module, function, arglist, &result); if ( err.code == AEROSPIKE_OK ) { val_to_pyobject(&err, result, &py_result); } else { as_error_update(&err, err.code, NULL); } CLEANUP: if (py_umodule) { Py_DECREF(py_umodule); } if (py_ufunction) { Py_DECREF(py_ufunction); } if (key_initialised == true) { // Destroy the key if it is initialised successfully. as_key_destroy(&key); } as_list_destroy(arglist); as_val_destroy(result); if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyObject *exception_type = raise_exception(&err); if(PyObject_HasAttrString(exception_type, "key")) { PyObject_SetAttrString(exception_type, "key", py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject_SetAttrString(exception_type, "bin", Py_None); } if(PyObject_HasAttrString(exception_type, "module")) { PyObject_SetAttrString(exception_type, "module", py_module); } if(PyObject_HasAttrString(exception_type, "func")) { PyObject_SetAttrString(exception_type, "func", py_function); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_result; }
/** ******************************************************************************************************** * Scan the map and apply a predicate filter. * * @param self AerospikeLMap object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of elements from the map after applying predicate. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLMap_Filter(AerospikeLMap * self, PyObject * args, PyObject * kwds) { char* filter_name = NULL; PyObject * py_args = NULL; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* arg_list = NULL; as_map* elements = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"udf_function_name", "args", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "|sOO:filter", kwlist, &filter_name, &py_args, &py_policy) == false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } if ( py_args && !filter_name) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name"); goto CLEANUP; } if ( py_args && !PyList_Check(py_args)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)"); goto CLEANUP; } if (py_args) { pyobject_to_list(&err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON); } aerospike_lmap_filter(self->client->as, &err, apply_policy_p, &self->key, &self->lmap, filter_name, arg_list, &elements); if (err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); goto CLEANUP; } PyObject* py_map = NULL; map_to_pyobject(&err, elements, &py_map); CLEANUP: if (elements) { as_map_destroy(elements); } if (arg_list) { as_list_destroy(arg_list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyString_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_map; }
/** ******************************************************************************************************** * Add a list of objects to the set. * * @param self AerospikeLSet object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns an integer status. 0(Zero) is success value. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLSet_Add_Many(AerospikeLSet * self, PyObject * args, PyObject * kwds) { PyObject* py_arglist = NULL; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* arglist = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"values", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:add_many", kwlist, &py_arglist, &py_policy)== false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } /* * Convert python list to as list */ if ( !PyList_Check(py_arglist)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid argument(type)"); goto CLEANUP; } pyobject_to_list(&err, py_arglist, &arglist, &static_pool, SERIALIZER_PYTHON); if (err.code != AEROSPIKE_OK) { goto CLEANUP; } aerospike_lset_add_all(self->client->as, &err, apply_policy_p, &self->key, &self->lset, arglist); if( err.code != AEROSPIKE_OK ) { as_error_update(&err, err.code, NULL); } CLEANUP: if (arglist) { as_list_destroy(arglist); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyString_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return PyLong_FromLong(0); }
/** ******************************************************************************************************** * Fetch the top N elements from the stack. * * @param self AerospikeLStack object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of elements. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLStack_Peek(AerospikeLStack * self, PyObject * args, PyObject * kwds) { long peek_count = 0; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* list = NULL; as_error err; as_error_init(&err); static char * kwlist[] = {"peek_count", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "l|O:peek", kwlist, &peek_count, &py_policy) == false ) { return NULL; } if (!self || !self->client || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } /* * Peek values from stack */ Py_BEGIN_ALLOW_THREADS aerospike_lstack_peek(self->client->as, &err, apply_policy_p, &self->key, &self->lstack, peek_count, &list); Py_END_ALLOW_THREADS if (err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); goto CLEANUP; } PyObject* py_list = NULL; list_to_pyobject(self->client, &err, list, &py_list); CLEANUP: if (list) { as_list_destroy(list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyString_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_list; }
/** ******************************************************************************************************** * Scan the stack and apply a predicate filter. * * @param self AerospikeLStack object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of elements(peek_count) from the stack after applying predicate. * In case of error, Appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLStack_Filter(AerospikeLStack * self, PyObject * args, PyObject * kwds) { long peek_count = 0; char* filter_name = NULL; PyObject * py_args = NULL; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* arg_list = NULL; as_list* elements_list = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"peek_count", "udf_function_name", "args", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "|lsOO:filter", kwlist, &peek_count, &filter_name, &py_args, &py_policy) == false ) { return NULL; } if (!self || !self->client || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } if ( py_args && !filter_name) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name"); goto CLEANUP; } if ( py_args && !PyList_Check(py_args)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)"); goto CLEANUP; } if (py_args) { pyobject_to_list(&err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON); } aerospike_lstack_filter(self->client->as, &err, apply_policy_p, &self->key, &self->lstack, peek_count, filter_name, arg_list, &elements_list); if (err.code != AEROSPIKE_OK) { goto CLEANUP; } PyObject* py_list = NULL; list_to_pyobject(&err, elements_list, &py_list); CLEANUP: if (elements_list) { as_list_destroy(elements_list); } if (arg_list) { as_list_destroy(arg_list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyErr_SetObject(PyExc_Exception, py_err); Py_DECREF(py_err); return NULL; } return py_list; }
/** ******************************************************************************************************** * Fetch the top N elements from the stack. * * @param self AerospikeLStack object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of elements. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLStack_Peek(AerospikeLStack * self, PyObject * args, PyObject * kwds) { long peek_count = 0; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* list = NULL; as_error err; as_error_init(&err); static char * kwlist[] = {"peek_count", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "l|O:peek", kwlist, &peek_count, &py_policy) == false ) { return NULL; } if (!self || !self->client || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } /* * Peek values from stack */ aerospike_lstack_peek(self->client->as, &err, apply_policy_p, &self->key, &self->lstack, peek_count, &list); if (err.code != AEROSPIKE_OK) { goto CLEANUP; } PyObject* py_list = NULL; list_to_pyobject(&err, list, &py_list); CLEANUP: if (list) { as_list_destroy(list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL; error_to_pyobject(&err, &py_err); PyErr_SetObject(PyExc_Exception, py_err); Py_DECREF(py_err); return NULL; } return py_list; }
int main(int argc, char* argv[]) { aerospike as; as_error err; as_boolean ldt_exists; as_ldt lstack, lstack2; as_integer ival; as_string sval; as_bytes bval; uint32_t n_elements, cap_size; as_arraylist_iterator it; as_list* p_list = NULL; // Parse command line arguments. if (! example_get_opts(argc, argv, EXAMPLE_BASIC_OPTS)) { exit(-1); } // Connect to the aerospike database cluster. example_connect_to_aerospike(&as); // Start clean. example_remove_test_record(&as); // Create a large stack object to use. No need to destroy lstack if using // as_ldt_init() on stack object. as_ldt_init(&lstack, "mystack", AS_LDT_LSTACK, NULL); // Verify that the LDT is not already there. as_boolean_init(&ldt_exists, false); assert (aerospike_lstack_ldt_exists(&as, &err, NULL, &g_key, &lstack, &ldt_exists) == AEROSPIKE_OK); assert (as_boolean_get(&ldt_exists) == false); LOG("verified that lstack ldt is not present"); // Push a few values onto the stack. // No need to destroy sval if using as_string_init() on stack object. // Push an integer as_integer_init(&ival, 123); assert (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&ival) == AEROSPIKE_OK); // Push a string as_string_init(&sval, "string stack value", false); assert (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&sval) == AEROSPIKE_OK); // Push bytes uint8_t buf[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; as_bytes_init_wrap(&bval, buf, 16, false); assert (aerospike_lstack_push(&as, &err, NULL, &g_key, &lstack, (const as_val*)&bval) == AEROSPIKE_OK); // Look at the stack size right now. assert (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) == AEROSPIKE_OK); LOG("%d values pushed", n_elements); // Peek a few values back. as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL); assert (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, 3, &p_list) == AEROSPIKE_OK); // See if the elements match what we expect. as_arraylist_iterator_init(&it, (const as_arraylist*)p_list); while (as_arraylist_iterator_has_next(&it)) { const as_val* p_val = as_arraylist_iterator_next(&it); char* p_str = as_val_tostring(p_val); LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str); free(p_str); } as_list_destroy(p_list); p_list = NULL; // Push 3 more items onto the stack. By using as_arraylist_inita() we avoid // some but not all internal heap usage, so we must call // as_arraylist_destroy(). as_arraylist vals; as_arraylist_inita(&vals, 3); as_arraylist_append_int64(&vals, 1000); as_arraylist_append_int64(&vals, 2000); as_arraylist_append_int64(&vals, 3000); assert (aerospike_lstack_push_all(&as, &err, NULL, &g_key, &lstack, (const as_list*)&vals) == AEROSPIKE_OK); as_arraylist_destroy(&vals); LOG("3 more values pushed"); // Peek all the values back again. as_ldt_init(&lstack2, "mystack", AS_LDT_LSTACK, NULL); assert (aerospike_lstack_peek(&as, &err, NULL, &g_key, &lstack2, 10, &p_list) == AEROSPIKE_OK); // See if the elements match what we expect. #if 0 as_arraylist_iterator_init(&it, (const as_arraylist*)p_list); while (as_arraylist_iterator_has_next(&it)) { const as_val* p_val = as_arraylist_iterator_next(&it); char* p_str = as_val_tostring(p_val); LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str); free(p_str); } #else const as_arraylist* p_array = (const as_arraylist*)p_list; int i; for (i = 0; i < p_array->size; i++) { const as_val* p_val = p_array->elements[i]; char* p_str = as_val_tostring(p_val); LOG(" peek - type = %d, value = %s", as_val_type(p_val), p_str); free(p_str); } #endif as_list_destroy(p_list); p_list = NULL; // Set capacity for the lstack. assert (aerospike_lstack_set_capacity(&as, &err, NULL, &g_key, &lstack, 10000) == AEROSPIKE_OK); // Get capacity from the lstack. assert (aerospike_lstack_get_capacity(&as, &err, NULL, &g_key, &lstack, &cap_size) == AEROSPIKE_OK); assert (cap_size == 10000); // Verify that the LDT is now present. as_boolean_init(&ldt_exists, false); assert (aerospike_lstack_ldt_exists(&as, &err, NULL, &g_key, &lstack, &ldt_exists) == AEROSPIKE_OK); assert (as_boolean_get(&ldt_exists) == true); LOG("verified that lstack ldt is present"); // Destroy the lstack. assert (aerospike_lstack_destroy(&as, &err, NULL, &g_key, &lstack) == AEROSPIKE_OK); // See if we can still do any lstack operations. assert (aerospike_lstack_size(&as, &err, NULL, &g_key, &lstack, &n_elements) != AEROSPIKE_OK); // Cleanup and disconnect from the database cluster. example_cleanup(&as); LOG("lstack example successfully completed"); return 0; }
/** ******************************************************************************************************** * Select values from the end of list up to a maximum count. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of ldt contents. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Find_Last(AerospikeLList * self, PyObject * args, PyObject * kwds) { PyObject* py_count = NULL; PyObject* py_policy = NULL; PyObject* py_elements_list = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* elements_list = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"count", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find_last", kwlist, &py_count, &py_policy)== false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } uint32_t count = 0; if ( PyInt_Check(py_count)) { count = PyInt_AsLong(py_count); } else if( PyLong_Check(py_count) ) { count = PyLong_AsLong(py_count); if (count == (uint32_t)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Count should be an integer or long"); goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_find_last(self->client->as, &err, apply_policy_p, &self->key, &self->llist, count, &elements_list); Py_END_ALLOW_THREADS if(err.code != AEROSPIKE_OK) { goto CLEANUP; } list_to_pyobject(self->client, &err, elements_list, &py_elements_list); CLEANUP: if (elements_list) { as_list_destroy(elements_list); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if (PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if (PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_elements_list; }
/** ******************************************************************************************************** * Get an object from the list. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns an object from the list. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Get(AerospikeLList * self, PyObject * args, PyObject * kwds) { PyObject* py_value = NULL; PyObject* py_policy = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_val * val = NULL; as_list* list_p = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"value", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|O:get", kwlist, &py_value, &py_policy) == false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } pyobject_to_val(self->client, &err, py_value, &val, &static_pool, SERIALIZER_PYTHON); if (err.code != AEROSPIKE_OK) { goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_find(self->client->as, &err, apply_policy_p, &self->key, &self->llist, val, &list_p); Py_END_ALLOW_THREADS if (err.code != AEROSPIKE_OK) { as_error_update(&err, err.code, NULL); goto CLEANUP; } PyObject * py_list = NULL; list_to_pyobject(self->client, &err, list_p, &py_list); CLEANUP: if (val) { as_val_destroy(val); } if (list_p) { as_list_destroy(list_p); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if(PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if(PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_list; }
/** ******************************************************************************************************** * Select values from a begin key to end key corresponding to a value up to a maximum count applying a lua filter. * * @param self AerospikeLList object * @param args The args is a tuple object containing an argument * list passed from Python to a C function * @param kwds Dictionary of keywords * * Returns a list of ldt contents. * In case of error,appropriate exceptions will be raised. ******************************************************************************************************** */ PyObject * AerospikeLList_Range_Limit(AerospikeLList * self, PyObject * args, PyObject * kwds) { char* filter_name = NULL; PyObject* py_count = NULL; PyObject * py_args = NULL; PyObject* py_policy = NULL; PyObject* py_from_value = NULL; PyObject* py_end_value = NULL; PyObject* py_elements_list = NULL; PyObject* py_filter_name = NULL; as_policy_apply apply_policy; as_policy_apply* apply_policy_p = NULL; as_list* arg_list = NULL; as_list* elements_list = NULL; as_val* from_val = NULL; as_val* end_val = NULL; as_static_pool static_pool; memset(&static_pool, 0, sizeof(static_pool)); as_error err; as_error_init(&err); static char * kwlist[] = {"start_value", "end_value", "count", "function", "args", "policy", NULL}; // Python Function Argument Parsing if ( PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OOO:range_limit", kwlist, &py_from_value, &py_end_value, &py_count, &py_filter_name, &py_args, &py_policy)== false ) { return NULL; } if (!self || !self->client->as) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object"); goto CLEANUP; } if (!self->client->is_conn_16) { as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster"); goto CLEANUP; } // Convert python policy object to as_policy_apply pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p, &self->client->as->config.policies.apply); if ( err.code != AEROSPIKE_OK ) { goto CLEANUP; } uint32_t count = 0; if (PyInt_Check(py_count)) { count = PyInt_AsLong(py_count); } else if (PyLong_Check(py_count)) { count = PyLong_AsLong(py_count); if (count == (uint32_t)-1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize"); goto CLEANUP; } } } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Count should be an integer or long"); goto CLEANUP; } if(py_filter_name) { if(PyStr_Check(py_filter_name)) { filter_name = PyStr_AsString(py_filter_name); } else if(py_filter_name != Py_None) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter name should be string or None"); goto CLEANUP; } } if ( py_args && !py_filter_name) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter arguments without filter name"); goto CLEANUP; } if ( !PyList_Check(py_args) && (py_args != Py_None)) { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid filter argument(type)"); goto CLEANUP; } if (py_args != Py_None) { pyobject_to_list(self->client, &err, py_args, &arg_list, &static_pool, SERIALIZER_PYTHON); } if( py_from_value != Py_None && py_end_value != Py_None ) { pyobject_to_val(self->client, &err, py_from_value, &from_val, &static_pool, SERIALIZER_PYTHON); pyobject_to_val(self->client, &err, py_end_value, &end_val, &static_pool, SERIALIZER_PYTHON); } else { as_error_update(&err, AEROSPIKE_ERR_PARAM, "Begin or end key cannot be None"); goto CLEANUP; } Py_BEGIN_ALLOW_THREADS aerospike_llist_range_limit(self->client->as, &err, apply_policy_p, &self->key, &self->llist, from_val, end_val, count, filter_name, arg_list, &elements_list); Py_END_ALLOW_THREADS if(err.code != AEROSPIKE_OK) { goto CLEANUP; } list_to_pyobject(self->client, &err, elements_list, &py_elements_list); CLEANUP: if (elements_list) { as_list_destroy(elements_list); } if(from_val) { as_val_destroy(from_val); } if(end_val) { as_val_destroy(end_val); } if ( err.code != AEROSPIKE_OK ) { PyObject * py_err = NULL, *py_key = NULL; PyObject *exception_type = raise_exception(&err); error_to_pyobject(&err, &py_err); if (PyObject_HasAttrString(exception_type, "key")) { key_to_pyobject(&err, &self->key, &py_key); PyObject_SetAttrString(exception_type, "key", py_key); Py_DECREF(py_key); } if (PyObject_HasAttrString(exception_type, "bin")) { PyObject *py_bins = PyStr_FromString((char *)&self->bin_name); PyObject_SetAttrString(exception_type, "bin", py_bins); Py_DECREF(py_bins); } PyErr_SetObject(exception_type, py_err); Py_DECREF(py_err); return NULL; } return py_elements_list; }