All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
aerospike_key.h
Go to the documentation of this file.
1 /*
2  * Copyright 2008-2016 Aerospike, Inc.
3  *
4  * Portions may be licensed to Aerospike, Inc. under one or more contributor
5  * license agreements.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
8  * use this file except in compliance with the License. You may obtain a copy of
9  * the License at http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
14  * License for the specific language governing permissions and limitations under
15  * the License.
16  */
17 #pragma once
18 
19 /**
20  * @defgroup key_operations Key Operations
21  * @ingroup client_operations
22  *
23  * Aerospike provides a key based API to access and modify data into the
24  * cluster.
25  *
26  * The Key API is a collection of APIs that use as_key as for looking up
27  * records for accessing and modifying in the cluster.
28  *
29  */
30 
31 #include <aerospike/aerospike.h>
32 #include <aerospike/as_listener.h>
33 #include <aerospike/as_error.h>
34 #include <aerospike/as_key.h>
35 #include <aerospike/as_list.h>
37 #include <aerospike/as_policy.h>
38 #include <aerospike/as_record.h>
39 #include <aerospike/as_status.h>
40 #include <aerospike/as_val.h>
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 /******************************************************************************
47  * FUNCTIONS
48  *****************************************************************************/
49 
50 /**
51  * Look up a record by key and return all bins.
52  *
53  * ~~~~~~~~~~{.c}
54  * as_key key;
55  * as_key_init(&key, "ns", "set", "key");
56  *
57  * as_record* rec = NULL;
58  * if (aerospike_key_get(&as, &err, NULL, &key, &rec) != AEROSPIKE_OK) {
59  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
60  * }
61  * else {
62  * as_record_destroy(rec);
63  * }
64  * ~~~~~~~~~~
65  *
66  * @param as The aerospike instance to use for this operation.
67  * @param err The as_error to be populated if an error occurs.
68  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
69  * @param key The key of the record.
70  * @param rec The record to be populated with the data from request.
71  *
72  * @return AEROSPIKE_OK if successful. Otherwise an error.
73  *
74  * @ingroup key_operations
75  */
78  aerospike* as, as_error* err, const as_policy_read* policy, const as_key* key, as_record** rec
79  );
80 
81 /**
82  * Asynchronously look up a record by key and return all bins.
83  *
84  * ~~~~~~~~~~{.c}
85  * void my_listener(as_error* err, as_record* record, void* udata, as_event_loop* event_loop)
86  * {
87  * if (err) {
88  * printf("Command failed: %d %s\n", err->code, err->message);
89  * return;
90  * }
91  * // Process record bins
92  * // Do not call as_record_destroy() because the calling function will do that for you.
93  * }
94  *
95  * as_key key;
96  * as_key_init(&key, "ns", "set", "key");
97  *
98  * as_status status = aerospike_key_get_async(&as, &err, NULL, &key, my_listener, NULL, NULL, NULL);
99  * ~~~~~~~~~~
100  *
101  * @param as The aerospike instance to use for this operation.
102  * @param err The as_error to be populated if an error occurs.
103  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
104  * @param key The key of the record.
105  * @param listener User function to be called with command results.
106  * @param udata User data to be forwarded to user callback.
107  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
108  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
109  * has been sent to the server. This allows for issuing the next command even before receiving a
110  * result for the current command.
111  *
112  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
113  *
114  * @ingroup key_operations
115  */
116 as_status
118  aerospike* as, as_error* err, const as_policy_read* policy, const as_key* key,
119  as_async_record_listener listener, void* udata, as_event_loop* event_loop,
120  as_pipe_listener pipe_listener
121  );
122 
123 /**
124  * Lookup a record by key, then return specified bins.
125  *
126  * ~~~~~~~~~~{.c}
127  * char* select[] = {"bin1", "bin2", "bin3", NULL};
128  *
129  * as_key key;
130  * as_key_init(&key, "ns", "set", "key");
131  *
132  * as_record* rec = NULL;
133  * if (aerospike_key_select(&as, &err, NULL, &key, select, &rec) != AEROSPIKE_OK) {
134  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
135  * }
136  * else {
137  * as_record_destroy(rec);
138  * }
139  * ~~~~~~~~~~
140  *
141  * @param as The aerospike instance to use for this operation.
142  * @param err The as_error to be populated if an error occurs.
143  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
144  * @param key The key of the record.
145  * @param bins The bins to select. A NULL terminated array of NULL terminated strings.
146  * @param rec The record to be populated with the data from request.
147  *
148  * @return AEROSPIKE_OK if successful. Otherwise an error.
149  *
150  * @ingroup key_operations
151  */
152 as_status
154  aerospike* as, as_error* err, const as_policy_read* policy, const as_key* key,
155  const char* bins[], as_record** rec
156  );
157 
158 /**
159  * Asynchronously lookup a record by key, then return specified bins.
160  *
161  * ~~~~~~~~~~{.c}
162  * void my_listener(as_error* err, as_record* record, void* udata, as_event_loop* event_loop)
163  * {
164  * if (err) {
165  * printf("Command failed: %d %s\n", err->code, err->message);
166  * return;
167  * }
168  * // Process record bins
169  * // Do not call as_record_destroy() because the calling function will do that for you.
170  * }
171  *
172  * char* select[] = {"bin1", "bin2", "bin3", NULL};
173  *
174  * as_key key;
175  * as_key_init(&key, "ns", "set", "key");
176  *
177  * as_status status = aerospike_key_select_async(&as, &err, NULL, &key, select, my_listener, NULL, NULL, NULL);
178  * ~~~~~~~~~~
179  *
180  * @param as The aerospike instance to use for this operation.
181  * @param err The as_error to be populated if an error occurs.
182  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
183  * @param key The key of the record.
184  * @param bins The bins to select. A NULL terminated array of NULL terminated strings.
185  * @param listener User function to be called with command results.
186  * @param udata User data to be forwarded to user callback.
187  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
188  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
189  * has been sent to the server. This allows for issuing the next command even before receiving a
190  * result for the current command.
191  *
192  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
193  *
194  * @ingroup key_operations
195  */
196 as_status
198  aerospike* as, as_error* err, const as_policy_read* policy, const as_key* key, const char* bins[],
199  as_async_record_listener listener, void* udata, as_event_loop* event_loop, as_pipe_listener pipe_listener
200  );
201 
202 /**
203  * Check if a record exists in the cluster via its key. The record's metadata
204  * will be populated if the record exists.
205  *
206  * ~~~~~~~~~~{.c}
207  * as_key key;
208  * as_key_init(&key, "ns", "set", "key");
209  *
210  * as_record* rec = NULL;
211  * if (aerospike_key_exists(&as, &err, NULL, &key, &rec) != AEROSPIKE_OK) {
212  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
213  * }
214  * else {
215  * if (rec) {
216  * printf("Record exists.");
217  * as_record_destroy(rec);
218  * }
219  * else {
220  * printf("Record doesn't exist.");
221  * }
222  * }
223  * ~~~~~~~~~~
224  *
225  * @param as The aerospike instance to use for this operation.
226  * @param err The as_error to be populated if an error occurs.
227  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
228  * @param key The key of the record.
229  * @param rec The metadata will be populated if the record exists.
230  *
231  * @return AEROSPIKE_OK if successful. AEROSPIKE_ERR_RECORD_NOT_FOUND if not found. Otherwise an error.
232  *
233  * @ingroup key_operations
234  */
235 as_status
237  aerospike* as, as_error* err, const as_policy_read* policy, const as_key* key, as_record** rec
238  );
239 
240 /**
241  * Asynchronously check if a record exists in the cluster via its key. The record's metadata
242  * will be populated if the record exists.
243  *
244  * ~~~~~~~~~~{.c}
245  * void my_listener(as_error* err, as_record* record, void* udata, as_event_loop* event_loop)
246  * {
247  * if (err) {
248  * printf("Command failed: %d %s\n", err->code, err->message);
249  * return;
250  * }
251  * if (record) {
252  * printf("Record exists.");
253  * // Do not call as_record_destroy() because the calling function will do that for you.
254  * }
255  * else {
256  * printf("Record doesn't exist.");
257  * }
258  * }
259  *
260  * as_key key;
261  * as_key_init(&key, "ns", "set", "key");
262  *
263  * as_status status = aerospike_key_exists_async(&as, &err, NULL, &key, my_listener, NULL, NULL, NULL);
264  * ~~~~~~~~~~
265  *
266  * @param as The aerospike instance to use for this operation.
267  * @param err The as_error to be populated if an error occurs.
268  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
269  * @param key The key of the record.
270  * @param listener User function to be called with command results.
271  * @param udata User data to be forwarded to user callback.
272  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
273  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
274  * has been sent to the server. This allows for issuing the next command even before receiving a
275  * result for the current command.
276  *
277  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
278  *
279  * @ingroup key_operations
280  */
281 as_status
283  aerospike* as, as_error* err, const as_policy_read* policy, const as_key* key,
284  as_async_record_listener listener, void* udata, as_event_loop* event_loop,
285  as_pipe_listener pipe_listener
286  );
287 
288 /**
289  * Store a record in the cluster.
290  *
291  * ~~~~~~~~~~{.c}
292  * as_key key;
293  * as_key_init(&key, "ns", "set", "key");
294  *
295  * as_record rec;
296  * as_record_init(&rec, 2);
297  * as_record_set_str(&rec, "bin1", "abc");
298  * as_record_set_int64(&rec, "bin2", 123);
299  *
300  * if (aerospike_key_put(&as, &err, NULL, &key, &rec) != AEROSPIKE_OK) {
301  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
302  * }
303  * as_record_destroy(&rec);
304  * ~~~~~~~~~~
305  *
306  * @param as The aerospike instance to use for this operation.
307  * @param err The as_error to be populated if an error occurs.
308  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
309  * @param key The key of the record.
310  * @param rec The record containing the data to be written.
311  *
312  * @return AEROSPIKE_OK if successful. Otherwise an error.
313  *
314  * @ingroup key_operations
315  */
316 as_status
318  aerospike* as, as_error* err, const as_policy_write* policy, const as_key* key, as_record* rec
319  );
320 
321 /**
322  * Asynchronously store a record in the cluster.
323  *
324  * ~~~~~~~~~~{.c}
325  * void my_listener(as_error* err, void* udata, as_event_loop* event_loop)
326  * {
327  * if (err) {
328  * printf("Command failed: %d %s\n", err->code, err->message);
329  * return;
330  * }
331  * printf("Command succeeded\n");
332  * }
333  *
334  * as_key key;
335  * as_key_init(&key, "ns", "set", "key");
336  *
337  * as_record rec;
338  * as_record_init(&rec, 2);
339  * as_record_set_str(&rec, "bin1", "abc");
340  * as_record_set_int64(&rec, "bin2", 123);
341  *
342  * as_status status = aerospike_key_put_async(&as, &err, NULL, &key, &rec, my_listener, NULL, NULL, NULL);
343  * as_record_destroy(&rec);
344  * ~~~~~~~~~~
345  *
346  * @param as The aerospike instance to use for this operation.
347  * @param err The as_error to be populated if an error occurs.
348  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
349  * @param key The key of the record.
350  * @param rec The record containing the data to be written.
351  * @param listener User function to be called with command results.
352  * @param udata User data to be forwarded to user callback.
353  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
354  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
355  * has been sent to the server. This allows for issuing the next command even before receiving a
356  * result for the current command.
357  *
358  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
359  *
360  * @ingroup key_operations
361  */
362 as_status
364  aerospike* as, as_error* err, const as_policy_write* policy, const as_key* key, as_record* rec,
365  as_async_write_listener listener, void* udata, as_event_loop* event_loop, as_pipe_listener pipe_listener
366  );
367 
368 /**
369  * Remove a record from the cluster.
370  *
371  * ~~~~~~~~~~{.c}
372  * as_key key;
373  * as_key_init(&key, "ns", "set", "key");
374  *
375  * if (aerospike_key_remove(&as, &err, NULL, &key) != AEROSPIKE_OK) {
376  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
377  * }
378  * ~~~~~~~~~~
379  *
380  * @param as The aerospike instance to use for this operation.
381  * @param err The as_error to be populated if an error occurs.
382  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
383  * @param key The key of the record.
384  *
385  * @return AEROSPIKE_OK if successful and AEROSPIKE_ERR_RECORD_NOT_FOUND if the record was not found. Otherwise an error.
386  *
387  * @ingroup key_operations
388  */
389 as_status
391  aerospike* as, as_error* err, const as_policy_remove* policy, const as_key* key
392  );
393 
394 /**
395  * Asynchronously remove a record from the cluster.
396  *
397  * ~~~~~~~~~~{.c}
398  * void my_listener(as_error* err, void* udata, as_event_loop* event_loop)
399  * {
400  * if (err) {
401  * printf("Command failed: %d %s\n", err->code, err->message);
402  * return;
403  * }
404  * printf("Command succeeded\n");
405  * }
406  *
407  * as_key key;
408  * as_key_init(&key, "ns", "set", "key");
409  *
410  * as_status status = aerospike_key_remove(&as, &err, NULL, &key, my_listener, NULL, NULL, NULL);
411  * ~~~~~~~~~~
412  *
413  * @param as The aerospike instance to use for this operation.
414  * @param err The as_error to be populated if an error occurs.
415  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
416  * @param key The key of the record.
417  * @param listener User function to be called with command results.
418  * @param udata User data to be forwarded to user callback.
419  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
420  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
421  * has been sent to the server. This allows for issuing the next command even before receiving a
422  * result for the current command.
423  *
424  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
425  *
426  * @ingroup key_operations
427  */
428 as_status
430  aerospike* as, as_error* err, const as_policy_remove* policy, const as_key* key,
431  as_async_write_listener listener, void* udata, as_event_loop* event_loop,
432  as_pipe_listener pipe_listener
433  );
434 
435 /**
436  * Lookup a record by key, then perform specified operations.
437  *
438  * ~~~~~~~~~~{.c}
439  * as_key key;
440  * as_key_init(&key, "ns", "set", "key");
441  *
442  * as_operations ops;
443  * as_operations_inita(&ops,3);
444  * as_operations_add_incr(&ops, "bin1", 456);
445  * as_operations_add_append_str(&ops, "bin2", "def");
446  * as_operations_add_read(&ops, "bin1")
447  *
448  * as_record * rec = NULL;
449  *
450  * if (aerospike_key_operate(&as, &err, NULL, &key, &ops, &rec) != AEROSPIKE_OK) {
451  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
452  * }
453  * else {
454  * as_record_destroy(rec);
455  * }
456  * as_operations_destroy(&ops);
457  * ~~~~~~~~~~
458  *
459  * @param as The aerospike instance to use for this operation.
460  * @param err The as_error to be populated if an error occurs.
461  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
462  * @param key The key of the record.
463  * @param ops The operations to perform on the record.
464  * @param rec The record to be populated with the data from AS_OPERATOR_READ operations.
465  *
466  * @return AEROSPIKE_OK if successful. Otherwise an error.
467  *
468  * @ingroup key_operations
469  */
470 as_status
472  aerospike* as, as_error* err, const as_policy_operate* policy, const as_key* key,
473  const as_operations* ops, as_record** rec
474  );
475 
476 /**
477  * Asynchronously lookup a record by key, then perform specified operations.
478  *
479  * ~~~~~~~~~~{.c}
480  * void my_listener(as_error* err, as_record* record, void* udata, as_event_loop* event_loop)
481  * {
482  * if (err) {
483  * printf("Command failed: %d %s\n", err->code, err->message);
484  * return;
485  * }
486  * // Process record bins
487  * // Do not call as_record_destroy() because the calling function will do that for you.
488  * }
489  *
490  * as_key key;
491  * as_key_init(&key, "ns", "set", "key");
492  *
493  * as_operations ops;
494  * as_operations_inita(&ops,3);
495  * as_operations_add_incr(&ops, "bin1", 456);
496  * as_operations_add_append_str(&ops, "bin2", "def");
497  * as_operations_add_read(&ops, "bin1")
498  *
499  * as_status status = aerospike_key_operate(&as, &err, NULL, &key, &ops, my_listener, NULL, NULL, NULL);
500  * as_operations_destroy(&ops);
501  * ~~~~~~~~~~
502  *
503  * @param as The aerospike instance to use for this operation.
504  * @param err The as_error to be populated if an error occurs.
505  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
506  * @param key The key of the record.
507  * @param ops The operations to perform on the record.
508  * @param listener User function to be called with command results.
509  * @param udata User data to be forwarded to user callback.
510  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
511  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
512  * has been sent to the server. This allows for issuing the next command even before receiving a
513  * result for the current command.
514  *
515  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
516  *
517  * @ingroup key_operations
518  */
519 as_status
521  aerospike* as, as_error* err, const as_policy_operate* policy, const as_key* key, const as_operations* ops,
522  as_async_record_listener listener, void* udata, as_event_loop* event_loop, as_pipe_listener pipe_listener
523  );
524 
525 /**
526  * Lookup a record by key, then apply the UDF.
527  *
528  * ~~~~~~~~~~{.c}
529  * as_key key;
530  * as_key_init(&key, "ns", "set", "key");
531  *
532  * as_arraylist args;
533  * as_arraylist_inita(&args, 2);
534  * as_arraylist_append_int64(&args, 1);
535  * as_arraylist_append_int64(&args, 2);
536  *
537  * as_val * res = NULL;
538  *
539  * if (aerospike_key_apply(&as, &err, NULL, &key, "math", "add", &args, &res) != AEROSPIKE_OK) {
540  * printf("error(%d) %s at [%s:%d]", err.code, err.message, err.file, err.line);
541  * }
542  * else {
543  * as_val_destroy(res);
544  * }
545  *
546  * as_arraylist_destroy(&args);
547  * ~~~~~~~~~~
548  *
549  *
550  * @param as The aerospike instance to use for this operation.
551  * @param err The as_error to be populated if an error occurs.
552  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
553  * @param key The key of the record.
554  * @param module The module containing the function to execute.
555  * @param function The function to execute.
556  * @param arglist The arguments for the function.
557  * @param result The return value from the function.
558  *
559  * @return AEROSPIKE_OK if successful. Otherwise an error.
560  *
561  * @ingroup key_operations
562  */
564  aerospike * as, as_error * err, const as_policy_apply * policy,
565  const as_key * key,
566  const char * module, const char * function, as_list * arglist,
567  as_val ** result
568  );
569 
570 /**
571  * Asynchronously lookup a record by key, then apply the UDF.
572  *
573  * ~~~~~~~~~~{.c}
574  * void my_listener(as_error* err, as_val* val, void* udata, as_event_loop* event_loop)
575  * {
576  * if (err) {
577  * printf("Command failed: %d %s\n", err->code, err->message);
578  * return;
579  * }
580  * // Process value. The calling function will call as_val_destroy().
581  * // If the value needs to be preserved, bump up the reference count using as_val_reserve()
582  * // and call as_val_destroy() when done with the value.
583  * }
584  *
585  * as_key key;
586  * as_key_init(&key, "ns", "set", "key");
587  *
588  * as_arraylist args;
589  * as_arraylist_inita(&args, 2);
590  * as_arraylist_append_int64(&args, 1);
591  * as_arraylist_append_int64(&args, 2);
592  *
593  * as_status status = aerospike_key_apply(&as, &err, NULL, &key, "math", "add", &args, my_listener, NULL, NULL, NULL);
594  * as_arraylist_destroy(&args);
595  * ~~~~~~~~~~
596  *
597  * @param as The aerospike instance to use for this operation.
598  * @param err The as_error to be populated if an error occurs.
599  * @param policy The policy to use for this operation. If NULL, then the default policy will be used.
600  * @param key The key of the record.
601  * @param module The module containing the function to execute.
602  * @param function The function to execute.
603  * @param arglist The arguments for the function.
604  * @param listener User function to be called with command results.
605  * @param udata User data to be forwarded to user callback.
606  * @param event_loop Event loop assigned to run this command. If NULL, an event loop will be choosen by round-robin.
607  * @param pipe_listener Enables command pipelining, if not NULL. The given callback is invoked after the current command
608  * has been sent to the server. This allows for issuing the next command even before receiving a
609  * result for the current command.
610  *
611  * @return AEROSPIKE_OK if async command succesfully queued. Otherwise an error.
612  *
613  * @ingroup key_operations
614  */
615 as_status
617  aerospike* as, as_error* err, const as_policy_apply* policy, const as_key* key,
618  const char* module, const char* function, as_list* arglist,
619  as_async_value_listener listener, void* udata, as_event_loop* event_loop,
620  as_pipe_listener pipe_listener
621  );
622 
623 /**
624  * Do the connected servers support the new floating point type.
625  * The cluster must already be connected (aerospike_connect()) prior to making this call.
626  */
627 bool
629 
630 /**
631  * Do the connected servers support geospatial data and queries.
632  * The cluster must already be connected (aerospike_connect()) prior to making this call.
633  */
634 bool
636 
637 #ifdef __cplusplus
638 } // end extern "C"
639 #endif
as_status aerospike_key_put(aerospike *as, as_error *err, const as_policy_write *policy, const as_key *key, as_record *rec)
void(* as_async_value_listener)(as_error *err, as_val *val, void *udata, as_event_loop *event_loop)
Definition: as_listener.h:62
as_status aerospike_key_apply_async(aerospike *as, as_error *err, const as_policy_apply *policy, const as_key *key, const char *module, const char *function, as_list *arglist, as_async_value_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)
as_status
Definition: as_status.h:30
as_status aerospike_key_get(aerospike *as, as_error *err, const as_policy_read *policy, const as_key *key, as_record **rec)
as_status aerospike_key_operate(aerospike *as, as_error *err, const as_policy_operate *policy, const as_key *key, const as_operations *ops, as_record **rec)
void(* as_async_record_listener)(as_error *err, as_record *record, void *udata, as_event_loop *event_loop)
Definition: as_listener.h:49
Definition: as_val.h:57
as_status aerospike_key_exists_async(aerospike *as, as_error *err, const as_policy_read *policy, const as_key *key, as_async_record_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)
as_status aerospike_key_apply(aerospike *as, as_error *err, const as_policy_apply *policy, const as_key *key, const char *module, const char *function, as_list *arglist, as_val **result)
as_status aerospike_key_remove_async(aerospike *as, as_error *err, const as_policy_remove *policy, const as_key *key, as_async_write_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)
as_status aerospike_key_get_async(aerospike *as, as_error *err, const as_policy_read *policy, const as_key *key, as_async_record_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)
as_status aerospike_key_exists(aerospike *as, as_error *err, const as_policy_read *policy, const as_key *key, as_record **rec)
as_status aerospike_key_select_async(aerospike *as, as_error *err, const as_policy_read *policy, const as_key *key, const char *bins[], as_async_record_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)
as_status aerospike_key_select(aerospike *as, as_error *err, const as_policy_read *policy, const as_key *key, const char *bins[], as_record **rec)
void(* as_async_write_listener)(as_error *err, void *udata, as_event_loop *event_loop)
Definition: as_listener.h:36
void(* as_pipe_listener)(void *udata, as_event_loop *event_loop)
Definition: as_listener.h:73
bool aerospike_has_geo(aerospike *as)
as_status aerospike_key_operate_async(aerospike *as, as_error *err, const as_policy_operate *policy, const as_key *key, const as_operations *ops, as_async_record_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)
as_status aerospike_key_remove(aerospike *as, as_error *err, const as_policy_remove *policy, const as_key *key)
bool aerospike_has_double(aerospike *as)
Definition: as_key.h:199
as_status aerospike_key_put_async(aerospike *as, as_error *err, const as_policy_write *policy, const as_key *key, as_record *rec, as_async_write_listener listener, void *udata, as_event_loop *event_loop, as_pipe_listener pipe_listener)