Main Page
Related Pages
Modules
Data Structures
Files
File List
Globals
All
Data Structures
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Groups
Pages
aerospike
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
>
36
#include <
aerospike/as_operations.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
*/
76
as_status
77
aerospike_key_get
(
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
117
aerospike_key_get_async
(
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
153
aerospike_key_select
(
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
197
aerospike_key_select_async
(
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
236
aerospike_key_exists
(
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
282
aerospike_key_exists_async
(
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
317
aerospike_key_put
(
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
363
aerospike_key_put_async
(
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
390
aerospike_key_remove
(
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
429
aerospike_key_remove_async
(
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
471
aerospike_key_operate
(
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
520
aerospike_key_operate_async
(
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
*/
563
as_status
aerospike_key_apply
(
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
616
aerospike_key_apply_async
(
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
628
aerospike_has_double
(
aerospike
* as);
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
635
aerospike_has_geo
(
aerospike
* as);
636
637
/**
638
* @cond SKIP_DOXYGEN
639
* doxygen skips this section till endcond
640
*/
641
as_status
642
aerospike_key_put_async_ex(
643
aerospike
* as,
as_error
* err,
const
as_policy_write
* policy,
const
as_key
* key,
as_record
* rec,
644
as_async_write_listener
listener,
void
* udata,
as_event_loop
* event_loop,
as_pipe_listener
pipe_listener,
645
size_t
* length,
size_t
* comp_length
646
);
647
648
as_status
649
aerospike_key_remove_async_ex(
650
aerospike
* as,
as_error
* err,
const
as_policy_remove
* policy,
const
as_key
* key,
651
as_async_write_listener
listener,
void
* udata,
as_event_loop
* event_loop,
652
as_pipe_listener
pipe_listener,
size_t
* length
653
);
654
/**
655
* @endcond
656
*/
657
658
#ifdef __cplusplus
659
}
// end extern "C"
660
#endif