HyperDex provides Node bindings under the module hyperdex-client. This library wraps the HyperDex C Client library and enables use of native Javascript data types.
This module was re-introduced in HyperDex 1.2.0.
The HyperDex Node.js Binding must be built and installed after HyperDex is built and installed. After installing HyperDex, you can build the Node.js bindings from either source or git checkout with:
% cd bindings/node.js % node rebuild
All client operation are defined in the hyperdex_client module. You can access this in your program with:
var hyperdex_client = require(’hyperdex-client’);
The following is a minimal application that stores the value ”Hello World” and then immediately retrieves the value:
var hyperdex_client = require(’hyperdex-client’) var c = new hyperdex_client.Client(’127.0.0.1’, 1982); function get_callback(obj, err) { if (err) { console.log(’error ’ + err); } console.log(’get: ’ + obj); } function put_callback(success, err) { if (err) { console.log(’error ’ + err); } console.log(’put: ’ + success); c.get(’kv’, ’k’, get_callback); } c.put(’kv’, ’k’, {v: ’Hello World!’}, put_callback);
You can run this example with:
% node hello-world.js put: true get: [object Object]
Right away, there are several points worth noting in this example:
HyperDex provides native integration with the asynchronous world of Node.js. You can issue several operations concurrently, and Node.js and HyperDex will work together to complete these operations quickly and efficiently. It’s easy to work with data concurrently. A common pattern is to keep a constant number of operations outstanding concurrently:
var hyperdex_client = require(’hyperdex-client’) var c = new hyperdex_client.Client(’127.0.0.1’, 1982); var NUMBER = 10000000 var CONCURRENT = 1000 var i = 0 function put (success, err) { if (i < THRESH) { c.put(’kv’, new String(i), {v: new String(i), put); } i += 1; } for (var x = 0; x < CONCURRENT; ++x) { put(); }
The Node bindings automatically manage conversion of data types from Javascript to HyperDex types, enabling applications to be written in idiomatic Javascript.
This section shows examples of Java data structures that are recognized by HyperDex. The examples here are for illustration purposes and are not exhaustive. Strings The HyperDex client recognizes Javascript strings and buffers and automatically converts them to HyperDex strings. For example, the following two calls have the same effect:
c.put("kv", "somekey", {v: "somevalue"}, function (success, err) {}); c.put("kv", "somekey", {v: new Buffer("somevalue")}, function (success, err) {});Integers The HyperDex client recognizes Javascript numbers and can convert them to HyperDex integers. For example:
c.put("kv", "somekey", {v: c.asInt(42)}, function (success, err) {});Floats The HyperDex client recognizes Javascript numbers and can convert them to HyperDex floats. For example:
c.put("kv", "somekey", {v: c.asFloat(3.1415)}, function (success, err) {});Lists The HyperDex client permits users to construct HyperDex lists from Javascript. For example:
c.put("kv", "somekey", {v: c.asList([’a’, ’b’, ’c’])}, function (success, err) {}); c.put("kv", "somekey", {v: c.asList([1, 2, 3])}, function (success, err) {}); c.put("kv", "somekey", {v: c.asList([1.0, 0.5, 0.25])}, function (success, err) {});Sets The HyperDex client permits users to construct HyperDex sets from Javascript. For example:
c.put("kv", "somekey", {v: c.asSet([’a’, ’b’, ’c’])}, function (success, err) {}); c.put("kv", "somekey", {v: c.asSet([1, 2, 3])}, function (success, err) {}); c.put("kv", "somekey", {v: c.asSet([1.0, 0.5, 0.25])}, function (success, err) {});Maps The HyperDex client permits users to construct HyperDex maps from Javascript. For example:
c.put("kv", "somekey", {v1: c.asMap([["k", "v"]])}, function(success, err) {}); c.put("kv", "somekey", {v2: c.asMap([[1, 2]])}, function(success, err) {}); c.put("kv", "somekey", {v3: c.asMap([[3.14, 0.125]])}, function(success, err) {}); c.put("kv", "somekey", {v4: c.asMap([["a", 1]])}, function(success, err) {});
Attributes in Node are specified in the form of a Javascript object. As you can see in the examples above, attributes are specified in the form:
{name: "value"}
Retrieve an object from space using key. Definition:
get(spacename, key, function (obj, done, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Retrieve part of an object from space using key. Only the specified attributes of the object will be returned to the client. Definition:
get_partial(spacename, key, attributenames, function (obj, done, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store or update an object by key. The object’s attributes will be set to the values specified by attrs. If the object exists, it will be updated and all existing values not altered by attrs will be preserved. If the object does not exist, a new object will be created, with its attributes initialized to their default values. Definition:
put(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Conditionally update an the object stored under key in space. Existing values will be overwitten with the values specified by attrs. Values not specified by attrs will remain unchanged. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_put(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Update all objects stored in space that match checks. Existing values will be overwitten with the values specified by attrs. Values not specified by attrs will remain unchanged.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_put(spacename, predicates, attributes, function (count, err) {})Parameters:
Store or object under key in space if and only if the operation creates a new object. The object’s attributes will be set to the values specified by attrs; any attributes not specified by attrs will be initialized to their defaults. If the object exists, the operation will fail with CMPFAIL. Definition:
put_if_not_exist(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Delete key from space. If no object exists, the operation will fail with NOTFOUND. Definition:
del(spacename, key, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Conditionally delete the object stored under key from space. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_del(spacename, key, predicates, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Delete all objects that match the specified checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_del(spacename, predicates, function (count, err) {})Parameters:
Add the specified number to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_add(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Add the specified number to the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_add(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Add the specified number to the existing value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_add(spacename, predicates, attributes, function (count, err) {})Parameters:
Subtract the specified number from the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_sub(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Subtract the specified number from the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_sub(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Subtract the specified number from the existing value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_sub(spacename, predicates, attributes, function (count, err) {})Parameters:
Multiply the existing value by the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_mul(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Multiply the existing value by the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_mul(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Multiply the existing value by the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_mul(spacename, predicates, attributes, function (count, err) {})Parameters:
Divide the existing value by the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_div(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Divide the existing value by the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_div(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Divide the existing value by the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_div(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the existing value modulo the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_mod(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the existing value modulo the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_mod(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the existing value modulo the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_mod(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the bitwise AND of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_and(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise AND of the existing value and the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_and(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise AND of the existing value and the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_and(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the bitwise OR of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_or(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise OR of the existing value and the specified number for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_or(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise OR of the existing value and the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_or(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the bitwise XOR of the existing value and the specified number for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_xor(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise XOR of the existing value and the specified number for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_xor(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise XOR of the existing value and the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_xor(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the minimum of the existing value and the provided value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_min(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the minimum of the existing value and the provided value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_min(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the minimum of the existing value and the provided value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_min(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the maximum of the existing value and the provided value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
atomic_max(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the maximum of the existing value and the provided value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_atomic_max(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the maximum of the existing value and the provided value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_atomic_max(spacename, predicates, attributes, function (count, err) {})Parameters:
Prepend the specified string to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
string_prepend(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Prepend the specified string to the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_string_prepend( spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Prepend the specified string to the existing value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_string_prepend(spacename, predicates, attributes, function (count, err) {})Parameters:
Append the specified string to the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
string_append(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Append the specified string to the existing value for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_string_append( spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Append the specified string to the existing value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_string_append(spacename, predicates, attributes, function (count, err) {})Parameters:
Push the specified value onto the front of the list for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
list_lpush(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Push the specified value onto the front of the list for each attribute if and only if checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_list_lpush(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Push the specified value onto the front of the list for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_list_lpush(spacename, predicates, attributes, function (count, err) {})Parameters:
Push the specified value onto the back of the list for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
list_rpush(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Push the specified value onto the back of the list for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_list_rpush(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Push the specified value onto the back of the list for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_list_rpush(spacename, predicates, attributes, function (count, err) {})Parameters:
Add the specified value to the set for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
set_add(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Add the specified value to the set for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_set_add(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Add the specified value to the set for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_set_add(spacename, predicates, attributes, function (count, err) {})Parameters:
Remove the specified value from the set. If the value is not contained within the set, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
set_remove(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Remove the specified value from the set if and only if the checks hold on the object. If the value is not contained within the set, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_set_remove(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Remove the specified value from the set for each object in space that matches checks. If the value is not contained within the set, this operation will do nothing.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_set_remove(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the intersection of the specified set and the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
set_intersect(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the intersection of the specified set and the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_set_intersect( spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the intersection of the specified set and the existing value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_set_intersect(spacename, predicates, attributes, function (count, err) {})Parameters:
Store the union of the specified set and the existing value for each attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
set_union(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the union of the specified set and the existing value for each attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_set_union(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the union of the specified set and the existing value for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_set_union(spacename, predicates, attributes, function (count, err) {})Parameters:
Move a field within a document from one name to another. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
document_rename(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Move a field within a document from one name to another if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_document_rename( spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Move a field within a document from one name to another for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_document_rename(spacename, predicates, attributes, function (count, err) {})Parameters:
Remove a field or object from a document. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
document_unset(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Remove a field or object from a document if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_document_unset( spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Remove a field or object from a document for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_document_unset(spacename, predicates, attributes, function (count, err) {})Parameters:
Insert a key-value pair into the map specified by each map-attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_add(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Insert a key-value pair into the map specified by each map-attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_add(spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Insert a key-value pair into the map specified by each map-attribute for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_add(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Remove a key-value pair from the map specified by each attribute. If there is no pair with the specified key within the map, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_remove(spacename, key, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Remove a key-value pair from the map specified by each attribute if and only if checks hold on the object. If there is no pair with the specified key within the map, this operation will do nothing. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_remove(spacename, key, predicates, attributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Remove a key-value pair from the map specified by each attribute for each object in space that matches checks. If there is no pair with the specified key within the map, this operation will do nothing.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_remove(spacename, predicates, attributes, function (count, err) {})Parameters:
Add the specified number to the value of a key-value pair within each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_add(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Add the specified number to the value of a key-value pair within each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_add( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Add the specified number to the value of a key-value pair within each map for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_add(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Subtract the specified number from the value of a key-value pair within each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_sub(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Subtract the specified number from the value of a key-value pair within each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_sub( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Subtract the specified number from the value of a key-value pair within each map for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_sub(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Multiply the value of each key-value pair by the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_mul(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Multiply the value of each key-value pair by the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_mul( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Multiply the value of each key-value pair by the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_mul(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Divide the value of each key-value pair by the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_div(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Divide the value of each key-value pair by the specified number for each map if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_div( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Divide the value of each key-value pair by the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_div(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Store the value of the key-value pair modulo the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_mod(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the value of the key-value pair modulo the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_mod( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the value of the key-value pair modulo the specified number for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_mod(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Store the bitwise AND of the value of the key-value pair and the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_and(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise AND of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_and( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise AND of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_and(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Store the bitwise OR of the value of the key-value pair and the specified number for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_or(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_or( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise OR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_or(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_xor(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_xor( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Store the bitwise XOR of the value of the key-value pair and the specified number for each map attribute for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_xor(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Prepend the specified string to the value of the key-value pair for each map. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_string_prepend(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Prepend the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_string_prepend( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Prepend the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_string_prepend( spacename, predicates, mapattributes, function (count, err) {})Parameters:
Append the specified string to the value of the key-value pair for each map attribute. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_string_append(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Append the specified string to the value of the key-value pair for each map attribute if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_string_append( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Append the specified string to the value of the key-value pair for each map attribute for each object in space that matches checks
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_string_append( spacename, predicates, mapattributes, function (count, err) {})Parameters:
Take the minium of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_min(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Take the minium of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_min( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Take the minium of the specified value and existing value for each key-value pair for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_min(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Take the maximum of the specified value and existing value for each key-value pair. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND. Definition:
map_atomic_max(spacename, key, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Take the maximum of the specified value and existing value for each key-value pair if and only if the checks hold on the object. This operation requires a pre-existing object in order to complete successfully. If no object exists, the operation will fail with NOTFOUND.
This operation will succeed if and only if the predicates specified by checks hold on the pre-existing object. If any of the predicates are not true for the existing object, then the operation will have no effect and fail with CMPFAIL.
All checks are atomic with the write. HyperDex guarantees that no other operation will come between validating the checks, and writing the new version of the object.. Definition:
cond_map_atomic_max( spacename, key, predicates, mapattributes, function (success, err) {})Parameters:
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Take the maximum of the specified value and existing value for each key-value pair for each object in space that matches checks.
This operation will only affect objects that match the provided checks. Objects that do not match checks will be unaffected by the group call. Each object that matches checks will be atomically updated with the check on the object. HyperDex guarantees that no object will be altered if the checks do not pass at the time of the write. Objects that are updated concurrently with the group call may or may not be updated; however, regardless of any other concurrent operations, the preceding guarantee will always hold. Definition:
group_map_atomic_max(spacename, predicates, mapattributes, function (count, err) {})Parameters:
Return all objects that match the specified checks. This operation behaves as an iterator and may return multiple objects from the single call. Definition:
search(spacename, predicates, function (obj, err) {})Parameters:
The second argument is a true/false value indicating whether the operation is complete. The callback will be called repeatedly until all objects are returned or encounter errors.
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Return all objects that match the specified checks, sorted according to attr. This operation behaves as an iterator and may return multiple objects from the single call. Definition:
sorted_search(spacename, predicates, sortby, limit, maxmin, function (obj, err) {})Parameters:
The second argument is a true/false value indicating whether the operation is complete. The callback will be called repeatedly until all objects are returned or encounter errors.
If the operation encounters any error, the error argument will be provided and will specify the error, in which case the first argument is undefined.
Count the number of objects that match the specified checks. This will return the number of objects counted by the search. If an error occurs during the count, the count may reflect a partial count. The real count will be higher than the returned value.
A count is the server-side equivalent of performing a search, and counting the number of objects that exist. For that reason, its efficiency closely follows that of search, except it will not transfer any objects over the network. Definition:
count(spacename, predicates, function (count, err) {})Parameters:
The HyperDex client module is signal-safe. Should a signal interrupt the client, it will raise an exception with status HYPERDEX_CLIENT_INTERRUPTED.
The Node module naturally integrates with the Node.js event loop. Each instance of Client registers itself with the Node event loop and makes callbacks as soon as events complete on the HyperDex side.
Put simply, a Node.js application can use Client instances in a straight-forward fashion without worrying about threading or manual integration.